diff --git a/lib/private/server.php b/lib/private/server.php
index 7fa06298b29293bb0c51469b2bb802331887660f..ff34cfdccb6df283d1d8785a0f4dfc0bbcb53b64 100644
--- a/lib/private/server.php
+++ b/lib/private/server.php
@@ -14,6 +14,7 @@ use OC\Security\Crypto;
use OC\Security\SecureRandom;
use OCP\IServerContainer;
use OCP\ISession;
+use OC\Tagging\TagMapper;
/**
* Class Server
@@ -68,9 +69,13 @@ class Server extends SimpleContainer implements IServerContainer {
$this->registerService('PreviewManager', function ($c) {
return new PreviewManager();
});
+ $this->registerService('TagMapper', function($c) {
+ return new TagMapper($c->getDb());
+ });
$this->registerService('TagManager', function ($c) {
+ $tagMapper = $c->query('TagMapper');
$user = \OC_User::getUser();
- return new TagManager($user);
+ return new TagManager($tagMapper, $user);
});
$this->registerService('RootFolder', function ($c) {
// TODO: get user and user manager from container as well
diff --git a/lib/private/share/share.php b/lib/private/share/share.php
index 5314e09b8dee35bb49d934b3253937e2563a5765..b827b84a9bc5552bd79136aea5fe806ba4853f65 100644
--- a/lib/private/share/share.php
+++ b/lib/private/share/share.php
@@ -1181,7 +1181,7 @@ class Share extends \OC\Share\Constants {
}
}
// 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') {
+ if (isset(self::$backendTypes[$itemType]) && (!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
@@ -1192,6 +1192,57 @@ class Share extends \OC\Share\Constants {
return false;
}
+ /**
+ * Get the owners of items shared with a user.
+ *
+ * @param string $user The user the items are shared with.
+ * @param string $type The type of the items shared with the user.
+ * @param boolean $includeCollections Include collection item types (optional)
+ * @param boolean $includeOwner include owner in the list of users the item is shared with (optional)
+ * @return array
+ */
+ public static function getSharedItemsOwners($user, $type, $includeCollections = false, $includeOwner = false) {
+ // First, we find out if $type is part of a collection (and if that collection is part of
+ // another one and so on).
+ $collectionTypes = array();
+ if (!$includeCollections || !$collectionTypes = self::getCollectionItemTypes($type)) {
+ $collectionTypes[] = $type;
+ }
+
+ // Of these collection types, along with our original $type, we make a
+ // list of the ones for which a sharing backend has been registered.
+ // FIXME: Ideally, we wouldn't need to nest getItemsSharedWith in this loop but just call it
+ // with its $includeCollections parameter set to true. Unfortunately, this fails currently.
+ $allMaybeSharedItems = array();
+ foreach ($collectionTypes as $collectionType) {
+ if (isset(self::$backends[$collectionType])) {
+ $allMaybeSharedItems[$collectionType] = self::getItemsSharedWithUser(
+ $collectionType,
+ $user,
+ self::FORMAT_NONE
+ );
+ }
+ }
+
+ $owners = array();
+ if ($includeOwner) {
+ $owners[] = $user;
+ }
+
+ // We take a look at all shared items of the given $type (or of the collections it is part of)
+ // and find out their owners. Then, we gather the tags for the original $type from all owners,
+ // and return them as elements of a list that look like "Tag (owner)".
+ foreach ($allMaybeSharedItems as $collectionType => $maybeSharedItems) {
+ foreach ($maybeSharedItems as $sharedItem) {
+ if (isset($sharedItem['id'])) { //workaround for https://github.com/owncloud/core/issues/2814
+ $owners[] = $sharedItem['uid_owner'];
+ }
+ }
+ }
+
+ return $owners;
+ }
+
/**
* Get shared items from the database
* @param string $itemType
diff --git a/lib/private/tagging/tag.php b/lib/private/tagging/tag.php
new file mode 100644
index 0000000000000000000000000000000000000000..3ea9fbac20ba25e7dfa6775f9645ae37bf9e9c7b
--- /dev/null
+++ b/lib/private/tagging/tag.php
@@ -0,0 +1,89 @@
+<?php
+/**
+* ownCloud - Tag class
+*
+* @author Bernhard Reiter
+* @copyright 2014 Bernhard Reiter <ockham@raz.or.at>
+*
+* 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\Tagging;
+
+use \OCP\AppFramework\Db\Entity;
+
+/**
+ * Class to represent a tag.
+ *
+ * @method string getOwner()
+ * @method void setOwner(string $owner)
+ * @method string getType()
+ * @method void setType(string $type)
+ * @method string getName()
+ * @method void setName(string $name)
+ */
+class Tag extends Entity {
+
+ protected $owner;
+ protected $type;
+ protected $name;
+
+ /**
+ * Constructor.
+ *
+ * @param string $owner The tag's owner
+ * @param string $type The type of item this tag is used for
+ * @param string $name The tag's name
+ */
+ public function __construct($owner = null, $type = null, $name = null) {
+ $this->setOwner($owner);
+ $this->setType($type);
+ $this->setName($name);
+ }
+
+ /**
+ * Transform a database columnname to a property
+ *
+ * @param string $columnName the name of the column
+ * @return string the property name
+ * @todo migrate existing database columns to the correct names
+ * to be able to drop this direct mapping
+ */
+ public function columnToProperty($columnName){
+ if ($columnName === 'category') {
+ return 'name';
+ } elseif ($columnName === 'uid') {
+ return 'owner';
+ } else {
+ return parent::columnToProperty($columnName);
+ }
+ }
+
+ /**
+ * Transform a property to a database column name
+ *
+ * @param string $property the name of the property
+ * @return string the column name
+ */
+ public function propertyToColumn($property){
+ if ($property === 'name') {
+ return 'category';
+ } elseif ($property === 'owner') {
+ return 'uid';
+ } else {
+ return parent::propertyToColumn($property);
+ }
+ }
+}
diff --git a/lib/private/tagging/tagmapper.php b/lib/private/tagging/tagmapper.php
new file mode 100644
index 0000000000000000000000000000000000000000..6c9bec7aa52096abbfa046068e3febe1fb34f38d
--- /dev/null
+++ b/lib/private/tagging/tagmapper.php
@@ -0,0 +1,77 @@
+<?php
+/**
+* ownCloud - TagMapper class
+*
+* @author Bernhard Reiter
+* @copyright 2014 Bernhard Reiter <ockham@raz.or.at>
+*
+* 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\Tagging;
+
+use \OCP\AppFramework\Db\Mapper,
+ \OCP\AppFramework\Db\DoesNotExistException,
+ \OCP\IDb;
+
+/**
+ * Mapper for Tag entity
+ */
+class TagMapper extends Mapper {
+
+ /**
+ * Constructor.
+ *
+ * @param IDb $db Instance of the Db abstraction layer.
+ */
+ public function __construct(IDb $db) {
+ parent::__construct($db, 'vcategory', 'OC\Tagging\Tag');
+ }
+
+ /**
+ * Load tags from the database.
+ *
+ * @param array|string $owners The user(s) whose tags we are going to load.
+ * @param string $type The type of item for which we are loading tags.
+ * @return array An array of Tag objects.
+ */
+ public function loadTags($owners, $type) {
+ if(!is_array($owners)) {
+ $owners = array($owners);
+ }
+
+ $sql = 'SELECT `id`, `uid`, `type`, `category` FROM `' . $this->getTableName() . '` '
+ . 'WHERE `uid` IN (' . str_repeat('?,', count($owners)-1) . '?) AND `type` = ? ORDER BY `category`';
+ return $this->findEntities($sql, array_merge($owners, array($type)));
+ }
+
+ /**
+ * Check if a given Tag object already exists in the database.
+ *
+ * @param Tag $tag The tag to look for in the database.
+ * @return bool
+ */
+ public function tagExists($tag) {
+ $sql = 'SELECT `id`, `uid`, `type`, `category` FROM `' . $this->getTableName() . '` '
+ . 'WHERE `uid` = ? AND `type` = ? AND `category` = ?';
+ try {
+ $this->findEntity($sql, array($tag->getOwner(), $tag->getType(), $tag->getName()));
+ } catch (DoesNotExistException $e) {
+ return false;
+ }
+ return true;
+ }
+}
+
diff --git a/lib/private/tagmanager.php b/lib/private/tagmanager.php
index 9a371a11253f524c7148336a22df896f4b60514a..d5bff04acffe97fe6d3be0e7bf5e8e59bb05430a 100644
--- a/lib/private/tagmanager.php
+++ b/lib/private/tagmanager.php
@@ -33,6 +33,8 @@
namespace OC;
+use OC\Tagging\TagMapper;
+
class TagManager implements \OCP\ITagManager {
/**
@@ -40,15 +42,24 @@ class TagManager implements \OCP\ITagManager {
*
* @var string
*/
- private $user = null;
+ private $user;
+
+ /**
+ * TagMapper
+ *
+ * @var TagMapper
+ */
+ private $mapper;
/**
* Constructor.
*
- * @param string $user The user whos data the object will operate on.
+ * @param TagMapper $mapper Instance of the TagMapper abstraction layer.
+ * @param string $user The user whose data the object will operate on.
*/
- public function __construct($user) {
+ public function __construct(TagMapper $mapper, $user) {
+ $this->mapper = $mapper;
$this->user = $user;
}
@@ -59,10 +70,11 @@ class TagManager implements \OCP\ITagManager {
* @see \OCP\ITags
* @param string $type The type identifier e.g. 'contact' or 'event'.
* @param array $defaultTags An array of default tags to be used if none are stored.
+ * @param boolean $includeShared Whether to include tags for items shared with this user by others.
* @return \OCP\ITags
*/
- public function load($type, $defaultTags=array()) {
- return new Tags($this->user, $type, $defaultTags);
+ public function load($type, $defaultTags=array(), $includeShared=false) {
+ return new Tags($this->mapper, $this->user, $type, $defaultTags, $includeShared);
}
-}
\ No newline at end of file
+}
diff --git a/lib/private/tags.php b/lib/private/tags.php
index 0e58789ecd58cf3d3cd32e94910682d6199ae03a..bab3d4952825b08c1c08c8d86ea3b5cc3125dd61 100644
--- a/lib/private/tags.php
+++ b/lib/private/tags.php
@@ -34,6 +34,9 @@
namespace OC;
+use \OC\Tagging\Tag,
+ \OC\Tagging\TagMapper;
+
class Tags implements \OCP\ITags {
/**
@@ -55,14 +58,44 @@ class Tags implements \OCP\ITags {
*
* @var string
*/
- private $type = null;
+ private $type;
/**
* User
*
* @var string
*/
- private $user = null;
+ private $user;
+
+ /**
+ * Are we including tags for shared items?
+ *
+ * @var bool
+ */
+ private $includeShared = false;
+
+ /**
+ * The current user, plus any owners of the items shared with the current
+ * user, if $this->includeShared === true.
+ *
+ * @var array
+ */
+ private $owners = array();
+
+ /**
+ * The Mapper we're using to communicate our Tag objects to the database.
+ *
+ * @var TagMapper
+ */
+ private $mapper;
+
+ /**
+ * The sharing backend for objects of $this->type. Required if
+ * $this->includeShared === true to determine ownership of items.
+ *
+ * @var \OCP\Share_Backend
+ */
+ private $backend;
const TAG_TABLE = '*PREFIX*vcategory';
const RELATION_TABLE = '*PREFIX*vcategory_to_object';
@@ -72,47 +105,29 @@ class Tags implements \OCP\ITags {
/**
* Constructor.
*
- * @param string $user The user whos data the object will operate on.
- * @param string $type
+ * @param TagMapper $mapper Instance of the TagMapper abstraction layer.
+ * @param string $user The user whose data the object will operate on.
+ * @param string $type The type of items for which tags will be loaded.
+ * @param array $defaultTags Tags that should be created at construction.
+ * @param boolean $includeShared Whether to include tags for items shared with this user by others.
*/
- public function __construct($user, $type, $defaultTags = array()) {
+ public function __construct(TagMapper $mapper, $user, $type, $defaultTags = array(), $includeShared = false) {
+ $this->mapper = $mapper;
$this->user = $user;
$this->type = $type;
- $this->loadTags($defaultTags);
- }
-
- /**
- * Load tags from db.
- *
- */
- protected function loadTags($defaultTags=array()) {
- $this->tags = array();
- $result = null;
- $sql = 'SELECT `id`, `category` FROM `' . self::TAG_TABLE . '` '
- . 'WHERE `uid` = ? AND `type` = ? ORDER BY `category`';
- try {
- $stmt = \OCP\DB::prepare($sql);
- $result = $stmt->execute(array($this->user, $this->type));
- if (\OCP\DB::isError($result)) {
- \OCP\Util::writeLog('core', __METHOD__. ', DB error: ' . \OCP\DB::getErrorMessage($result), \OCP\Util::ERROR);
- }
- } catch(\Exception $e) {
- \OCP\Util::writeLog('core', __METHOD__.', exception: '.$e->getMessage(),
- \OCP\Util::ERROR);
- }
-
- if(!is_null($result)) {
- while( $row = $result->fetchRow()) {
- $this->tags[$row['id']] = $row['category'];
- }
+ $this->includeShared = $includeShared;
+ $this->owners = array($this->user);
+ if ($this->includeShared) {
+ $this->owners = array_merge($this->owners, \OC\Share\Share::getSharedItemsOwners($this->user, $this->type, true));
+ $this->backend = \OC\Share\Share::getBackend($this->type);
}
+ $this->tags = $this->mapper->loadTags($this->owners, $this->type);
if(count($defaultTags) > 0 && count($this->tags) === 0) {
$this->addMultiple($defaultTags, true);
}
\OCP\Util::writeLog('core', __METHOD__.', tags: ' . print_r($this->tags, true),
\OCP\Util::DEBUG);
-
}
/**
@@ -124,13 +139,28 @@ class Tags implements \OCP\ITags {
return count($this->tags) === 0;
}
+ /**
+ * Returns an array mapping a given tag's properties to its values:
+ * ['id' => 0, 'name' = 'Tag', 'owner' = 'User', 'type' => 'tagtype']
+ *
+ * @param string $id The ID of the tag that is going to be mapped
+ * @return array|false
+ */
+ public function getTag($id) {
+ $key = $this->getTagById($id);
+ if ($key !== false) {
+ return $this->tagMap($this->tags[$key]);
+ }
+ return false;
+ }
+
/**
* Get the tags for a specific user.
*
- * This returns an array with id/name maps:
+ * This returns an array with maps containing each tag's properties:
* [
- * ['id' => 0, 'name' = 'First tag'],
- * ['id' => 1, 'name' = 'Second tag'],
+ * ['id' => 0, 'name' = 'First tag', 'owner' = 'User', 'type' => 'tagtype'],
+ * ['id' => 1, 'name' = 'Shared tag', 'owner' = 'Other user', 'type' => 'tagtype'],
* ]
*
* @return array
@@ -140,22 +170,35 @@ class Tags implements \OCP\ITags {
return array();
}
- $tags = array_values($this->tags);
- uasort($tags, 'strnatcasecmp');
+ usort($this->tags, function($a, $b) {
+ return strnatcasecmp($a->getName(), $b->getName());
+ });
$tagMap = array();
- foreach($tags as $tag) {
- if($tag !== self::TAG_FAVORITE) {
- $tagMap[] = array(
- 'id' => $this->array_searchi($tag, $this->tags),
- 'name' => $tag
- );
+ foreach($this->tags as $tag) {
+ if($tag->getName() !== self::TAG_FAVORITE) {
+ $tagMap[] = $this->tagMap($tag);
}
}
return $tagMap;
}
+ /**
+ * Return only the tags owned by the given user, omitting any tags shared
+ * by other users.
+ *
+ * @param string $user The user whose tags are to be checked.
+ * @return array An array of Tag objects.
+ */
+ public function getTagsForUser($user) {
+ return array_filter($this->tags,
+ function($tag) use($user) {
+ return $tag->getOwner() === $user;
+ }
+ );
+ }
+
/**
* Get the a list if items tagged with $tag.
*
@@ -174,7 +217,7 @@ class Tags implements \OCP\ITags {
\OCP\Util::writeLog('core', __METHOD__.', Cannot use empty tag names', \OCP\Util::DEBUG);
return false;
}
- $tagId = $this->array_searchi($tag, $this->tags);
+ $tagId = $this->getTagId($tag);
}
if($tagId === false) {
@@ -203,7 +246,22 @@ class Tags implements \OCP\ITags {
if(!is_null($result)) {
while( $row = $result->fetchRow()) {
- $ids[] = (int)$row['objid'];
+ $id = (int)$row['objid'];
+
+ if ($this->includeShared) {
+ // We have to check if we are really allowed to access the
+ // items that are tagged with $tag. To that end, we ask the
+ // corresponding sharing backend if the item identified by $id
+ // is owned by any of $this->owners.
+ foreach ($this->owners as $owner) {
+ if ($this->backend->isValidSource($id, $owner)) {
+ $ids[] = $id;
+ break;
+ }
+ }
+ } else {
+ $ids[] = $id;
+ }
}
}
@@ -211,13 +269,26 @@ class Tags implements \OCP\ITags {
}
/**
- * Checks whether a tag is already saved.
+ * Checks whether a tag is saved for the given user,
+ * disregarding the ones shared with him or her.
+ *
+ * @param string $name The tag name to check for.
+ * @param string $user The user whose tags are to be checked.
+ * @return bool
+ */
+ public function userHasTag($name, $user) {
+ $key = $this->array_searchi($name, $this->getTagsForUser($user));
+ return ($key !== false) ? $this->tags[$key]->getId() : false;
+ }
+
+ /**
+ * Checks whether a tag is saved for or shared with the current user.
*
- * @param string $name The name to check for.
+ * @param string $name The tag name to check for.
* @return bool
*/
public function hasTag($name) {
- return $this->in_arrayi($name, $this->tags);
+ return $this->getTagId($name) !== false;
}
/**
@@ -233,41 +304,27 @@ class Tags implements \OCP\ITags {
\OCP\Util::writeLog('core', __METHOD__.', Cannot add an empty tag', \OCP\Util::DEBUG);
return false;
}
- if($this->hasTag($name)) {
+ if($this->userHasTag($name, $this->user)) {
\OCP\Util::writeLog('core', __METHOD__.', name: ' . $name. ' exists already', \OCP\Util::DEBUG);
return false;
}
try {
- $result = \OCP\DB::insertIfNotExist(
- self::TAG_TABLE,
- array(
- 'uid' => $this->user,
- 'type' => $this->type,
- 'category' => $name,
- )
- );
- if (\OCP\DB::isError($result)) {
- \OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OCP\DB::getErrorMessage($result), \OCP\Util::ERROR);
- return false;
- } elseif((int)$result === 0) {
- \OCP\Util::writeLog('core', __METHOD__.', Tag already exists: ' . $name, \OCP\Util::DEBUG);
- return false;
- }
+ $tag = new Tag($this->user, $this->type, $name);
+ $tag = $this->mapper->insert($tag);
+ $this->tags[] = $tag;
} catch(\Exception $e) {
\OCP\Util::writeLog('core', __METHOD__.', exception: '.$e->getMessage(),
\OCP\Util::ERROR);
return false;
}
- $id = \OCP\DB::insertid(self::TAG_TABLE);
- \OCP\Util::writeLog('core', __METHOD__.', id: ' . $id, \OCP\Util::DEBUG);
- $this->tags[$id] = $name;
- return $id;
+ \OCP\Util::writeLog('core', __METHOD__.', id: ' . $tag->getId(), \OCP\Util::DEBUG);
+ return $tag->getId();
}
/**
* Rename tag.
*
- * @param string $from The name of the existing tag
+ * @param string|integer $from The name or ID of the existing tag
* @param string $to The new name of the tag.
* @return bool
*/
@@ -280,27 +337,30 @@ class Tags implements \OCP\ITags {
return false;
}
- $id = $this->array_searchi($from, $this->tags);
- if($id === false) {
+ if (is_numeric($from)) {
+ $key = $this->getTagById($from);
+ } else {
+ $key = $this->getTagByName($from);
+ }
+ if($key === false) {
\OCP\Util::writeLog('core', __METHOD__.', tag: ' . $from. ' does not exist', \OCP\Util::DEBUG);
return false;
}
+ $tag = $this->tags[$key];
+
+ if($this->userHasTag($to, $tag->getOwner())) {
+ \OCP\Util::writeLog('core', __METHOD__.', A tag named ' . $to. ' already exists for user ' . $tag->getOwner() . '.', \OCP\Util::DEBUG);
+ return false;
+ }
- $sql = 'UPDATE `' . self::TAG_TABLE . '` SET `category` = ? '
- . 'WHERE `uid` = ? AND `type` = ? AND `id` = ?';
try {
- $stmt = \OCP\DB::prepare($sql);
- $result = $stmt->execute(array($to, $this->user, $this->type, $id));
- if (\OCP\DB::isError($result)) {
- \OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OCP\DB::getErrorMessage($result), \OCP\Util::ERROR);
- return false;
- }
+ $tag->setName($to);
+ $this->tags[$key] = $this->mapper->update($tag);
} catch(\Exception $e) {
\OCP\Util::writeLog('core', __METHOD__.', exception: '.$e->getMessage(),
\OCP\Util::ERROR);
return false;
}
- $this->tags[$id] = $to;
return true;
}
@@ -308,7 +368,7 @@ class Tags implements \OCP\ITags {
* Add a list of new tags.
*
* @param string[] $names A string with a name or an array of strings containing
- * the name(s) of the to add.
+ * the name(s) of the tag(s) to add.
* @param bool $sync When true, save the tags
* @param int|null $id int Optional object id to add to this|these tag(s)
* @return bool Returns false on error.
@@ -322,9 +382,8 @@ class Tags implements \OCP\ITags {
$newones = array();
foreach($names as $name) {
- if(($this->in_arrayi(
- $name, $this->tags) == false) && $name !== '') {
- $newones[] = $name;
+ if(!$this->hasTag($name) && $name !== '') {
+ $newones[] = new Tag($this->user, $this->type, $name);
}
if(!is_null($id) ) {
// Insert $objectid, $categoryid pairs if not exist.
@@ -346,26 +405,26 @@ class Tags implements \OCP\ITags {
if(is_array($this->tags)) {
foreach($this->tags as $tag) {
try {
- \OCP\DB::insertIfNotExist(self::TAG_TABLE,
- array(
- 'uid' => $this->user,
- 'type' => $this->type,
- 'category' => $tag,
- ));
+ if (!$this->mapper->tagExists($tag)) {
+ $this->mapper->insert($tag);
+ }
} catch(\Exception $e) {
\OCP\Util::writeLog('core', __METHOD__.', exception: '.$e->getMessage(),
\OCP\Util::ERROR);
}
}
+
// reload tags to get the proper ids.
- $this->loadTags();
+ $this->tags = $this->mapper->loadTags($this->owners, $this->type);
+ \OCP\Util::writeLog('core', __METHOD__.', tags: ' . print_r($this->tags, true),
+ \OCP\Util::DEBUG);
// Loop through temporarily cached objectid/tagname pairs
// and save relations.
$tags = $this->tags;
// For some reason this is needed or array_search(i) will return 0..?
ksort($tags);
foreach(self::$relations as $relation) {
- $tagId = $this->array_searchi($relation['tag'], $tags);
+ $tagId = $this->getTagId($relation['tag']);
\OCP\Util::writeLog('core', __METHOD__ . 'catid, ' . $relation['tag'] . ' ' . $tagId, \OCP\Util::DEBUG);
if($tagId) {
try {
@@ -493,7 +552,7 @@ class Tags implements \OCP\ITags {
* @return boolean
*/
public function addToFavorites($objid) {
- if(!$this->hasTag(self::TAG_FAVORITE)) {
+ if(!$this->userHasTag(self::TAG_FAVORITE, $this->user)) {
$this->add(self::TAG_FAVORITE);
}
return $this->tagAs($objid, self::TAG_FAVORITE);
@@ -526,7 +585,7 @@ class Tags implements \OCP\ITags {
if(!$this->hasTag($tag)) {
$this->add($tag);
}
- $tagId = $this->array_searchi($tag, $this->tags);
+ $tagId = $this->getTagId($tag);
} else {
$tagId = $tag;
}
@@ -559,7 +618,7 @@ class Tags implements \OCP\ITags {
\OCP\Util::writeLog('core', __METHOD__.', Tag name is empty', \OCP\Util::DEBUG);
return false;
}
- $tagId = $this->array_searchi($tag, $this->tags);
+ $tagId = $this->getTagId($tag);
} else {
$tagId = $tag;
}
@@ -578,9 +637,9 @@ class Tags implements \OCP\ITags {
}
/**
- * Delete tags from the
+ * Delete tags from the database.
*
- * @param string[] $names An array of tags to delete
+ * @param string[]|integer[] $names An array of tags (names or IDs) to delete
* @return bool Returns false on error
*/
public function delete($names) {
@@ -596,21 +655,19 @@ class Tags implements \OCP\ITags {
foreach($names as $name) {
$id = null;
- if($this->hasTag($name)) {
- $id = $this->array_searchi($name, $this->tags);
- unset($this->tags[$id]);
+ if (is_numeric($name)) {
+ $key = $this->getTagById($name);
+ } else {
+ $key = $this->getTagByName($name);
}
- try {
- $stmt = \OCP\DB::prepare('DELETE FROM `' . self::TAG_TABLE . '` WHERE '
- . '`uid` = ? AND `type` = ? AND `category` = ?');
- $result = $stmt->execute(array($this->user, $this->type, $name));
- if (\OCP\DB::isError($result)) {
- \OCP\Util::writeLog('core', __METHOD__. 'DB error: ' . \OCP\DB::getErrorMessage($result), \OCP\Util::ERROR);
- }
- } catch(\Exception $e) {
- \OCP\Util::writeLog('core', __METHOD__ . ', exception: '
- . $e->getMessage(), \OCP\Util::ERROR);
- return false;
+ if ($key !== false) {
+ $tag = $this->tags[$key];
+ $id = $tag->getId();
+ unset($this->tags[$key]);
+ $this->mapper->delete($tag);
+ } else {
+ \OCP\Util::writeLog('core', __METHOD__ . 'Cannot delete tag ' . $name
+ . ': not found.', \OCP\Util::ERROR);
}
if(!is_null($id) && $id !== false) {
try {
@@ -634,19 +691,67 @@ class Tags implements \OCP\ITags {
return true;
}
- // case-insensitive in_array
- private function in_arrayi($needle, $haystack) {
+ // case-insensitive array_search
+ protected function array_searchi($needle, $haystack, $mem='getName') {
if(!is_array($haystack)) {
return false;
}
- return in_array(strtolower($needle), array_map('strtolower', $haystack));
+ return array_search(strtolower($needle), array_map(
+ function($tag) use($mem) {
+ return strtolower(call_user_func(array($tag, $mem)));
+ }, $haystack)
+ );
}
- // case-insensitive array_search
- private function array_searchi($needle, $haystack) {
- if(!is_array($haystack)) {
- return false;
+ /**
+ * Get a tag's ID.
+ *
+ * @param string $name The tag name to look for.
+ * @return string|bool The tag's id or false if no matching tag is found.
+ */
+ private function getTagId($name) {
+ $key = $this->array_searchi($name, $this->tags);
+ if ($key !== false) {
+ return $this->tags[$key]->getId();
}
- return array_search(strtolower($needle), array_map('strtolower', $haystack));
+ return false;
+ }
+
+ /**
+ * Get a tag by its name.
+ *
+ * @param string $name The tag name.
+ * @return integer|bool The tag object's offset within the $this->tags
+ * array or false if it doesn't exist.
+ */
+ private function getTagByName($name) {
+ return $this->array_searchi($name, $this->tags, 'getName');
+ }
+
+ /**
+ * Get a tag by its ID.
+ *
+ * @param string $id The tag ID to look for.
+ * @return integer|bool The tag object's offset within the $this->tags
+ * array or false if it doesn't exist.
+ */
+ private function getTagById($id) {
+ return $this->array_searchi($id, $this->tags, 'getId');
+ }
+
+ /**
+ * Returns an array mapping a given tag's properties to its values:
+ * ['id' => 0, 'name' = 'Tag', 'owner' = 'User', 'type' => 'tagtype']
+ *
+ * @param Tag $tag The tag that is going to be mapped
+ * @return array
+ */
+ private function tagMap(Tag $tag) {
+ return array(
+ 'id' => $tag->getId(),
+ 'name' => $tag->getName(),
+ 'owner' => $tag->getOwner(),
+ 'type' => $tag->getType()
+ );
}
}
diff --git a/lib/public/itagmanager.php b/lib/public/itagmanager.php
index 40487de42b4aa28b865490e15095a159299c8d1b..54daa5cc1cbbc643bb04ffbab3561380411ee91f 100644
--- a/lib/public/itagmanager.php
+++ b/lib/public/itagmanager.php
@@ -48,8 +48,9 @@ interface ITagManager {
* @see \OCP\ITags
* @param string $type The type identifier e.g. 'contact' or 'event'.
* @param array $defaultTags An array of default tags to be used if none are stored.
+ * @param boolean $includeShared Whether to include tags for items shared with this user by others.
* @return \OCP\ITags
*/
- public function load($type, $defaultTags=array());
+ public function load($type, $defaultTags=array(), $includeShared=false);
-}
\ No newline at end of file
+}
diff --git a/lib/public/itags.php b/lib/public/itags.php
index 1cba07e9b5377555730531404df0b22ef7b68193..4514746bbe88d56cc56b16280718118cb273265a 100644
--- a/lib/public/itags.php
+++ b/lib/public/itags.php
@@ -53,6 +53,15 @@ interface ITags {
*/
public function isEmpty();
+ /**
+ * Returns an array mapping a given tag's properties to its values:
+ * ['id' => 0, 'name' = 'Tag', 'owner' = 'User', 'type' => 'tagtype']
+ *
+ * @param string $id The ID of the tag that is going to be mapped
+ * @return array|false
+ */
+ public function getTag($id);
+
/**
* Get the tags for a specific user.
*
@@ -84,6 +93,16 @@ interface ITags {
*/
public function hasTag($name);
+ /**
+ * Checks whether a tag is saved for the given user,
+ * disregarding the ones shared with him or her.
+ *
+ * @param string $name The tag name to check for.
+ * @param string $user The user whose tags are to be checked.
+ * @return bool
+ */
+ public function userHasTag($name, $user);
+
/**
* Add a new tag.
*
@@ -95,7 +114,7 @@ interface ITags {
/**
* Rename tag.
*
- * @param string $from The name of the existing tag
+ * @param string|integer $from The name or ID of the existing tag
* @param string $to The new name of the tag.
* @return bool
*/
@@ -162,11 +181,11 @@ interface ITags {
public function unTag($objid, $tag);
/**
- * Delete tags from the
+ * Delete tags from the database
*
- * @param string[] $names An array of tags to delete
+ * @param string[]|integer[] $names An array of tags (names or IDs) to delete
* @return bool Returns false on error
*/
public function delete($names);
-}
\ No newline at end of file
+}
diff --git a/tests/lib/share/backend.php b/tests/lib/share/backend.php
index 50ce24e07b6d15a9cdf2319053d844cdbaaa8d47..61b8f262a42e24f67fddb805533485befb7b8ac1 100644
--- a/tests/lib/share/backend.php
+++ b/tests/lib/share/backend.php
@@ -29,9 +29,10 @@ class Test_Share_Backend implements OCP\Share_Backend {
private $testItem1 = 'test.txt';
private $testItem2 = 'share.txt';
+ private $testId = 1;
public function isValidSource($itemSource, $uidOwner) {
- if ($itemSource == $this->testItem1 || $itemSource == $this->testItem2) {
+ if ($itemSource == $this->testItem1 || $itemSource == $this->testItem2 || $itemSource == 1) {
return true;
}
}
diff --git a/tests/lib/tags.php b/tests/lib/tags.php
index 976b4b4fdc83182e077ae991e7d1d8021dfb31a1..2f7a1e817f84e2fa9e5913701e4089615356cbb8 100644
--- a/tests/lib/tags.php
+++ b/tests/lib/tags.php
@@ -34,7 +34,8 @@ class Test_Tags extends PHPUnit_Framework_TestCase {
$this->objectType = uniqid('type_');
OC_User::createUser($this->user, 'pass');
OC_User::setUserId($this->user);
- $this->tagMgr = new OC\TagManager($this->user);
+ $this->tagMapper = new OC\Tagging\TagMapper(new OC\AppFramework\Db\Db());
+ $this->tagMgr = new OC\TagManager($this->tagMapper, $this->user);
}
@@ -84,7 +85,36 @@ class Test_Tags extends PHPUnit_Framework_TestCase {
$this->assertTrue($tagger->hasTag($tag));
}
- $this->assertCount(4, $tagger->getTags(), 'Not all tags added');
+ $tagMaps = $tagger->getTags();
+ $this->assertCount(4, $tagMaps, 'Not all tags added');
+ foreach($tagMaps as $tagMap) {
+ $this->assertEquals(null, $tagMap['id']);
+ }
+
+ // As addMultiple has been called without $sync=true, the tags aren't
+ // saved to the database, so they're gone when we reload $tagger:
+
+ $tagger = $this->tagMgr->load($this->objectType);
+ $this->assertEquals(0, count($tagger->getTags()));
+
+ // Now, we call addMultiple() with $sync=true so the tags will be
+ // be saved to the database.
+ $result = $tagger->addMultiple($tags, true);
+ $this->assertTrue((bool)$result);
+
+ $tagMaps = $tagger->getTags();
+ foreach($tagMaps as $tagMap) {
+ $this->assertNotEquals(null, $tagMap['id']);
+ }
+
+ // Reload the tagger.
+ $tagger = $this->tagMgr->load($this->objectType);
+
+ foreach($tags as $tag) {
+ $this->assertTrue($tagger->hasTag($tag));
+ }
+
+ $this->assertCount(4, $tagger->getTags(), 'Not all previously saved tags found');
}
public function testIsEmpty() {
@@ -120,8 +150,8 @@ class Test_Tags extends PHPUnit_Framework_TestCase {
$this->assertTrue($tagger->rename('Wrok', 'Work'));
$this->assertTrue($tagger->hasTag('Work'));
$this->assertFalse($tagger->hastag('Wrok'));
- $this->assertFalse($tagger->rename('Wrok', 'Work'));
-
+ $this->assertFalse($tagger->rename('Wrok', 'Work')); // Rename non-existant tag.
+ $this->assertFalse($tagger->rename('Work', 'Family')); // Collide with existing tag.
}
public function testTagAs() {
@@ -160,7 +190,33 @@ class Test_Tags extends PHPUnit_Framework_TestCase {
public function testFavorite() {
$tagger = $this->tagMgr->load($this->objectType);
$this->assertTrue($tagger->addToFavorites(1));
+ $this->assertEquals(array(1), $tagger->getFavorites());
$this->assertTrue($tagger->removeFromFavorites(1));
+ $this->assertEquals(array(), $tagger->getFavorites());
+ }
+
+ public function testShareTags() {
+ $test_tag = 'TestTag';
+ OCP\Share::registerBackend('test', 'Test_Share_Backend');
+
+ $tagger = $this->tagMgr->load('test');
+ $tagger->tagAs(1, $test_tag);
+
+ $other_user = uniqid('user2_');
+ OC_User::createUser($other_user, 'pass');
+
+ OC_User::setUserId($other_user);
+ $other_tagMgr = new OC\TagManager($this->tagMapper, $other_user);
+ $other_tagger = $other_tagMgr->load('test');
+ $this->assertFalse($other_tagger->hasTag($test_tag));
+
+ OC_User::setUserId($this->user);
+ OCP\Share::shareItem('test', 1, OCP\Share::SHARE_TYPE_USER, $other_user, OCP\PERMISSION_READ);
+
+ OC_User::setUserId($other_user);
+ $other_tagger = $other_tagMgr->load('test', array(), true); // Update tags, load shared ones.
+ $this->assertTrue($other_tagger->hasTag($test_tag));
+ $this->assertContains(1, $other_tagger->getIdsForTag($test_tag));
}
}