Bookmarks::addBookmark() - Code Metrics - Inspection of "Delicious html import" - owncloud/bookmarks - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#185)

unknown

created 2015-12-21 17:04 UTC

Bookmarks::addBookmark() C

↳ Parent: Bookmarks

Complexity

Conditions	7
Paths	16

Size

Total Lines	71
Code Lines	50

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	24
CRAP Score	15.0285

Importance

Changes	6
Bugs	1	Features	1

Metric	Value
c	6
b	1
f	1
dl	0
loc	71
ccs	24
cts	53
cp	0.4528
rs	6.7969
cc	7
eloc	50
nc	16
nop	8
crap	15.0285

How to fix Long Method Many Parameters

<?php

/**
 * ownCloud - bookmarks plugin
 *
 * @author Arthur Schiwon
 * @copyright 2011 Arthur Schiwon [email protected]
 *
 * 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/>.
 *
 */
/**
 * This class manages bookmarks
 */

namespace OCA\Bookmarks\Controller\Lib;

use \OCP\IDb;

class Bookmarks {

	/**
	 * @brief Finds all tags for bookmarks
	 * @param $userId UserId
	 * @param IDb $db Database Interface
	 * @param filterTags array of tag to look for if empty then every tag
	 * @param offset integer offset
	 * @param limit integer of item to return
	 * @return Found Tags
	 */
	public static function findTags($userId, IDb $db, $filterTags = array(), $offset = 0, $limit = -1) {
		$params = array_merge($filterTags, $filterTags);
		array_unshift($params, $userId);
		$not_in = '';
		if (!empty($filterTags)) {
			$exist_clause = " AND	exists (select 1 from `*PREFIX*bookmarks_tags`
				`t2` where `t2`.`bookmark_id` = `t`.`bookmark_id` and `tag` = ?) ";

			$not_in = ' AND `tag` not in (' . implode(',', array_fill(0, count($filterTags), '?')) . ')' .
					str_repeat($exist_clause, count($filterTags));
		}
		$sql = 'SELECT tag, count(*) as nbr from *PREFIX*bookmarks_tags t ' .
				' WHERE EXISTS( SELECT 1 from *PREFIX*bookmarks bm where  t.bookmark_id  = bm.id and user_id = ?) ' .
				$not_in .
				' GROUP BY `tag` ORDER BY `nbr` DESC ';

