Adding group principals to new dav endpoint

apps/dav/lib/connector/sabre/principal.php

@@ -33,22 +33,20 @@ namespace OCA\DAV\Connector\Sabre;
 use OCP\IUser;
 use OCP\IUserManager;
 use OCP\IConfig;
+use Sabre\DAV\Exception;
 use \Sabre\DAV\PropPatch;
+use Sabre\DAVACL\PrincipalBackend\BackendInterface;
 use Sabre\HTTP\URLUtil;
 
-class Principal implements \Sabre\DAVACL\PrincipalBackend\BackendInterface {
-	/** @var IConfig */
-	private $config;
+class Principal implements BackendInterface {
+
 	/** @var IUserManager */
 	private $userManager;
 
 	/**
-	 * @param IConfig $config
 	 * @param IUserManager $userManager
 	 */
-	public function __construct(IConfig $config,
-								IUserManager $userManager) {
-		$this->config = $config;
+	public function __construct(IUserManager $userManager) {
 		$this->userManager = $userManager;
 	}
 
@@ -108,13 +106,13 @@ class Principal implements \Sabre\DAVACL\PrincipalBackend\BackendInterface {
 	 *
 	 * @param string $principal
 	 * @return string[]
-	 * @throws \Sabre\DAV\Exception
+	 * @throws Exception
 	 */
 	public function getGroupMemberSet($principal) {
 		// TODO: for now the group principal has only one member, the user itself
 		$principal = $this->getPrincipalByPath($principal);
 		if (!$principal) {
-			throw new \Sabre\DAV\Exception('Principal not found');
+			throw new Exception('Principal not found');
 		}
 
 		return [$principal['uri']];
@@ -125,7 +123,7 @@ class Principal implements \Sabre\DAVACL\PrincipalBackend\BackendInterface {
 	 *
 	 * @param string $principal
 	 * @return array
-	 * @throws \Sabre\DAV\Exception
+	 * @throws Exception
 	 */
 	public function getGroupMembership($principal) {
 		list($prefix, $name) = URLUtil::splitPath($principal);
@@ -134,7 +132,7 @@ class Principal implements \Sabre\DAVACL\PrincipalBackend\BackendInterface {
 		if ($prefix === 'principals/users') {
 			$principal = $this->getPrincipalByPath($principal);
 			if (!$principal) {
-				throw new \Sabre\DAV\Exception('Principal not found');
+				throw new Exception('Principal not found');
 			}
 
 			// TODO: for now the user principal has only its own groups
@@ -157,10 +155,10 @@ class Principal implements \Sabre\DAVACL\PrincipalBackend\BackendInterface {
 	 *
 	 * @param string $principal
 	 * @param string[] $members
-	 * @throws \Sabre\DAV\Exception
+	 * @throws Exception
 	 */
 	public function setGroupMemberSet($principal, array $members) {
-		throw new \Sabre\DAV\Exception('Setting members of the group is not supported yet');
+		throw new Exception('Setting members of the group is not supported yet');
 	}
 
 	/**

apps/dav/lib/dav/groupprincipalbackend.php

@@ -0,0 +1,153 @@
+<?php
+
+namespace OCA\DAV\DAV;
+
+use OCP\IGroup;
+use OCP\IGroupManager;
+use Sabre\DAV\Exception;
+use \Sabre\DAV\PropPatch;
+use Sabre\DAVACL\PrincipalBackend\BackendInterface;
+
+class GroupPrincipalBackend implements BackendInterface {
+
+	const PRINCIPAL_PREFIX = 'principals/groups';
+
+	/** @var IGroupManager */
+	private $groupManager;
+
+	/**
+	 * @param IGroupManager $IGroupManager
+	 */
+	public function __construct(IGroupManager $IGroupManager) {
+		$this->groupManager = $IGroupManager;
+	}
+
+	/**
+	 * Returns a list of principals based on a prefix.
+	 *
+	 * This prefix will often contain something like 'principals'. You are only
+	 * expected to return principals that are in this base path.
+	 *
+	 * You are expected to return at least a 'uri' for every user, you can
+	 * return any additional properties if you wish so. Common properties are:
+	 *   {DAV:}displayname
+	 *
+	 * @param string $prefixPath
+	 * @return string[]
+	 */
+	public function getPrincipalsByPrefix($prefixPath) {
+		$principals = [];
+
+		if ($prefixPath === self::PRINCIPAL_PREFIX) {
+			foreach($this->groupManager->search('') as $user) {
+				$principals[] = $this->groupToPrincipal($user);
+			}
+		}
+
+		return $principals;
+	}
+
+	/**
+	 * Returns a specific principal, specified by it's path.
+	 * The returned structure should be the exact same as from
+	 * getPrincipalsByPrefix.
+	 *
+	 * @param string $path
+	 * @return array
+	 */
+	public function getPrincipalByPath($path) {
+		$elements = explode('/', $path);
+		if ($elements[0] !== 'principals') {
+			return null;
+		}
+		if ($elements[1] !== 'groups') {
+			return null;
+		}
+		$name = $elements[2];
+		$user = $this->groupManager->get($name);
+
+		if (!is_null($user)) {
+			return $this->groupToPrincipal($user);
+		}
+
+		return null;
+	}
+
+	/**
+	 * Returns the list of members for a group-principal
+	 *
+	 * @param string $principal
+	 * @return string[]
+	 * @throws Exception
+	 */
+	public function getGroupMemberSet($principal) {
+		// TODO: implement if we want that
+		return [];
+	}
+
+	/**
+	 * Returns the list of groups a principal is a member of
+	 *
+	 * @param string $principal
+	 * @return array
+	 * @throws Exception
+	 */
+	public function getGroupMembership($principal) {
+		return [];
+	}
+
+	/**
+	 * Updates the list of group members for a group principal.
+	 *
+	 * The principals should be passed as a list of uri's.
+	 *
+	 * @param string $principal
+	 * @param string[] $members
+	 * @throws Exception
+	 */
+	public function setGroupMemberSet($principal, array $members) {
+		throw new Exception('Setting members of the group is not supported yet');
+	}
+
+	/**
+	 * @param string $path
+	 * @param PropPatch $propPatch
+	 * @return int
+	 */
+	function updatePrincipal($path, PropPatch $propPatch) {
+		return 0;
+	}
+
+	/**
+	 * @param string $prefixPath
+	 * @param array $searchProperties
+	 * @param string $test
+	 * @return array
+	 */
+	function searchPrincipals($prefixPath, array $searchProperties, $test = 'allof') {
+		return [];
+	}
+
+	/**
+	 * @param string $uri
+	 * @param string $principalPrefix
+	 * @return string
+	 */
+	function findByUri($uri, $principalPrefix) {
+		return '';
+	}
+
+	/**
+	 * @param IGroup $group
+	 * @return array
+	 */
+	protected function groupToPrincipal($group) {
+		$groupId = $group->getGID();
+		$principal = [
+				'uri' => "principals/groups/$groupId",
+				'{DAV:}displayname' => $groupId,
+		];
+
+		return $principal;
+	}
+}

apps/dav/lib/rootcollection.php

@@ -6,6 +6,7 @@ use OCA\DAV\CalDAV\CalDavBackend;
 use OCA\DAV\CardDAV\AddressBookRoot;
 use OCA\DAV\CardDAV\CardDavBackend;
 use OCA\DAV\Connector\Sabre\Principal;
+use OCA\DAV\DAV\GroupPrincipalBackend;
 use OCA\DAV\DAV\SystemPrincipalBackend;
 use Sabre\CalDAV\CalendarRoot;
 use Sabre\CalDAV\Principal\Collection;
@@ -16,22 +17,26 @@ class RootCollection extends SimpleCollection {
 	public function __construct() {
 		$config = \OC::$server->getConfig();
 		$db = \OC::$server->getDatabaseConnection();
-		$principalBackend = new Principal(
-				$config,
-				\OC::$server->getUserManager()
+		$userPrincipalBackend = new Principal(
+			\OC::$server->getUserManager()
+		);
+		$groupPrincipalBackend = new GroupPrincipalBackend(
+			\OC::$server->getGroupManager()
 		);
 		// as soon as debug mode is enabled we allow listing of principals
 		$disableListing = !$config->getSystemValue('debug', false);
 
 		// setup the first level of the dav tree
-		$userPrincipals = new Collection($principalBackend, 'principals/users');
+		$userPrincipals = new Collection($userPrincipalBackend, 'principals/users');
 		$userPrincipals->disableListing = $disableListing;
+		$groupPrincipals = new Collection($groupPrincipalBackend, 'principals/groups');
+		$groupPrincipals->disableListing = $disableListing;
 		$systemPrincipals = new Collection(new SystemPrincipalBackend(), 'principals/system');
 		$systemPrincipals->disableListing = $disableListing;
-		$filesCollection = new Files\RootCollection($principalBackend, 'principals/users');
+		$filesCollection = new Files\RootCollection($userPrincipalBackend, 'principals/users');
 		$filesCollection->disableListing = $disableListing;
 		$caldavBackend = new CalDavBackend($db);
-		$calendarRoot = new CalendarRoot($principalBackend, $caldavBackend, 'principals/users');
+		$calendarRoot = new CalendarRoot($userPrincipalBackend, $caldavBackend, 'principals/users');
 		$calendarRoot->disableListing = $disableListing;
 		$systemTagCollection = new SystemTag\SystemTagsByIdCollection(
 			\OC::$server->getSystemTagManager()
@@ -41,17 +46,18 @@ class RootCollection extends SimpleCollection {
 			\OC::$server->getSystemTagObjectMapper()
 		);
 
-		$usersCardDavBackend = new CardDavBackend($db, $principalBackend, \OC::$server->getLogger());
-		$usersAddressBookRoot = new AddressBookRoot($principalBackend, $usersCardDavBackend, 'principals/users');
+		$usersCardDavBackend = new CardDavBackend($db, $userPrincipalBackend, \OC::$server->getLogger());
+		$usersAddressBookRoot = new AddressBookRoot($userPrincipalBackend, $usersCardDavBackend, 'principals/users');
 		$usersAddressBookRoot->disableListing = $disableListing;
 
-		$systemCardDavBackend = new CardDavBackend($db, $principalBackend, \OC::$server->getLogger());
+		$systemCardDavBackend = new CardDavBackend($db, $userPrincipalBackend, \OC::$server->getLogger());
 		$systemAddressBookRoot = new AddressBookRoot(new SystemPrincipalBackend(), $systemCardDavBackend, 'principals/system');
 		$systemAddressBookRoot->disableListing = $disableListing;
 
 		$children = [
 				new SimpleCollection('principals', [
 						$userPrincipals,
+						$groupPrincipals,
 						$systemPrincipals]),
 				$filesCollection,
 				$calendarRoot,

apps/dav/tests/unit/connector/sabre/principal.php

@@ -17,18 +17,14 @@ use OCP\IConfig;
 class Principal extends \Test\TestCase {
 	/** @var IUserManager */
 	private $userManager;
-	/** @var IConfig */
-	private $config;
 	/** @var \OCA\DAV\Connector\Sabre\Principal */
 	private $connector;
 
 	public function setUp() {
 		$this->userManager = $this->getMockBuilder('\OCP\IUserManager')
 			->disableOriginalConstructor()->getMock();
-		$this->config = $this->getMockBuilder('\OCP\IConfig')
-			->disableOriginalConstructor()->getMock();
 
-		$this->connector = new \OCA\DAV\Connector\Sabre\Principal($this->config, $this->userManager);
+		$this->connector = new \OCA\DAV\Connector\Sabre\Principal($this->userManager);
 		parent::setUp();
 	}
 

apps/dav/tests/unit/dav/groupprincipaltest.php

@@ -0,0 +1,146 @@
+<?php
+
+namespace OCA\DAV\Tests\Unit\DAV;
+
+use OCA\DAV\DAV\GroupPrincipalBackend;
+use OCP\IGroupManager;
+use PHPUnit_Framework_MockObject_MockObject;
+use \Sabre\DAV\PropPatch;
+
+class GroupPrincipalTest extends \Test\TestCase {
+
+	/** @var IGroupManager | PHPUnit_Framework_MockObject_MockObject */
+	private $groupManager;
+
+	/** @var GroupPrincipalBackend */
+	private $connector;
+
+	public function setUp() {
+		$this->groupManager = $this->getMockBuilder('\OCP\IGroupManager')
+			->disableOriginalConstructor()->getMock();
+
+		$this->connector = new GroupPrincipalBackend($this->groupManager);
+		parent::setUp();
+	}
+
+	public function testGetPrincipalsByPrefixWithoutPrefix() {
+		$response = $this->connector->getPrincipalsByPrefix('');
+		$this->assertSame([], $response);
+	}
+
+	public function testGetPrincipalsByPrefixWithUsers() {
+		$group1 = $this->mockGroup('foo');
+		$group2 = $this->mockGroup('bar');
+		$this->groupManager
+			->expects($this->once())
+			->method('search')
+			->with('')
+			->will($this->returnValue([$group1, $group2]));
+
+		$expectedResponse = [
+			0 => [
+				'uri' => 'principals/groups/foo',
+				'{DAV:}displayname' => 'foo'
+			],
+			1 => [
+				'uri' => 'principals/groups/bar',
+				'{DAV:}displayname' => 'bar',
+			]
+		];
+		$response = $this->connector->getPrincipalsByPrefix('principals/groups');
+		$this->assertSame($expectedResponse, $response);
+	}
+
+	public function testGetPrincipalsByPrefixEmpty() {
+		$this->groupManager
+			->expects($this->once())
+			->method('search')
+			->with('')
+			->will($this->returnValue([]));
+
+		$response = $this->connector->getPrincipalsByPrefix('principals/groups');
+		$this->assertSame([], $response);
+	}
+
+	public function testGetPrincipalsByPathWithoutMail() {
+		$group1 = $this->mockGroup('foo');
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('foo')
+			->will($this->returnValue($group1));
+
+		$expectedResponse = [
+			'uri' => 'principals/groups/foo',
+			'{DAV:}displayname' => 'foo'
+		];
+		$response = $this->connector->getPrincipalByPath('principals/groups/foo');
+		$this->assertSame($expectedResponse, $response);
+	}
+
+	public function testGetPrincipalsByPathWithMail() {
+		$fooUser = $this->mockGroup('foo');
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('foo')
+			->will($this->returnValue($fooUser));
+
+		$expectedResponse = [
+			'uri' => 'principals/groups/foo',
+			'{DAV:}displayname' => 'foo',
+		];
+		$response = $this->connector->getPrincipalByPath('principals/groups/foo');
+		$this->assertSame($expectedResponse, $response);
+	}
+
+	public function testGetPrincipalsByPathEmpty() {
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('foo')
+			->will($this->returnValue(null));
+
+		$response = $this->connector->getPrincipalByPath('principals/groups/foo');
+		$this->assertSame(null, $response);
+	}
+
+	public function testGetGroupMemberSet() {
+		$response = $this->connector->getGroupMemberSet('principals/groups/foo');
+		$this->assertSame([], $response);
+	}
+
+	public function testGetGroupMembership() {
+		$response = $this->connector->getGroupMembership('principals/groups/foo');
+		$this->assertSame([], $response);
+	}
+
+	/**
+	 * @expectedException \Sabre\DAV\Exception
+	 * @expectedExceptionMessage Setting members of the group is not supported yet
+	 */
+	public function testSetGroupMembership() {
+		$this->connector->setGroupMemberSet('principals/groups/foo', ['foo']);
+	}
+
+	public function testUpdatePrincipal() {
+		$this->assertSame(0, $this->connector->updatePrincipal('foo', new PropPatch(array())));
+	}
+
+	public function testSearchPrincipals() {
+		$this->assertSame([], $this->connector->searchPrincipals('principals/groups', []));
+	}
+
+	/**
+	 * @return PHPUnit_Framework_MockObject_MockObject
+	 */
+	private function mockGroup($gid) {
+		$fooUser = $this->getMockBuilder('\OC\Group\Group')
+			->disableOriginalConstructor()->getMock();
+		$fooUser
+			->expects($this->exactly(1))
+			->method('getGID')
+			->will($this->returnValue($gid));
+		return $fooUser;
+	}
+}