Bookmarks::getURLMetadata() - Code Metrics - Inspection of "[tx-robot] updated from transifex" - owncloud/bookmarks - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1b93f9...7b1849 )

unknown

created 2016-08-02 00:12 UTC

Bookmarks::getURLMetadata() C

↳ Parent: Bookmarks

Complexity

Conditions	7
Paths	23

Size

Total Lines	43
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	26
CRAP Score	7.0178

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
c	3
b	1
f	0
dl	0
loc	43
ccs	26
cts	28
cp	0.9286
rs	6.7272
cc	7
eloc	25
nc	23
nop	1
crap	7.0178

<?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 string $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 int $id BookmarkId
	 * @param string $userId UserId
	 * @param IDb $db Database Interface
	 * @return array 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 string $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 string $userId UserId
	 * @param IDb $db Database Interface
	 * @param int $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,
				$new
			);

			$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
			);

			$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 string $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 string $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) {
		$public = $is_public ? 1 : 0;
		$url_without_prefix = trim(substr($url, strpos($url, "://") + 3)); // Removes everything from the url before the "://" pattern (included)
		if($url_without_prefix === '') {
			throw new \InvalidArgumentException('Bookmark URL is missing');
		}
		$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 {
			$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,
			);
			$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 string $user User imported Bookmarks should belong to
	 * @param IDb $db Database Interface
	 * @param string $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');

		$l = \OC::$server->getL10NFactory()->get('bookmarks');
		$errors = [];

		// Reintroduce transaction here!?
		foreach ($links as $link) {
			/* @var \DOMElement $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");
			try {
				self::addBookmark($user, $db, $ref, $title, $tags, $desc_str);
			} catch (\InvalidArgumentException $e) {
				\OC::$server->getLogger()->logException($e, ['app' => 'bookmarks']);
				$errors[] =  $l->t('Failed to import one bookmark, because: ') . $e->getMessage();
			}
		}

		return $errors;
	}

	/**
	 * @brief Load Url and receive Metadata (Title)
	 * @param string $url Url to load and analyze
	 * @return array Metadata for url;
	 * @throws \Exception
	 */
	public static function getURLMetadata($url) {
		
		$metadata = array();
		$metadata['url'] = $url;
		$page = "";
		
		try {
			$request = \OC::$server->getHTTPClientService()->newClient()->get($url);
			$page = $request->getBody();
			$contentType = $request->getHeader('Content-Type');
		} catch (\Exception $e) {
			throw $e;
		}
		
		//Check for encoding of site.
		//If not UTF-8 convert it.
		$encoding = array();
		preg_match('#.+?/.+?;\\s?charset\\s?=\\s?(.+)#i', $contentType, $encoding);
		if(empty($encoding)) {
			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 string $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 int $id BookmarkId
66		* @param string $userId UserId
67		* @param IDb $db Database Interface
68		* @return array Specific Bookmark
69		*/
70	2	public static function findUniqueBookmark($id, $userId, IDb $db) {
71	2	$CONFIG_DBTYPE = \OCP\Config::getSystemValue('dbtype', 'sqlite');
72	2	if ($CONFIG_DBTYPE == 'pgsql') {
73		$group_fct = 'array_agg(`tag`)';
74		} else {
75	2	$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	2	WHERE `user_id` = ? AND `id` = ?";
80	2	$query = $db->prepareQuery($sql);
81	2	$result = $query->execute(array($userId, $id))->fetchRow();
82	2	$result['tags'] = explode(',', $result['tags']);
83	2	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 string $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	3	public static function findBookmarks(
120		$userid, IDb $db, $offset, $sqlSortColumn, $filters, $filterTagOnly, $limit = 10, $public = false, $requestedAttributes = null, $tagFilterConjunction = "and") {
121
122	3	$CONFIG_DBTYPE = \OCP\Config::getSystemValue('dbtype', 'sqlite');
123	3	if (is_string($filters)) {
124		$filters = array($filters);
125		}
126
127	3	$toSelect = '*';
128	3	$tableAttributes = array('id', 'url', 'title', 'user_id', 'description',
129	3	'public', 'added', 'lastmodified', 'clickcount',);
130
131	3	$returnTags = true;
132
133	3	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	3	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	3	$sql = "SELECT " . $toSelect . ", (SELECT GROUP_CONCAT(`tag`) from `PREFIXbookmarks_tags`
152		WHERE `bookmark_id` = `b`.`id`) as `tags`
153		FROM `PREFIXbookmarks` `b`
154	3	WHERE `user_id` = ? ";
155		}
156
157	3	$params = array($userid);
158
159	3	if ($public) {
160	1	$sql .= ' AND public = 1 ';
161	1	}
162
163	3	if (count($filters) > 0) {
164	2	Bookmarks::findBookmarksBuildFilter($sql, $params, $filters, $filterTagOnly, $tagFilterConjunction, $CONFIG_DBTYPE);
165	2	}
166
167	3	if (!in_array($sqlSortColumn, $tableAttributes)) {
168	1	$sqlSortColumn = 'lastmodified';
169	1	}
170	3	$sql .= " ORDER BY " . $sqlSortColumn . " DESC ";
171	3	if ($limit == -1 \|\| $limit === false) {
172	3	$limit = null;
173	3	$offset = null;
174	3	}
175
176	3	$query = $db->prepareQuery($sql, $limit, $offset);
177	3	$results = $query->execute($params)->fetchAll();
178	3	$bookmarks = array();
179	3	foreach ($results as $result) {
180	3	if ($returnTags) {
181	2	$result['tags'] = explode(',', $result['tags']);
182	2	} else {
183	1	unset($result['tags']);
184		}
185	3	$bookmarks[] = $result;
186	3	}
187	3	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 string $userId UserId
233		* @param IDb $db Database Interface
234		* @param int $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		$new
312		);
313
314		$query->execute($params);
315
316
317		// Update tags to the new label unless it already exists a tag like this
318		$query = $db->prepareQuery("
319		UPDATE `PREFIXbookmarks_tags`
320		SET `tag` = ?
321		WHERE `tag` = ?
322		AND exists( SELECT `b`.`id` FROM `PREFIXbookmarks` `b`
323		WHERE `b`.`user_id` = ? AND `bookmark_id` = `b`.`id`)
324		");
325
326		$params = array(
327		$new,
328		$old,
329		$user_id
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 string $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 string $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	8	public static function addBookmark($userid, IDb $db, $url, $title, $tags = array(), $description = '', $is_public = false) {
430	8	$public = $is_public ? 1 : 0;
431	8	$url_without_prefix = trim(substr($url, strpos($url, "://") + 3)); // Removes everything from the url before the "://" pattern (included)
432	8	if($url_without_prefix === '') {
433		throw new \InvalidArgumentException('Bookmark URL is missing');
434		}
435	8	$enc_url_noprefix = htmlspecialchars_decode($url_without_prefix);
436	8	$enc_url = htmlspecialchars_decode($url);
437		// Change lastmodified date if the record if already exists
438	8	$sql = "SELECT * from `PREFIXbookmarks` WHERE `url` like ? AND `user_id` = ?";
439	8	$query = $db->prepareQuery($sql, 1);
440	8	$result = $query->execute(array('%'.$enc_url_noprefix, $userid)); // Find url in the db independantly from its protocol
441	8	if ($row = $result->fetchRow()) {
442		$params = array();
443		$title_str = '';
444		if (trim($title) != '') { // Do we replace the old title
445		$title_str = ' , title = ?';
446		$params[] = $title;
447		}
448		$desc_str = '';
449		if (trim($description) != '') { // Do we replace the old description
450		$desc_str = ' , description = ?';
451		$params[] = $description;
452		}
453		$sql = "UPDATE `PREFIXbookmarks` SET `lastmodified` = "
454		. "UNIX_TIMESTAMP() $title_str $desc_str , `url` = ? WHERE `url` like ? and `user_id` = ?";
455		$params[] = $enc_url;
456		$params[] = '%'.$enc_url_noprefix;
457		$params[] = $userid;
458		$query = $db->prepareQuery($sql);
459		$query->execute($params);
460		return $row['id'];
461		} else {
462	8	$query = $db->prepareQuery("
463		INSERT INTO `PREFIXbookmarks`
464		(`url`, `title`, `user_id`, `public`, `added`, `lastmodified`, `description`)
465		VALUES (?, ?, ?, ?, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), ?)
466	8	");
467
468		$params = array(
469	8	$enc_url,
470	8	htmlspecialchars_decode($title),
471	8	$userid,
472	8	$public,
473	8	$description,
474	8	);
475	8	$query->execute($params);
476
477	8	$b_id = $db->getInsertId('PREFIXbookmarks');
478
479	8	if ($b_id !== false) {
480	8	self::addTags($db, $b_id, $tags);
481	8	return $b_id;
482		}
483		}
484		}
485
486		/**
487		* @brief Add a set of tags for a bookmark
488		* @param IDb $db Database Interface
489		* @param int $bookmarkID The bookmark reference
490		* @param array $tags Set of tags to add to the bookmark
491		* @return null
492		* */
493	8	private static function addTags(IDb $db, $bookmarkID, $tags) {
494	8	$sql = 'INSERT INTO `PREFIXbookmarks_tags` (`bookmark_id`, `tag`) select ?, ? ';
495	8	$dbtype = \OCP\Config::getSystemValue('dbtype', 'sqlite');
496
497	8	if ($dbtype === 'mysql') {
498		$sql .= 'from dual ';
499		}
500	8	$sql .= 'where not exists(select * from `PREFIXbookmarks_tags` where `bookmark_id` = ? and `tag` = ?)';
501
502	8	$query = $db->prepareQuery($sql);
503	8	foreach ($tags as $tag) {
504	8	$tag = trim($tag);
505	8	if (empty($tag)) {
506		//avoid saving white spaces
507		continue;
508		}
509	8	$params = array($bookmarkID, $tag, $bookmarkID, $tag);
510	8	$query->execute($params);
511	8	}
512	8	}
513
514		/**
515		* @brief Import Bookmarks from html formatted file
516		* @param string $user User imported Bookmarks should belong to
517		* @param IDb $db Database Interface
518		* @param string $file Content to import
519		* @return null
520		* */
521		public static function importFile($user, IDb $db, $file) {
522		libxml_use_internal_errors(true);
523		$dom = new \domDocument();
524
525		$dom->loadHTMLFile($file);
526		$links = $dom->getElementsByTagName('a');
527
528		$l = \OC::$server->getL10NFactory()->get('bookmarks');
529		$errors = [];
530
531		// Reintroduce transaction here!?
532		foreach ($links as $link) {
533		/* @var \DOMElement $link */
534		$title = $link->nodeValue;
535		$ref = $link->getAttribute("href");
536		$tag_str = '';
537		if ($link->hasAttribute("tags"))
538		$tag_str = $link->getAttribute("tags");
539		$tags = explode(',', $tag_str);
540
541		$desc_str = '';
542		if ($link->hasAttribute("description"))
543		$desc_str = $link->getAttribute("description");
544		try {
545		self::addBookmark($user, $db, $ref, $title, $tags, $desc_str);
546		} catch (\InvalidArgumentException $e) {
547		\OC::$server->getLogger()->logException($e, ['app' => 'bookmarks']);
548		$errors[] = $l->t('Failed to import one bookmark, because: ') . $e->getMessage();
549		}
550		}
551
552		return $errors;
553		}
554
555		/**
556		* @brief Load Url and receive Metadata (Title)
557		* @param string $url Url to load and analyze
558		* @return array Metadata for url;
559		* @throws \Exception
560		*/
561	1	public static function getURLMetadata($url) {
562
563	1	$metadata = array();
564	1	$metadata['url'] = $url;
565	1	$page = "";
566
567		try {
568	1	$request = \OC::$server->getHTTPClientService()->newClient()->get($url);
569	1	$page = $request->getBody();
570	1	$contentType = $request->getHeader('Content-Type');
571	1	} catch (\Exception $e) {
572		throw $e;
573		}
574
575		//Check for encoding of site.
576		//If not UTF-8 convert it.
577	1	$encoding = array();
578	1	preg_match('#.+?/.+?;\\s?charset\\s?=\\s?(.+)#i', $contentType, $encoding);
579	1	if(empty($encoding)) {
580	1	preg_match('/charset="?(.*?)["\|;]/i', $page, $encoding);
581	1	}
582
583	1	if (isset($encoding[1])) {
584	1	$decodeFrom = strtoupper($encoding[1]);
585	1	} else {
586		$decodeFrom = 'UTF-8';
587		}
588
589	1	if ($page) {
590
591	1	if ($decodeFrom != 'UTF-8') {
592	1	$page = iconv($decodeFrom, "UTF-8", $page);
593	1	}
594
595	1	preg_match("/<title>(.*)<\/title>/si", $page, $match);
596
597	1	if (isset($match[1])) {
598	1	$metadata['title'] = html_entity_decode($match[1]);
599	1	}
600	1	}
601
602	1	return $metadata;
603		}
604
605		/**
606		* @brief Seperate Url String at comma charachter
607		* @param $line String of Tags
608		* @return array Array of Tags
609		* */
610		public static function analyzeTagRequest($line) {
611		$tags = explode(',', $line);
612		$filterTag = array();
613		foreach ($tags as $tag) {
614		if (trim($tag) != '')
615		$filterTag[] = trim($tag);
616		}
617		return $filterTag;
618		}
619
620		}
621

owncloud / bookmarks

Push — master ( 1b93f9...7b1849 )

Bookmarks::getURLMetadata() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like