		$query = $db->prepareQuery($sql, $limit, $offset);
		$tags = $query->execute($params)->fetchAll();
		return $tags;
	}

	/**
	 * @brief Finds Bookmark with certain ID
	 * @param $id BookmarkId
	 * @param $userId UserId
	 * @param IDb $db Database Interface
	 * @return Specific Bookmark
	 */
	public static function findUniqueBookmark($id, $userId, IDb $db) {
		$CONFIG_DBTYPE = \OCP\Config::getSystemValue('dbtype', 'sqlite');
		if ($CONFIG_DBTYPE == 'pgsql') {
			$group_fct = 'array_agg(`tag`)';
		} else {
			$group_fct = 'GROUP_CONCAT(`tag`)';
		}
		$sql = "SELECT *, (select $group_fct from `*PREFIX*bookmarks_tags` where `bookmark_id` = `b`.`id`) as `tags`
				FROM `*PREFIX*bookmarks` `b`
				WHERE `user_id` = ? AND `id` = ?";
		$query = $db->prepareQuery($sql);
		$result = $query->execute(array($userId, $id))->fetchRow();
		$result['tags'] = explode(',', $result['tags']);
		return $result;
	}

	/**
	 * @brief Check if an URL is bookmarked
	 * @param $url Url of a possible bookmark
	 * @param $userId UserId
	 * @param IDb $db Database Interface
	 * @return boolean if the url is already bookmarked
	 */
	public static function bookmarkExists($url, $userId, IDb $db) {
		$enc_url = htmlspecialchars_decode($url);
		$sql = "SELECT id from `*PREFIX*bookmarks` where `url` = ? and `user_id` = ?";
		$query = $db->prepareQuery($sql);
		$result = $query->execute(array($enc_url, $userId))->fetchRow();
		if ($result) {
			return $result['id'];
		} else {
			return false;
		}
	}

	/**
	 * @brief Finds all bookmarks, matching the filter
	 * @param $userid UserId
	 * @param IDb $db Database Interface
	 * @param int $offset offset
	 * @param string $sqlSortColumn result with this column
	 * @param string|array $filters filters can be: empty -> no filter, a string -> filter this, a string array -> filter for all strings
	 * @param bool $filterTagOnly true, filter affects only tags, else filter affects url, title and tags
	 * @param int $limit limit of items to return (default 10) if -1 or false then all items are returned
	 * @param bool $public check if only public bookmarks should be returned
	 * @param array $requestedAttributes select all the attributes that should be returned. default is * + tags
	 * @param string $tagFilterConjunction select wether the filterTagOnly should filter with an AND or an OR  conjunction
	 * @return Collection of specified bookmarks
	 */
	public static function findBookmarks(
	$userid, IDb $db, $offset, $sqlSortColumn, $filters, $filterTagOnly, $limit = 10, $public = false, $requestedAttributes = null, $tagFilterConjunction = "and") {

		$CONFIG_DBTYPE = \OCP\Config::getSystemValue('dbtype', 'sqlite');
		if (is_string($filters)) {
			$filters = array($filters);
		}

		$toSelect = '*';
		$tableAttributes = array('id', 'url', 'title', 'user_id', 'description',
			'public', 'added', 'lastmodified', 'clickcount',);

		$returnTags = true;

		if ($requestedAttributes != null) {

			$key = array_search('tags', $requestedAttributes);
			if ($key == false) {
				$returnTags = false;
			} else {
				unset($requestedAttributes[$key]);
			}

			$toSelect = implode(",", array_intersect($tableAttributes, $requestedAttributes));
		}

		if ($CONFIG_DBTYPE == 'pgsql') {
			$sql = "SELECT " . $toSelect . " FROM (SELECT *, (select array_to_string(array_agg(`tag`),',')
				from `*PREFIX*bookmarks_tags` where `bookmark_id` = `b2`.`id`) as `tags`
				FROM `*PREFIX*bookmarks` `b2`
				WHERE `user_id` = ? ) as `b` WHERE true ";
		} else {
			$sql = "SELECT " . $toSelect . ", (SELECT GROUP_CONCAT(`tag`) from `*PREFIX*bookmarks_tags`
				WHERE `bookmark_id` = `b`.`id`) as `tags`
				FROM `*PREFIX*bookmarks` `b`
				WHERE `user_id` = ? ";
		}

		$params = array($userid);

		if ($public) {
			$sql .= ' AND public = 1 ';
		}

		if (count($filters) > 0) {
			Bookmarks::findBookmarksBuildFilter($sql, $params, $filters, $filterTagOnly, $tagFilterConjunction, $CONFIG_DBTYPE);
		}

		if (!in_array($sqlSortColumn, $tableAttributes)) {
			$sqlSortColumn = 'lastmodified';
		}
		$sql .= " ORDER BY " . $sqlSortColumn . " DESC ";
		if ($limit == -1 || $limit === false) {
			$limit = null;
			$offset = null;
		}

		$query = $db->prepareQuery($sql, $limit, $offset);
		$results = $query->execute($params)->fetchAll();
		$bookmarks = array();
		foreach ($results as $result) {
			if ($returnTags) {
				$result['tags'] = explode(',', $result['tags']);
			} else {
				unset($result['tags']);
			}
			$bookmarks[] = $result;
		}
		return $bookmarks;
	}

	private static function findBookmarksBuildFilter(&$sql, &$params, $filters, $filterTagOnly, $tagFilterConjunction, $CONFIG_DBTYPE) {
		$tagOrSearch = false;
		$connectWord = 'AND';

		if ($tagFilterConjunction == 'or') {
			$tagOrSearch = true;
			$connectWord = 'OR';
		}

		if ($filterTagOnly) {
			if ($tagOrSearch) {
				$sql .= 'AND (';
			} else {
				$sql .= 'AND';
			}
			$exist_clause = " exists (SELECT `id` FROM  `*PREFIX*bookmarks_tags`
				`t2` WHERE `t2`.`bookmark_id` = `b`.`id` AND `tag` = ?) ";
			$sql .= str_repeat($exist_clause . $connectWord, count($filters));
			if ($tagOrSearch) {
				$sql = rtrim($sql, 'OR');
				$sql .= ')';
			} else {
				$sql = rtrim($sql, 'AND');
			}
			$params = array_merge($params, $filters);
		} else {
			if ($CONFIG_DBTYPE == 'mysql') { //Dirty hack to allow usage of alias in where
				$sql .= ' HAVING true ';
			}
			foreach ($filters as $filter) {
				if ($CONFIG_DBTYPE == 'mysql') {
					$sql .= ' AND lower( concat(url,title,description,IFNULL(tags,\'\') )) like ? ';
				} else {
					$sql .= ' AND lower(url || title || description || ifnull(tags,\'\') ) like ? ';
				}
				$params[] = '%' . strtolower($filter) . '%';
			}
		}
	}

	/**
	 * @brief Delete bookmark with specific id
	 * @param $userId UserId
	 * @param IDb $db Database Interface
	 * @param $id Bookmark ID to delete
	 * @return boolean Success of operation
	 */
	public static function deleteUrl($userId, IDb $db, $id) {
		$user = $userId;

		$query = $db->prepareQuery("
				SELECT `id` FROM `*PREFIX*bookmarks`
				WHERE `id` = ?
				AND `user_id` = ?
				");

		$result = $query->execute(array($id, $user));
		$id = $result->fetchOne();
		if ($id === false) {
			return false;
		}

		$query = $db->prepareQuery("
			DELETE FROM `*PREFIX*bookmarks`
			WHERE `id` = ?
			");

		$query->execute(array($id));

		$query = $db->prepareQuery("
			DELETE FROM `*PREFIX*bookmarks_tags`
			WHERE `bookmark_id` = ?
			");

		$query->execute(array($id));
		return true;
	}

	/**
	 * @brief Rename a tag
	 * @param $userId UserId
	 * @param IDb $db Database Interface
	 * @param string $old Old Tag Name
	 * @param string $new New Tag Name
	 * @return boolean Success of operation
	 */
	public static function renameTag($userId, IDb $db, $old, $new) {
		$user_id = $userId;
		$CONFIG_DBTYPE = \OCP\Config::getSystemValue('dbtype', 'sqlite');


		if ($CONFIG_DBTYPE == 'sqlite' or $CONFIG_DBTYPE == 'sqlite3') {
			// Update tags to the new label unless it already exists a tag like this
			$query = $db->prepareQuery("
				UPDATE OR REPLACE `*PREFIX*bookmarks_tags`
				SET `tag` = ?
				WHERE `tag` = ?
				AND exists( select `b`.`id` from `*PREFIX*bookmarks` `b`
				WHERE `b`.`user_id` = ? AND `bookmark_id` = `b`.`id`)
			");

			$params = array(
				$new,
				$old,
				$user_id,
			);

			$query->execute($params);
		} else {

			// Remove potentialy duplicated tags
			$query = $db->prepareQuery("
			DELETE FROM `*PREFIX*bookmarks_tags` as `tgs` WHERE `tgs`.`tag` = ?
			AND exists( SELECT `id` FROM `*PREFIX*bookmarks` WHERE `user_id` = ?
			AND `tgs`.`bookmark_id` = `id`)
			AND exists( SELECT `t`.`tag` FROM `*PREFIX*bookmarks_tags` `t` where `t`.`tag` = ?
			AND `tgs`.`bookmark_id` = `t`.`bookmark_id`");

			$params = array(
				$new,
				$user_id,
			);

			$query->execute($params);


			// Update tags to the new label unless it already exists a tag like this
			$query = $db->prepareQuery("
			UPDATE `*PREFIX*bookmarks_tags`
			SET `tag` = ?
			WHERE `tag` = ?
			AND exists( SELECT `b`.`id` FROM `*PREFIX*bookmarks` `b`
			WHERE `b`.`user_id` = ? AND `bookmark_id` = `b`.`id`)
			");

			$params = array(
				$new,
				$old,
				$user_id,
				$old,
			);

			$query->execute($params);
		}


		return true;
	}

	/**
	 * @brief Delete a tag
	 * @param $userid UserId
	 * @param IDb $db Database Interface
	 * @param string $old Tag Name to delete
	 * @return boolean Success of operation
	 */
	public static function deleteTag($userid, IDb $db, $old) {

		// Update the record
		$query = $db->prepareQuery("
		DELETE FROM `*PREFIX*bookmarks_tags`
		WHERE `tag` = ?
		AND exists( SELECT `id` FROM `*PREFIX*bookmarks` WHERE `user_id` = ? AND `bookmark_id` = `id`)
		");

		$params = array(
			$old,
			$userid,
		);

		$result = $query->execute($params);
		return $result;
	}

	/**
	 * Edit a bookmark
	 * @param $userid UserId
	 * @param IDb $db Database Interface
	 * @param int $id The id of the bookmark to edit
	 * @param string $url The url to set
	 * @param string $title Name of the bookmark
	 * @param array $tags Simple array of tags to qualify the bookmark (different tags are taken from values)
	 * @param string $description A longer description about the bookmark
	 * @param boolean $is_public True if the bookmark is publishable to not registered users
	 * @return null
	 */
	public static function editBookmark($userid, IDb $db, $id, $url, $title, $tags = array(), $description = '', $is_public = false) {

		$is_public = $is_public ? 1 : 0;
		$user_id = $userid;

		// Update the record
		$query = $db->prepareQuery("
		UPDATE `*PREFIX*bookmarks` SET
			`url` = ?, `title` = ?, `public` = ?, `description` = ?,
			`lastmodified` = UNIX_TIMESTAMP()
		WHERE `id` = ?
		AND `user_id` = ?
		");

		$params = array(
			htmlspecialchars_decode($url),
			htmlspecialchars_decode($title),
			$is_public,
			htmlspecialchars_decode($description),
			$id,
			$user_id,
		);

		$result = $query->execute($params);

		// Abort the operation if bookmark couldn't be set
		// (probably because the user is not allowed to edit this bookmark)
		if ($result == 0)
			exit();


		// Remove old tags
		$sql = "DELETE FROM `*PREFIX*bookmarks_tags`  WHERE `bookmark_id` = ?";
		$query = $db->prepareQuery($sql);
		$query->execute(array($id));

		// Add New Tags
		self::addTags($db, $id, $tags);

		return $id;
	}

	/**
	 * Add a bookmark
	 * @param $userid UserId
	 * @param IDb $db Database Interface
	 * @param string $url
	 * @param string $title Name of the bookmark
	 * @param array $tags Simple array of tags to qualify the bookmark (different tags are taken from values)
	 * @param string $description A longer description about the bookmark
	 * @param boolean $public True if the bookmark is publishable to not registered users
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
	 * @return int The id of the bookmark created
	 */
	public static function addBookmark($userid, IDb $db, $url, $title, $tags = array(), $description = '', $is_public = false, $added = 0) {
		$public = $is_public ? 1 : 0;
		$url_without_prefix = substr($url, strpos($url, "://") + 3); // Removes everything from the url before the "://" pattern (included)
		$enc_url_noprefix = htmlspecialchars_decode($url_without_prefix);
		$enc_url = htmlspecialchars_decode($url);
		// Change lastmodified date if the record if already exists
		$sql = "SELECT * from  `*PREFIX*bookmarks` WHERE `url` like ? AND `user_id` = ?";
		$query = $db->prepareQuery($sql, 1);
		$result = $query->execute(array('%'.$enc_url_noprefix, $userid)); // Find url in the db independantly from its protocol
		if ($row = $result->fetchRow()) {
			$params = array();
			$title_str = '';
			if (trim($title) != '') { // Do we replace the old title
				$title_str = ' , title = ?';
				$params[] = $title;
			}
			$desc_str = '';
			if (trim($description) != '') { // Do we replace the old description
				$desc_str = ' , description = ?';
				$params[] = $description;
			}
			$sql = "UPDATE `*PREFIX*bookmarks` SET `lastmodified` = "
					. "UNIX_TIMESTAMP() $title_str $desc_str , `url` = ? WHERE `url` like ? and `user_id` = ?";
			$params[] = $enc_url;
			$params[] = '%'.$enc_url_noprefix;
			$params[] = $userid;
			$query = $db->prepareQuery($sql);
			$query->execute($params);
			return $row['id'];
		} else {
			if ($added <= 0) {
				$query = $db->prepareQuery("
				INSERT INTO `*PREFIX*bookmarks`
				(`url`, `title`, `user_id`, `public`, `added`, `lastmodified`, `description`)
				VALUES (?, ?, ?, ?, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), ?)
				");

				$params = array(
					$enc_url,
					htmlspecialchars_decode($title),
					$userid,
					$public,
					$description,
				);
			} else {
				$query = $db->prepareQuery("
				INSERT INTO `*PREFIX*bookmarks`
				(`url`, `title`, `user_id`, `public`, `added`, `lastmodified`, `description`)
				VALUES (?, ?, ?, ?, ?, ?, ?)
				");

				$params = array(
					$enc_url,
					htmlspecialchars_decode($title),
					$userid,
					$public,
					$added,
					$added,
					$description,
				);
			}
			$query->execute($params);

			$b_id = $db->getInsertId('*PREFIX*bookmarks');

			if ($b_id !== false) {
				self::addTags($db, $b_id, $tags);
				return $b_id;
			}
		}
	}

	/**
	 * @brief Add a set of tags for a bookmark
	 * @param IDb $db Database Interface
	 * @param int $bookmarkID The bookmark reference
	 * @param array $tags Set of tags to add to the bookmark
	 * @return null
	 * */
	private static function addTags(IDb $db, $bookmarkID, $tags) {
		$sql = 'INSERT INTO `*PREFIX*bookmarks_tags` (`bookmark_id`, `tag`) select ?, ? ';
		$dbtype = \OCP\Config::getSystemValue('dbtype', 'sqlite');

		if ($dbtype === 'mysql') {
			$sql .= 'from dual ';
		}
		$sql .= 'where not exists(select * from `*PREFIX*bookmarks_tags` where `bookmark_id` = ? and `tag` = ?)';

		$query = $db->prepareQuery($sql);
		foreach ($tags as $tag) {
			$tag = trim($tag);
			if (empty($tag)) {
				//avoid saving white spaces
				continue;
			}
			$params = array($bookmarkID, $tag, $bookmarkID, $tag);
			$query->execute($params);
		}
	}

	/**
	 * @brief Import Bookmarks from html formatted file
	 * @param $user User imported Bookmarks should belong to
	 * @param IDb $db Database Interface
	 * @param $file Content to import
	 * @return null
	 * */
	public static function importFile($user, IDb $db, $file) {
		libxml_use_internal_errors(true);
		$dom = new \domDocument();

		$dom->loadHTMLFile($file);
		$links = $dom->getElementsByTagName('a');

		// Reintroduce transaction here!?
		foreach ($links as $link) {
			$title = $link->nodeValue;
			$ref = $link->getAttribute("href");
			$tag_str = '';
			if ($link->hasAttribute("tags"))
				$tag_str = $link->getAttribute("tags");
			$tags = explode(',', $tag_str);

			$desc_str = '';
			if ($link->hasAttribute("description")) {
				$desc_str = $link->getAttribute("description");
			} else {
				/* Get description from a following <DD> when link in a
				 * <DT> (e.g., Delicious export) */
				$parent = $link->parentNode;
				if ($parent && $parent->tagName == "dt") {
					$dd = $parent->nextSibling;
					if ($dd->tagName == "dd") {
						$desc_str = trim($dd->nodeValue);
					}
				}
			}

			$private = FALSE;
			if ($link->hasAttribute("private") && $link->getAttribute("private") === "1") {
				$private = TRUE;
			}

			$added = 0;
			if ($link->hasAttribute("add_date")) {
				$added = $link->getAttribute("add_date");
			}

			self::addBookmark($user, $db, $ref, $title, $tags, $desc_str, $private, $added);
		}

		return array();
	}

	/**
	 * @brief Load Url and receive Metadata (Title)
	 * @param $url Url to load and analyze
	 * @return array Metadata for url;
	 * */
	public static function getURLMetadata($url) {
		
		$metadata = array();
		$metadata['url'] = $url;
		$page = "";
		
		try {
			$page = \OC::$server->getHTTPHelper()->getUrlContent($url);
		} catch (\Exception $e) {
			throw $e;
		}
		
		//Check for encoding of site.
		//If not UTF-8 convert it.
		$encoding = array();
		preg_match('/charset="?(.*?)["|;]/i', $page, $encoding);
		
		if (isset($encoding[1])) {
			$decodeFrom = strtoupper($encoding[1]);
		} else {
			$decodeFrom = 'UTF-8';
		}

		if ($page) {

			if ($decodeFrom != 'UTF-8') {
				$page = iconv($decodeFrom, "UTF-8", $page);
			}

			preg_match("/<title>(.*)<\/title>/si", $page, $match);
			
			if (isset($match[1])) {
				$metadata['title'] = html_entity_decode($match[1]);
			}
		}
		
		return $metadata;
	}

	/**
	 * @brief Seperate Url String at comma charachter
	 * @param $line String of Tags
	 * @return array Array of Tags
	 * */
	public static function analyzeTagRequest($line) {
		$tags = explode(',', $line);
		$filterTag = array();
		foreach ($tags as $tag) {
			if (trim($tag) != '')
				$filterTag[] = trim($tag);
		}
		return $filterTag;
	}

}


1		<?php
2
3		/**
4		* ownCloud - bookmarks plugin
5		*
6		* @author Arthur Schiwon
7		* @copyright 2011 Arthur Schiwon [email protected]
8		*
9		* This library is free software; you can redistribute it and/or
10		* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
11		* License as published by the Free Software Foundation; either
12		* version 3 of the License, or any later version.
13		*
14		* This library is distributed in the hope that it will be useful,
15		* but WITHOUT ANY WARRANTY; without even the implied warranty of
16		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17		* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
18		*
19		* You should have received a copy of the GNU Affero General Public
20		* License along with this library. If not, see <http://www.gnu.org/licenses/>.
21		*
22		*/
23		/**
24		* This class manages bookmarks
25		*/
26
27		namespace OCA\Bookmarks\Controller\Lib;
28
29		use \OCP\IDb;
30
31		class Bookmarks {
32
33		/**
34		* @brief Finds all tags for bookmarks
35		* @param $userId UserId
36		* @param IDb $db Database Interface
37		* @param filterTags array of tag to look for if empty then every tag
38		* @param offset integer offset
39		* @param limit integer of item to return
40		* @return Found Tags
41		*/
42	1	public static function findTags($userId, IDb $db, $filterTags = array(), $offset = 0, $limit = -1) {
43	1	$params = array_merge($filterTags, $filterTags);
44	1	array_unshift($params, $userId);
45	1	$not_in = '';
46	1	if (!empty($filterTags)) {
47		$exist_clause = " AND exists (select 1 from `PREFIXbookmarks_tags`
48		`t2` where `t2`.`bookmark_id` = `t`.`bookmark_id` and `tag` = ?) ";
49
50		$not_in = ' AND `tag` not in (' . implode(',', array_fill(0, count($filterTags), '?')) . ')' .
51		str_repeat($exist_clause, count($filterTags));
52		}
53		$sql = 'SELECT tag, count() as nbr from PREFIX*bookmarks_tags t ' .
54	1	' WHERE EXISTS( SELECT 1 from PREFIXbookmarks bm where t.bookmark_id = bm.id and user_id = ?) ' .
55	1	$not_in .
56	1	' GROUP BY `tag` ORDER BY `nbr` DESC ';
57
58	1	$query = $db->prepareQuery($sql, $limit, $offset);
59	1	$tags = $query->execute($params)->fetchAll();
60	1	return $tags;
61		}
62
63		/**
64		* @brief Finds Bookmark with certain ID
65		* @param $id BookmarkId
66		* @param $userId UserId
67		* @param IDb $db Database Interface
68		* @return Specific Bookmark
69		*/
70	3	public static function findUniqueBookmark($id, $userId, IDb $db) {
71	3	$CONFIG_DBTYPE = \OCP\Config::getSystemValue('dbtype', 'sqlite');
72	3	if ($CONFIG_DBTYPE == 'pgsql') {
73		$group_fct = 'array_agg(`tag`)';
74		} else {
75	3	$group_fct = 'GROUP_CONCAT(`tag`)';
76		}
77		$sql = "SELECT , (select $group_fct from `PREFIX*bookmarks_tags` where `bookmark_id` = `b`.`id`) as `tags`
78		FROM `PREFIXbookmarks` `b`
79	3	WHERE `user_id` = ? AND `id` = ?";
80	3	$query = $db->prepareQuery($sql);
81	3	$result = $query->execute(array($userId, $id))->fetchRow();
82	3	$result['tags'] = explode(',', $result['tags']);
83	3	return $result;
84		}
85
86		/**
87		* @brief Check if an URL is bookmarked
88		* @param $url Url of a possible bookmark
89		* @param $userId UserId
90		* @param IDb $db Database Interface
91		* @return boolean if the url is already bookmarked
92		*/
93	1	public static function bookmarkExists($url, $userId, IDb $db) {
94	1	$enc_url = htmlspecialchars_decode($url);
95	1	$sql = "SELECT id from `PREFIXbookmarks` where `url` = ? and `user_id` = ?";
96	1	$query = $db->prepareQuery($sql);
97	1	$result = $query->execute(array($enc_url, $userId))->fetchRow();
98	1	if ($result) {
99	1	return $result['id'];
100		} else {
101	1	return false;
102		}
103		}
104
105		/**
106		* @brief Finds all bookmarks, matching the filter
107		* @param $userid UserId
108		* @param IDb $db Database Interface
109		* @param int $offset offset
110		* @param string $sqlSortColumn result with this column
111		* @param string\|array $filters filters can be: empty -> no filter, a string -> filter this, a string array -> filter for all strings
112		* @param bool $filterTagOnly true, filter affects only tags, else filter affects url, title and tags
113		* @param int $limit limit of items to return (default 10) if -1 or false then all items are returned
114		* @param bool $public check if only public bookmarks should be returned
115		* @param array $requestedAttributes select all the attributes that should be returned. default is * + tags
116		* @param string $tagFilterConjunction select wether the filterTagOnly should filter with an AND or an OR conjunction
117		* @return Collection of specified bookmarks
118		*/
119	4	public static function findBookmarks(
120		$userid, IDb $db, $offset, $sqlSortColumn, $filters, $filterTagOnly, $limit = 10, $public = false, $requestedAttributes = null, $tagFilterConjunction = "and") {
121
122	4	$CONFIG_DBTYPE = \OCP\Config::getSystemValue('dbtype', 'sqlite');
123	4	if (is_string($filters)) {
124		$filters = array($filters);
125		}
126
127	4	$toSelect = '*';
128	4	$tableAttributes = array('id', 'url', 'title', 'user_id', 'description',
129	4	'public', 'added', 'lastmodified', 'clickcount',);
130
131	4	$returnTags = true;
132
133	4	if ($requestedAttributes != null) {
134
135	1	$key = array_search('tags', $requestedAttributes);
136	1	if ($key == false) {
137	1	$returnTags = false;
138	1	} else {
139		unset($requestedAttributes[$key]);
140		}
141
142	1	$toSelect = implode(",", array_intersect($tableAttributes, $requestedAttributes));
143	1	}
144
145	4	if ($CONFIG_DBTYPE == 'pgsql') {
146		$sql = "SELECT " . $toSelect . " FROM (SELECT *, (select array_to_string(array_agg(`tag`),',')
147		from `PREFIXbookmarks_tags` where `bookmark_id` = `b2`.`id`) as `tags`
148		FROM `PREFIXbookmarks` `b2`
149		WHERE `user_id` = ? ) as `b` WHERE true ";
150		} else {
151	4	$sql = "SELECT " . $toSelect . ", (SELECT GROUP_CONCAT(`tag`) from `PREFIXbookmarks_tags`
152		WHERE `bookmark_id` = `b`.`id`) as `tags`
153		FROM `PREFIXbookmarks` `b`
154	4	WHERE `user_id` = ? ";
155		}
156
157	4	$params = array($userid);
158
159	4	if ($public) {
160	1	$sql .= ' AND public = 1 ';
161	1	}
162
163	4	if (count($filters) > 0) {
164	2	Bookmarks::findBookmarksBuildFilter($sql, $params, $filters, $filterTagOnly, $tagFilterConjunction, $CONFIG_DBTYPE);
165	2	}
166
167	4	if (!in_array($sqlSortColumn, $tableAttributes)) {
168	1	$sqlSortColumn = 'lastmodified';
169	1	}
170	4	$sql .= " ORDER BY " . $sqlSortColumn . " DESC ";
171	4	if ($limit == -1 \|\| $limit === false) {
172	4	$limit = null;
173	4	$offset = null;
174	4	}
175
176	4	$query = $db->prepareQuery($sql, $limit, $offset);
177	4	$results = $query->execute($params)->fetchAll();
178	4	$bookmarks = array();
179	4	foreach ($results as $result) {
180	4	if ($returnTags) {
181	3	$result['tags'] = explode(',', $result['tags']);
182	3	} else {
183	1	unset($result['tags']);
184		}
185	4	$bookmarks[] = $result;
186	4	}
187	4	return $bookmarks;
188		}
189
190	2	private static function findBookmarksBuildFilter(&$sql, &$params, $filters, $filterTagOnly, $tagFilterConjunction, $CONFIG_DBTYPE) {
191	2	$tagOrSearch = false;
192	2	$connectWord = 'AND';
193
194	2	if ($tagFilterConjunction == 'or') {
195	1	$tagOrSearch = true;
196	1	$connectWord = 'OR';
197	1	}
198
199	2	if ($filterTagOnly) {
200	2	if ($tagOrSearch) {
201	1	$sql .= 'AND (';
202	1	} else {
203	1	$sql .= 'AND';
204		}
205		$exist_clause = " exists (SELECT `id` FROM `PREFIXbookmarks_tags`
206	2	`t2` WHERE `t2`.`bookmark_id` = `b`.`id` AND `tag` = ?) ";
207	2	$sql .= str_repeat($exist_clause . $connectWord, count($filters));
208	2	if ($tagOrSearch) {
209	1	$sql = rtrim($sql, 'OR');
210	1	$sql .= ')';
211	1	} else {
212	1	$sql = rtrim($sql, 'AND');
213		}
214	2	$params = array_merge($params, $filters);
215	2	} else {
216		if ($CONFIG_DBTYPE == 'mysql') { //Dirty hack to allow usage of alias in where
217		$sql .= ' HAVING true ';
218		}
219		foreach ($filters as $filter) {
220		if ($CONFIG_DBTYPE == 'mysql') {
221		$sql .= ' AND lower( concat(url,title,description,IFNULL(tags,\'\') )) like ? ';
222		} else {
223		$sql .= ' AND lower(url \|\| title \|\| description \|\| ifnull(tags,\'\') ) like ? ';
224		}
225		$params[] = '%' . strtolower($filter) . '%';
226		}
227		}
228	2	}
229
230		/**
231		* @brief Delete bookmark with specific id
232		* @param $userId UserId
233		* @param IDb $db Database Interface
234		* @param $id Bookmark ID to delete
235		* @return boolean Success of operation
236		*/
237	1	public static function deleteUrl($userId, IDb $db, $id) {
238	1	$user = $userId;
239
240	1	$query = $db->prepareQuery("
241		SELECT `id` FROM `PREFIXbookmarks`
242		WHERE `id` = ?
243		AND `user_id` = ?
244	1	");
245
246	1	$result = $query->execute(array($id, $user));
247	1	$id = $result->fetchOne();
248	1	if ($id === false) {
249		return false;
250		}
251
252	1	$query = $db->prepareQuery("
253		DELETE FROM `PREFIXbookmarks`
254		WHERE `id` = ?
255	1	");
256
257	1	$query->execute(array($id));
258
259	1	$query = $db->prepareQuery("
260		DELETE FROM `PREFIXbookmarks_tags`
261		WHERE `bookmark_id` = ?
262	1	");
263
264	1	$query->execute(array($id));
265	1	return true;
266		}
267
268		/**
269		* @brief Rename a tag
270		* @param $userId UserId
271		* @param IDb $db Database Interface
272		* @param string $old Old Tag Name
273		* @param string $new New Tag Name
274		* @return boolean Success of operation
275		*/
276		public static function renameTag($userId, IDb $db, $old, $new) {
277		$user_id = $userId;
278		$CONFIG_DBTYPE = \OCP\Config::getSystemValue('dbtype', 'sqlite');
279
280
281		if ($CONFIG_DBTYPE == 'sqlite' or $CONFIG_DBTYPE == 'sqlite3') {
282		// Update tags to the new label unless it already exists a tag like this
283		$query = $db->prepareQuery("
284		UPDATE OR REPLACE `PREFIXbookmarks_tags`
285		SET `tag` = ?
286		WHERE `tag` = ?
287		AND exists( select `b`.`id` from `PREFIXbookmarks` `b`
288		WHERE `b`.`user_id` = ? AND `bookmark_id` = `b`.`id`)
289		");
290
291		$params = array(
292		$new,
293		$old,
294		$user_id,
295		);
296
297		$query->execute($params);
298		} else {
299
300		// Remove potentialy duplicated tags
301		$query = $db->prepareQuery("
302		DELETE FROM `PREFIXbookmarks_tags` as `tgs` WHERE `tgs`.`tag` = ?
303		AND exists( SELECT `id` FROM `PREFIXbookmarks` WHERE `user_id` = ?
304		AND `tgs`.`bookmark_id` = `id`)
305		AND exists( SELECT `t`.`tag` FROM `PREFIXbookmarks_tags` `t` where `t`.`tag` = ?
306		AND `tgs`.`bookmark_id` = `t`.`bookmark_id`");
307
308		$params = array(
309		$new,
310		$user_id,
311		);
312
313		$query->execute($params);
314
315
316		// Update tags to the new label unless it already exists a tag like this
317		$query = $db->prepareQuery("
318		UPDATE `PREFIXbookmarks_tags`
319		SET `tag` = ?
320		WHERE `tag` = ?
321		AND exists( SELECT `b`.`id` FROM `PREFIXbookmarks` `b`
322		WHERE `b`.`user_id` = ? AND `bookmark_id` = `b`.`id`)
323		");
324
325		$params = array(
326		$new,
327		$old,
328		$user_id,
329		$old,
330		);
331
332		$query->execute($params);
333		}
334
335
336		return true;
337		}
338
339		/**
340		* @brief Delete a tag
341		* @param $userid UserId
342		* @param IDb $db Database Interface
343		* @param string $old Tag Name to delete
344		* @return boolean Success of operation
345		*/
346		public static function deleteTag($userid, IDb $db, $old) {
347
348		// Update the record
349		$query = $db->prepareQuery("
350		DELETE FROM `PREFIXbookmarks_tags`
351		WHERE `tag` = ?
352		AND exists( SELECT `id` FROM `PREFIXbookmarks` WHERE `user_id` = ? AND `bookmark_id` = `id`)
353		");
354
355		$params = array(
356		$old,
357		$userid,
358		);
359
360		$result = $query->execute($params);
361		return $result;
362		}
363
364		/**
365		* Edit a bookmark
366		* @param $userid UserId
367		* @param IDb $db Database Interface
368		* @param int $id The id of the bookmark to edit
369		* @param string $url The url to set
370		* @param string $title Name of the bookmark
371		* @param array $tags Simple array of tags to qualify the bookmark (different tags are taken from values)
372		* @param string $description A longer description about the bookmark
373		* @param boolean $is_public True if the bookmark is publishable to not registered users
374		* @return null
375		*/
376	1	public static function editBookmark($userid, IDb $db, $id, $url, $title, $tags = array(), $description = '', $is_public = false) {
377
378	1	$is_public = $is_public ? 1 : 0;
379	1	$user_id = $userid;
380
381		// Update the record
382	1	$query = $db->prepareQuery("
383		UPDATE `PREFIXbookmarks` SET
384		`url` = ?, `title` = ?, `public` = ?, `description` = ?,
385		`lastmodified` = UNIX_TIMESTAMP()
386		WHERE `id` = ?
387		AND `user_id` = ?
388	1	");
389
390		$params = array(
391	1	htmlspecialchars_decode($url),
392	1	htmlspecialchars_decode($title),
393	1	$is_public,
394	1	htmlspecialchars_decode($description),
395	1	$id,
396	1	$user_id,
397	1	);
398
399	1	$result = $query->execute($params);
400
401		// Abort the operation if bookmark couldn't be set
402		// (probably because the user is not allowed to edit this bookmark)
403	1	if ($result == 0)
404	1	exit();
405
406
407		// Remove old tags
408	1	$sql = "DELETE FROM `PREFIXbookmarks_tags` WHERE `bookmark_id` = ?";
409	1	$query = $db->prepareQuery($sql);
410	1	$query->execute(array($id));
411
412		// Add New Tags
413	1	self::addTags($db, $id, $tags);
414
415	1	return $id;
416		}
417
418		/**
419		* Add a bookmark
420		* @param $userid UserId
421		* @param IDb $db Database Interface
422		* @param string $url
423		* @param string $title Name of the bookmark
424		* @param array $tags Simple array of tags to qualify the bookmark (different tags are taken from values)
425		* @param string $description A longer description about the bookmark
426		* @param boolean $public True if the bookmark is publishable to not registered users
		0 ignored issues – show Documentation introduced 2015-12-06 07:12 UTC by Report Bug Copy Issue Report There is no parameter named `$public`. Did you maybe mean `$is_public`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
427		* @return int The id of the bookmark created
428		*/
429	9	public static function addBookmark($userid, IDb $db, $url, $title, $tags = array(), $description = '', $is_public = false, $added = 0) {
430	9	$public = $is_public ? 1 : 0;
431	9	$url_without_prefix = substr($url, strpos($url, "://") + 3); // Removes everything from the url before the "://" pattern (included)
432	9	$enc_url_noprefix = htmlspecialchars_decode($url_without_prefix);
433	9	$enc_url = htmlspecialchars_decode($url);
434		// Change lastmodified date if the record if already exists
435	9	$sql = "SELECT * from `PREFIXbookmarks` WHERE `url` like ? AND `user_id` = ?";
436	9	$query = $db->prepareQuery($sql, 1);
437	9	$result = $query->execute(array('%'.$enc_url_noprefix, $userid)); // Find url in the db independantly from its protocol
438	9	if ($row = $result->fetchRow()) {
439		$params = array();
440		$title_str = '';
441		if (trim($title) != '') { // Do we replace the old title
442		$title_str = ' , title = ?';
443		$params[] = $title;
444		}
445		$desc_str = '';
446		if (trim($description) != '') { // Do we replace the old description
447		$desc_str = ' , description = ?';
448		$params[] = $description;
449		}
450		$sql = "UPDATE `PREFIXbookmarks` SET `lastmodified` = "
451		. "UNIX_TIMESTAMP() $title_str $desc_str , `url` = ? WHERE `url` like ? and `user_id` = ?";
452		$params[] = $enc_url;
453		$params[] = '%'.$enc_url_noprefix;
454		$params[] = $userid;
455		$query = $db->prepareQuery($sql);
456		$query->execute($params);
457		return $row['id'];
458		} else {
459	9	if ($added <= 0) {
460	9	$query = $db->prepareQuery("
461		INSERT INTO `PREFIXbookmarks`
462		(`url`, `title`, `user_id`, `public`, `added`, `lastmodified`, `description`)
463		VALUES (?, ?, ?, ?, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), ?)
464	9	");
465
466		$params = array(
467	9	$enc_url,
468	9	htmlspecialchars_decode($title),
469	9	$userid,
470	9	$public,
471	9	$description,
472	9	);
473	9	} else {
474		$query = $db->prepareQuery("
475		INSERT INTO `PREFIXbookmarks`
476		(`url`, `title`, `user_id`, `public`, `added`, `lastmodified`, `description`)
477		VALUES (?, ?, ?, ?, ?, ?, ?)
478		");
479
480		$params = array(
481		$enc_url,
482		htmlspecialchars_decode($title),
483		$userid,
484		$public,
485		$added,
486		$added,
487		$description,
488		);
489		}
490	9	$query->execute($params);
491
492	9	$b_id = $db->getInsertId('PREFIXbookmarks');
493
494	9	if ($b_id !== false) {
495	9	self::addTags($db, $b_id, $tags);
496	9	return $b_id;
497		}
498		}
499		}
500
501		/**
502		* @brief Add a set of tags for a bookmark
503		* @param IDb $db Database Interface
504		* @param int $bookmarkID The bookmark reference
505		* @param array $tags Set of tags to add to the bookmark
506		* @return null
507		* */
508	9	private static function addTags(IDb $db, $bookmarkID, $tags) {
509	9	$sql = 'INSERT INTO `PREFIXbookmarks_tags` (`bookmark_id`, `tag`) select ?, ? ';
510	9	$dbtype = \OCP\Config::getSystemValue('dbtype', 'sqlite');
511
512	9	if ($dbtype === 'mysql') {
513		$sql .= 'from dual ';
514		}
515	9	$sql .= 'where not exists(select * from `PREFIXbookmarks_tags` where `bookmark_id` = ? and `tag` = ?)';
516
517	9	$query = $db->prepareQuery($sql);
518	9	foreach ($tags as $tag) {
519	9	$tag = trim($tag);
520	9	if (empty($tag)) {
521		//avoid saving white spaces
522		continue;
523		}
524	9	$params = array($bookmarkID, $tag, $bookmarkID, $tag);
525	9	$query->execute($params);
526	9	}
527	9	}
528
529		/**
530		* @brief Import Bookmarks from html formatted file
531		* @param $user User imported Bookmarks should belong to
532		* @param IDb $db Database Interface
533		* @param $file Content to import
534		* @return null
535		* */
536		public static function importFile($user, IDb $db, $file) {
537		libxml_use_internal_errors(true);
538		$dom = new \domDocument();
539
540		$dom->loadHTMLFile($file);
541		$links = $dom->getElementsByTagName('a');
542
543		// Reintroduce transaction here!?
544		foreach ($links as $link) {
545		$title = $link->nodeValue;
546		$ref = $link->getAttribute("href");
547		$tag_str = '';
548		if ($link->hasAttribute("tags"))
549		$tag_str = $link->getAttribute("tags");
550		$tags = explode(',', $tag_str);
551
552		$desc_str = '';
553		if ($link->hasAttribute("description")) {
554		$desc_str = $link->getAttribute("description");
555		} else {
556		/* Get description from a following <DD> when link in a
557		* <DT> (e.g., Delicious export) */
558		$parent = $link->parentNode;
559		if ($parent && $parent->tagName == "dt") {
560		$dd = $parent->nextSibling;
561		if ($dd->tagName == "dd") {
562		$desc_str = trim($dd->nodeValue);
563		}
564		}
565		}
566
567		$private = FALSE;
568		if ($link->hasAttribute("private") && $link->getAttribute("private") === "1") {
569		$private = TRUE;
570		}
571
572		$added = 0;
573		if ($link->hasAttribute("add_date")) {
574		$added = $link->getAttribute("add_date");
575		}
576
577		self::addBookmark($user, $db, $ref, $title, $tags, $desc_str, $private, $added);
578		}
579
580		return array();
581		}
582
583		/**
584		* @brief Load Url and receive Metadata (Title)
585		* @param $url Url to load and analyze
586		* @return array Metadata for url;
587		* */
588	1	public static function getURLMetadata($url) {
589
590	1	$metadata = array();
591	1	$metadata['url'] = $url;
592	1	$page = "";
593
594		try {
595	1	$page = \OC::$server->getHTTPHelper()->getUrlContent($url);
596	1	} catch (\Exception $e) {
597		throw $e;
598		}
599
600		//Check for encoding of site.
601		//If not UTF-8 convert it.
602	1	$encoding = array();
603	1	preg_match('/charset="?(.*?)["\|;]/i', $page, $encoding);
604
605	1	if (isset($encoding[1])) {
606	1	$decodeFrom = strtoupper($encoding[1]);
607	1	} else {
608		$decodeFrom = 'UTF-8';
609		}
610
611	1	if ($page) {
612
613	1	if ($decodeFrom != 'UTF-8') {
614	1	$page = iconv($decodeFrom, "UTF-8", $page);
615	1	}
616
617	1	preg_match("/<title>(.*)<\/title>/si", $page, $match);
618
619	1	if (isset($match[1])) {
620	1	$metadata['title'] = html_entity_decode($match[1]);
621	1	}
622	1	}
623
624	1	return $metadata;
625		}
626
627		/**
628		* @brief Seperate Url String at comma charachter
629		* @param $line String of Tags
630		* @return array Array of Tags
631		* */
632		public static function analyzeTagRequest($line) {
633		$tags = explode(',', $line);
634		$filterTag = array();
635		foreach ($tags as $tag) {
636		if (trim($tag) != '')
637		$filterTag[] = trim($tag);
638		}
639		return $filterTag;
640		}
641
642		}
643

owncloud / bookmarks

Pull Request — master (#185)

Bookmarks::addBookmark() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Many Parameters

Long Method

Many Parameters

Duplication Side-by-Side

Filter issues like