WatchedItemStore - Code Metrics - Inspection of "Daily Inspection: Merge "mediawiki.api.parse: Allo..." - wikimedia/mediawiki - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (8ef871)

unknown

created 2016-03-11 17:57 UTC

WatchedItemStore B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	522
Duplicated Lines	3.45 %

Coupling/Cohesion

Components	2
Dependencies	12

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	52
lcom	2
cbo	12
dl	18
loc	522
rs	7.9487
c	2
b	0
f	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	overrideDeferredUpdatesAddCallableUpdateCallback()	9	9	2
A	overrideRevisionGetTimestampFromIdCallback()	9	9	2
A	overrideDefaultInstance()	0	8	2
A	getDefaultInstance()	0	9	2
A	getCacheKey()	0	7	1
A	cache()	0	6	1
A	uncache()	0	3	1
A	getCached()	0	3	1
A	dbCond()	0	7	1
A	getWatchedItem()	0	7	2
B	loadWatchedItem()	0	28	3
A	isWatched()	0	3	1
A	addWatch()	0	3	1
B	addWatchBatch()	0	39	6
A	removeWatch()	0	21	3
B	updateNotificationTimestamp()	0	39	3
B	resetNotificationTimestamp()	0	38	6
C	getNotificationTimestamp()	0	46	7
A	duplicateAllAssociatedEntries()	0	11	3
B	duplicateEntry()	0	42	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like WatchedItemStore often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use WatchedItemStore, and based on these observations, apply Extract Interface, too.

<?php

use Wikimedia\Assert\Assert;

/**
 * Storage layer class for WatchedItems.
 * Database interaction.
 *
 * @author Addshore
 *
 * @since 1.27
 */
class WatchedItemStore {

	/**
	 * @var LoadBalancer
	 */
	private $loadBalancer;

	/**
	 * @var BagOStuff
	 */
	private $cache;

	/**
	 * @var callable|null
	 */
	private $deferredUpdatesAddCallableUpdateCallback;

	/**
	 * @var callable|null
	 */
	private $revisionGetTimestampFromIdCallback;

	/**
	 * @var self|null
	 */
	private static $instance;

	public function __construct( LoadBalancer $loadBalancer, BagOStuff $cache ) {
		$this->loadBalancer = $loadBalancer;
		$this->cache = $cache;
		$this->deferredUpdatesAddCallableUpdateCallback = [ 'DeferredUpdates', 'addCallableUpdate' ];
		$this->revisionGetTimestampFromIdCallback = [ 'Revision', 'getTimestampFromId' ];
	}

	/**
	 * Overrides the DeferredUpdates::addCallableUpdate callback
	 * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
	 *
	 * @param callable $callback
	 * @see DeferredUpdates::addCallableUpdate for callback signiture
	 *
	 * @throws MWException
	 */
	public function overrideDeferredUpdatesAddCallableUpdateCallback( $callback ) {
		if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
			throw new MWException(
				'Cannot override DeferredUpdates::addCallableUpdate callback in operation.'
			);
		}
		Assert::parameterType( 'callable', $callback, '$callback' );
		$this->deferredUpdatesAddCallableUpdateCallback = $callback;
	}

	/**
	 * Overrides the Revision::getTimestampFromId callback
	 * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
	 *
	 * @param callable $callback
	 * @see Revision::getTimestampFromId for callback signiture
	 *
	 * @throws MWException
	 */
	public function overrideRevisionGetTimestampFromIdCallback( $callback ) {
		if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
			throw new MWException(
				'Cannot override Revision::getTimestampFromId callback in operation.'
			);
		}
		Assert::parameterType( 'callable', $callback, '$callback' );
		$this->revisionGetTimestampFromIdCallback = $callback;
	}

	/**
	 * Overrides the default instance of this class
	 * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
	 *
	 * @param WatchedItemStore $store
	 *
	 * @throws MWException
	 */
	public static function overrideDefaultInstance( WatchedItemStore $store ) {
		if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
			throw new MWException(
				'Cannot override ' . __CLASS__ . 'default instance in operation.'
			);
		}
		self::$instance = $store;
	}

	/**
	 * @return self
	 */
	public static function getDefaultInstance() {
		if ( !self::$instance ) {
			self::$instance = new self(
				wfGetLB(),
				new HashBagOStuff( [ 'maxKeys' => 100 ] )
			);
		}
		return self::$instance;
	}

	private function getCacheKey( User $user, LinkTarget $target ) {
		return $this->cache->makeKey(
			(string)$target->getNamespace(),
			$target->getDBkey(),
			(string)$user->getId()
		);
	}

	private function cache( WatchedItem $item ) {
		$this->cache->set(
			$this->getCacheKey( $item->getUser(), $item->getLinkTarget() ),
			$item
		);
	}

	private function uncache( User $user, LinkTarget $target ) {
		$this->cache->delete( $this->getCacheKey( $user, $target ) );
	}

	/**
	 * @param User $user
	 * @param LinkTarget $target
	 *
	 * @return WatchedItem|null
	 */
	private function getCached( User $user, LinkTarget $target ) {
		return $this->cache->get( $this->getCacheKey( $user, $target ) );
	}

	/**
	 * Return an array of conditions to select or update the appropriate database
	 * row.
	 *
	 * @param User $user
	 * @param LinkTarget $target
	 *
	 * @return array
	 */
	private function dbCond( User $user, LinkTarget $target ) {
		return [
			'wl_user' => $user->getId(),
			'wl_namespace' => $target->getNamespace(),
			'wl_title' => $target->getDBkey(),
		];
	}

	/**
	 * Get an item (may be cached)
	 *
	 * @param User $user
	 * @param LinkTarget $target
	 *
	 * @return WatchedItem|false
	 */
	public function getWatchedItem( User $user, LinkTarget $target ) {
		$cached = $this->getCached( $user, $target );
		if ( $cached ) {
			return $cached;
		}
		return $this->loadWatchedItem( $user, $target );
	}

	/**
	 * Loads an item from the db
	 *
	 * @param User $user
	 * @param LinkTarget $target
	 *
	 * @return WatchedItem|false
	 */
	public function loadWatchedItem( User $user, LinkTarget $target ) {
		// Only loggedin user can have a watchlist
		if ( $user->isAnon() ) {
			return false;
		}

		$dbr = $this->loadBalancer->getConnection( DB_SLAVE, [ 'watchlist' ] );
		$row = $dbr->selectRow(
			'watchlist',
			'wl_notificationtimestamp',
			$this->dbCond( $user, $target ),
			__METHOD__
		);
		$this->loadBalancer->reuseConnection( $dbr );

		if ( !$row ) {
			return false;
		}

		$item = new WatchedItem(
			$user,
			$target,
			$row->wl_notificationtimestamp
		);
		$this->cache( $item );

		return $item;
	}

	/**
	 * Must be called separately for Subject & Talk namespaces
	 *
	 * @param User $user
	 * @param LinkTarget $target
	 *
	 * @return bool
	 */
	public function isWatched( User $user, LinkTarget $target ) {
		return (bool)$this->getWatchedItem( $user, $target );
	}

	/**
	 * Must be called separately for Subject & Talk namespaces
	 *
	 * @param User $user
	 * @param LinkTarget $target
	 */
	public function addWatch( User $user, LinkTarget $target ) {
		$this->addWatchBatch( [ [ $user, $target ] ] );
	}

	/**
	 * @param array[] $userTargetCombinations array of arrays containing [0] => User [1] => LinkTarget
	 *
	 * @return bool success
	 */
	public function addWatchBatch( array $userTargetCombinations ) {
		if ( $this->loadBalancer->getReadOnlyReason() !== false ) {
			return false;
		}

		$rows = [];
		foreach ( $userTargetCombinations as list( $user, $target ) ) {
			/**
			 * @var User $user
			 * @var LinkTarget $target
			 */

			// Only loggedin user can have a watchlist
			if ( $user->isAnon() ) {
				continue;
			}
			$rows[] = [
				'wl_user' => $user->getId(),
				'wl_namespace' => $target->getNamespace(),
				'wl_title' => $target->getDBkey(),
				'wl_notificationtimestamp' => null,
			];
			$this->uncache( $user, $target );
		}

		if ( !$rows ) {

			return false;
		}

		$dbw = $this->loadBalancer->getConnection( DB_MASTER, [ 'watchlist' ] );
		foreach ( array_chunk( $rows, 100 ) as $toInsert ) {
			// Use INSERT IGNORE to avoid overwriting the notification timestamp
			// if there's already an entry for this page
			$dbw->insert( 'watchlist', $toInsert, __METHOD__, 'IGNORE' );
		}
		$this->loadBalancer->reuseConnection( $dbw );

		return true;
	}

	/**
	 * Removes the an entry for the User watching the LinkTarget
	 * Must be called separately for Subject & Talk namespaces
	 *
	 * @param User $user
	 * @param LinkTarget $target
	 *
	 * @return bool success
	 * @throws DBUnexpectedError
	 * @throws MWException
	 */
	public function removeWatch( User $user, LinkTarget $target ) {
		// Only logged in user can have a watchlist
		if ( $this->loadBalancer->getReadOnlyReason() !== false || $user->isAnon() ) {
			return false;
		}

		$this->uncache( $user, $target );

		$dbw = $this->loadBalancer->getConnection( DB_MASTER, [ 'watchlist' ] );
		$dbw->delete( 'watchlist',
			[
				'wl_user' => $user->getId(),
				'wl_namespace' => $target->getNamespace(),
				'wl_title' => $target->getDBkey(),
			], __METHOD__
		);
		$success = (bool)$dbw->affectedRows();
		$this->loadBalancer->reuseConnection( $dbw );

		return $success;
	}

	/**
	 * @param User $editor The editor that triggered the update. Their notification
	 *  timestamp will not be updated(they have already seen it)
	 * @param LinkTarget $target The target to update timestamps for
	 * @param string $timestamp Set the update timestamp to this value
	 *
	 * @return int[] Array of user IDs the timestamp has been updated for
	 */
	public function updateNotificationTimestamp( User $editor, LinkTarget $target, $timestamp ) {
		$dbw = $this->loadBalancer->getConnection( DB_MASTER, [ 'watchlist' ] );
		$res = $dbw->select( [ 'watchlist' ],
			[ 'wl_user' ],
			[
				'wl_user != ' . intval( $editor->getId() ),
				'wl_namespace' => $target->getNamespace(),
				'wl_title' => $target->getDBkey(),
				'wl_notificationtimestamp IS NULL',
			], __METHOD__
		);

		$watchers = [];
		foreach ( $res as $row ) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			$watchers[] = intval( $row->wl_user );
		}

		if ( $watchers ) {

			// Update wl_notificationtimestamp for all watching users except the editor
			$fname = __METHOD__;
			$dbw->onTransactionIdle(
				function () use ( $dbw, $timestamp, $watchers, $target, $fname ) {
					$dbw->update( 'watchlist',
						[ /* SET */
							'wl_notificationtimestamp' => $dbw->timestamp( $timestamp )
						], [ /* WHERE */
							'wl_user' => $watchers,
							'wl_namespace' => $target->getNamespace(),
							'wl_title' => $target->getDBkey(),
						], $fname
					);
				}
			);
		}

		$this->loadBalancer->reuseConnection( $dbw );

		return $watchers;
	}

	/**
	 * Reset the notification timestamp of this entry
	 *
	 * @param User $user
	 * @param Title $title
	 * @param string $force Whether to force the write query to be executed even if the
	 *    page is not watched or the notification timestamp is already NULL.
	 *    'force' in order to force
	 * @param int $oldid The revision id being viewed. If not given or 0, latest revision is assumed.
	 *
	 * @return bool success
	 */
	public function resetNotificationTimestamp( User $user, Title $title, $force = '', $oldid = 0 ) {
		// Only loggedin user can have a watchlist
		if ( $this->loadBalancer->getReadOnlyReason() !== false || $user->isAnon() ) {
			return false;
		}

		$item = null;
		if ( $force != 'force' ) {
			$item = $this->loadWatchedItem( $user, $title );
			if ( !$item || $item->getNotificationTimestamp() === null ) {
				return false;
			}
		}

		// If the page is watched by the user (or may be watched), update the timestamp
		$job = new ActivityUpdateJob(
			$title,
			[
				'type'      => 'updateWatchlistNotification',
				'userid'    => $user->getId(),
				'notifTime' => $this->getNotificationTimestamp( $user, $title, $item, $force, $oldid ),
				'curTime'   => time()
			]
		);

		// Try to run this post-send
		// Calls DeferredUpdates::addCallableUpdate in normal operation
		call_user_func(
			$this->deferredUpdatesAddCallableUpdateCallback,
			function() use ( $job ) {
				$job->run();
			}
		);

		$this->uncache( $user, $title );

		return true;
	}

	private function getNotificationTimestamp( User $user, Title $title, $item, $force, $oldid ) {
		if ( !$oldid ) {
			// No oldid given, assuming latest revision; clear the timestamp.
			return null;
		}

		if ( !$title->getNextRevisionID( $oldid ) ) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
			// Oldid given and is the latest revision for this title; clear the timestamp.
			return null;
		}

		if ( $item === null ) {
			$item = $this->loadWatchedItem( $user, $title );
		}

		if ( !$item ) {
			// This can only happen if $force is enabled.
			return null;
		}

		// Oldid given and isn't the latest; update the timestamp.
		// This will result in no further notification emails being sent!
		// Calls Revision::getTimestampFromId in normal operation
		$notificationTimestamp = call_user_func(
			$this->revisionGetTimestampFromIdCallback,
			$title,
			$oldid
		);

		// We need to go one second to the future because of various strict comparisons
		// throughout the codebase
		$ts = new MWTimestamp( $notificationTimestamp );
		$ts->timestamp->add( new DateInterval( 'PT1S' ) );
		$notificationTimestamp = $ts->getTimestamp( TS_MW );

		if ( $notificationTimestamp < $item->getNotificationTimestamp() ) {
			if ( $force != 'force' ) {
				return false;
			} else {
				// This is a little silly…
				return $item->getNotificationTimestamp();
			}
		}

		return $notificationTimestamp;
	}

	/**
	 * Check if the given title already is watched by the user, and if so
	 * add a watch for the new title.
	 *
	 * To be used for page renames and such.
	 *
	 * @param LinkTarget $oldTarget
	 * @param LinkTarget $newTarget
	 */
	public function duplicateAllAssociatedEntries( LinkTarget $oldTarget, LinkTarget $newTarget ) {
		if ( !$oldTarget instanceof Title ) {
			$oldTarget = Title::newFromLinkTarget( $oldTarget );
		}
		if ( !$newTarget instanceof Title ) {
			$newTarget = Title::newFromLinkTarget( $newTarget );
		}

		$this->duplicateEntry( $oldTarget->getSubjectPage(), $newTarget->getSubjectPage() );
		$this->duplicateEntry( $oldTarget->getTalkPage(), $newTarget->getTalkPage() );
	}

	/**
	 * Check if the given title already is watched by the user, and if so
	 * add a watch for the new title.
	 *
	 * To be used for page renames and such.
	 * This must be called separately for Subject and Talk pages
	 *
	 * @param LinkTarget $oldTarget
	 * @param LinkTarget $newTarget
	 */
	public function duplicateEntry( LinkTarget $oldTarget, LinkTarget $newTarget ) {
		$dbw = $this->loadBalancer->getConnection( DB_MASTER, [ 'watchlist' ] );

		$result = $dbw->select(
			'watchlist',
			[ 'wl_user', 'wl_notificationtimestamp' ],
			[
				'wl_namespace' => $oldTarget->getNamespace(),
				'wl_title' => $oldTarget->getDBkey(),
			],
			__METHOD__,
			[ 'FOR UPDATE' ]
		);

		$newNamespace = $newTarget->getNamespace();
		$newDBkey = $newTarget->getDBkey();

		# Construct array to replace into the watchlist
		$values = [];
		foreach ( $result as $row ) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			$values[] = [
				'wl_user' => $row->wl_user,
				'wl_namespace' => $newNamespace,
				'wl_title' => $newDBkey,
				'wl_notificationtimestamp' => $row->wl_notificationtimestamp,
			];
		}

		if ( !empty( $values ) ) {
			# Perform replace
			# Note that multi-row replace is very efficient for MySQL but may be inefficient for
			# some other DBMSes, mostly due to poor simulation by us
			$dbw->replace(
				'watchlist',
				[ [ 'wl_user', 'wl_namespace', 'wl_title' ] ],
				$values,
				__METHOD__
			);
		}

		$this->loadBalancer->reuseConnection( $dbw );
	}

}


1		<?php
2
3		use Wikimedia\Assert\Assert;
4
5		/**
6		* Storage layer class for WatchedItems.
7		* Database interaction.
8		*
9		* @author Addshore
10		*
11		* @since 1.27
12		*/
13		class WatchedItemStore {
14
15		/**
16		* @var LoadBalancer
17		*/
18		private $loadBalancer;
19
20		/**
21		* @var BagOStuff
22		*/
23		private $cache;
24
25		/**
26		* @var callable\|null
27		*/
28		private $deferredUpdatesAddCallableUpdateCallback;
29
30		/**
31		* @var callable\|null
32		*/
33		private $revisionGetTimestampFromIdCallback;
34
35		/**
36		* @var self\|null
37		*/
38		private static $instance;
39
40		public function __construct( LoadBalancer $loadBalancer, BagOStuff $cache ) {
41		$this->loadBalancer = $loadBalancer;
42		$this->cache = $cache;
43		$this->deferredUpdatesAddCallableUpdateCallback = [ 'DeferredUpdates', 'addCallableUpdate' ];
44		$this->revisionGetTimestampFromIdCallback = [ 'Revision', 'getTimestampFromId' ];
45		}
46
47		/**
48		* Overrides the DeferredUpdates::addCallableUpdate callback
49		* This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
50		*
51		* @param callable $callback
52		* @see DeferredUpdates::addCallableUpdate for callback signiture
53		*
54		* @throws MWException
55		*/
56	View Code Duplication	public function overrideDeferredUpdatesAddCallableUpdateCallback( $callback ) {
57		if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
58		throw new MWException(
59		'Cannot override DeferredUpdates::addCallableUpdate callback in operation.'
60		);
61		}
62		Assert::parameterType( 'callable', $callback, '$callback' );
63		$this->deferredUpdatesAddCallableUpdateCallback = $callback;
64		}
65
66		/**
67		* Overrides the Revision::getTimestampFromId callback
68		* This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
69		*
70		* @param callable $callback
71		* @see Revision::getTimestampFromId for callback signiture
72		*
73		* @throws MWException
74		*/
75	View Code Duplication	public function overrideRevisionGetTimestampFromIdCallback( $callback ) {
76		if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
77		throw new MWException(
78		'Cannot override Revision::getTimestampFromId callback in operation.'
79		);
80		}
81		Assert::parameterType( 'callable', $callback, '$callback' );
82		$this->revisionGetTimestampFromIdCallback = $callback;
83		}
84
85		/**
86		* Overrides the default instance of this class
87		* This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
88		*
89		* @param WatchedItemStore $store
90		*
91		* @throws MWException
92		*/
93		public static function overrideDefaultInstance( WatchedItemStore $store ) {
94		if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
95		throw new MWException(
96		'Cannot override ' . __CLASS__ . 'default instance in operation.'
97		);
98		}
99		self::$instance = $store;
100		}
101
102		/**
103		* @return self
104		*/
105		public static function getDefaultInstance() {
106		if ( !self::$instance ) {
107		self::$instance = new self(
108		wfGetLB(),
109		new HashBagOStuff( [ 'maxKeys' => 100 ] )
110		);
111		}
112		return self::$instance;
113		}
114
115		private function getCacheKey( User $user, LinkTarget $target ) {
116		return $this->cache->makeKey(
117		(string)$target->getNamespace(),
118		$target->getDBkey(),
119		(string)$user->getId()
120		);
121		}
122
123		private function cache( WatchedItem $item ) {
124		$this->cache->set(
125		$this->getCacheKey( $item->getUser(), $item->getLinkTarget() ),
126		$item
127		);
128		}
129
130		private function uncache( User $user, LinkTarget $target ) {
131		$this->cache->delete( $this->getCacheKey( $user, $target ) );
132		}
133
134		/**
135		* @param User $user
136		* @param LinkTarget $target
137		*
138		* @return WatchedItem\|null
139		*/
140		private function getCached( User $user, LinkTarget $target ) {
141		return $this->cache->get( $this->getCacheKey( $user, $target ) );
142		}
143
144		/**
145		* Return an array of conditions to select or update the appropriate database
146		* row.
147		*
148		* @param User $user
149		* @param LinkTarget $target
150		*
151		* @return array
152		*/
153		private function dbCond( User $user, LinkTarget $target ) {
154		return [
155		'wl_user' => $user->getId(),
156		'wl_namespace' => $target->getNamespace(),
157		'wl_title' => $target->getDBkey(),
158		];
159		}
160
161		/**
162		* Get an item (may be cached)
163		*
164		* @param User $user
165		* @param LinkTarget $target
166		*
167		* @return WatchedItem\|false
168		*/
169		public function getWatchedItem( User $user, LinkTarget $target ) {
170		$cached = $this->getCached( $user, $target );
171		if ( $cached ) {
172		return $cached;
173		}
174		return $this->loadWatchedItem( $user, $target );
175		}
176
177		/**
178		* Loads an item from the db
179		*
180		* @param User $user
181		* @param LinkTarget $target
182		*
183		* @return WatchedItem\|false
184		*/
185		public function loadWatchedItem( User $user, LinkTarget $target ) {
186		// Only loggedin user can have a watchlist
187		if ( $user->isAnon() ) {
188		return false;
189		}
190
191		$dbr = $this->loadBalancer->getConnection( DB_SLAVE, [ 'watchlist' ] );
192		$row = $dbr->selectRow(
193		'watchlist',
194		'wl_notificationtimestamp',
195		$this->dbCond( $user, $target ),
196		__METHOD__
197		);
198		$this->loadBalancer->reuseConnection( $dbr );
199
200		if ( !$row ) {
201		return false;
202		}
203
204		$item = new WatchedItem(
205		$user,
206		$target,
207		$row->wl_notificationtimestamp
208		);
209		$this->cache( $item );
210
211		return $item;
212		}
213
214		/**
215		* Must be called separately for Subject & Talk namespaces
216		*
217		* @param User $user
218		* @param LinkTarget $target
219		*
220		* @return bool
221		*/
222		public function isWatched( User $user, LinkTarget $target ) {
223		return (bool)$this->getWatchedItem( $user, $target );
224		}
225
226		/**
227		* Must be called separately for Subject & Talk namespaces
228		*
229		* @param User $user
230		* @param LinkTarget $target
231		*/
232		public function addWatch( User $user, LinkTarget $target ) {
233		$this->addWatchBatch( [ [ $user, $target ] ] );
234		}
235
236		/**
237		* @param array[] $userTargetCombinations array of arrays containing [0] => User [1] => LinkTarget
238		*
239		* @return bool success
240		*/
241		public function addWatchBatch( array $userTargetCombinations ) {
242		if ( $this->loadBalancer->getReadOnlyReason() !== false ) {
243		return false;
244		}
245
246		$rows = [];
247		foreach ( $userTargetCombinations as list( $user, $target ) ) {
248		/**
249		* @var User $user
250		* @var LinkTarget $target
251		*/
252
253		// Only loggedin user can have a watchlist
254		if ( $user->isAnon() ) {
255		continue;
256		}
257		$rows[] = [
258		'wl_user' => $user->getId(),
259		'wl_namespace' => $target->getNamespace(),
260		'wl_title' => $target->getDBkey(),
261		'wl_notificationtimestamp' => null,
262		];
263		$this->uncache( $user, $target );
264		}
265
266		if ( !$rows ) {
		0 ignored issues – show Bug Best Practice introduced 2016-03-09 18:21 UTC by Report Bug Copy Issue Report The expression `$rows` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
267		return false;
268		}
269
270		$dbw = $this->loadBalancer->getConnection( DB_MASTER, [ 'watchlist' ] );
271		foreach ( array_chunk( $rows, 100 ) as $toInsert ) {
272		// Use INSERT IGNORE to avoid overwriting the notification timestamp
273		// if there's already an entry for this page
274		$dbw->insert( 'watchlist', $toInsert, __METHOD__, 'IGNORE' );
275		}
276		$this->loadBalancer->reuseConnection( $dbw );
277
278		return true;
279		}
280
281		/**
282		* Removes the an entry for the User watching the LinkTarget
283		* Must be called separately for Subject & Talk namespaces
284		*
285		* @param User $user
286		* @param LinkTarget $target
287		*
288		* @return bool success
289		* @throws DBUnexpectedError
290		* @throws MWException
291		*/
292		public function removeWatch( User $user, LinkTarget $target ) {
293		// Only logged in user can have a watchlist
294		if ( $this->loadBalancer->getReadOnlyReason() !== false \|\| $user->isAnon() ) {
295		return false;
296		}
297
298		$this->uncache( $user, $target );
299
300		$dbw = $this->loadBalancer->getConnection( DB_MASTER, [ 'watchlist' ] );
301		$dbw->delete( 'watchlist',
302		[
303		'wl_user' => $user->getId(),
304		'wl_namespace' => $target->getNamespace(),
305		'wl_title' => $target->getDBkey(),
306		], __METHOD__
307		);
308		$success = (bool)$dbw->affectedRows();
309		$this->loadBalancer->reuseConnection( $dbw );
310
311		return $success;
312		}
313
314		/**
315		* @param User $editor The editor that triggered the update. Their notification
316		* timestamp will not be updated(they have already seen it)
317		* @param LinkTarget $target The target to update timestamps for
318		* @param string $timestamp Set the update timestamp to this value
319		*
320		* @return int[] Array of user IDs the timestamp has been updated for
321		*/
322		public function updateNotificationTimestamp( User $editor, LinkTarget $target, $timestamp ) {
323		$dbw = $this->loadBalancer->getConnection( DB_MASTER, [ 'watchlist' ] );
324		$res = $dbw->select( [ 'watchlist' ],
325		[ 'wl_user' ],
326		[
327		'wl_user != ' . intval( $editor->getId() ),
328		'wl_namespace' => $target->getNamespace(),
329		'wl_title' => $target->getDBkey(),
330		'wl_notificationtimestamp IS NULL',
331		], __METHOD__
332		);
333
334		$watchers = [];
335		foreach ( $res as $row ) {
		0 ignored issues – show Bug introduced 2016-03-09 18:21 UTC by Report Bug Copy Issue Report The expression `$res` of type `boolean\|object<ResultWrapper>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
336		$watchers[] = intval( $row->wl_user );
337		}
338
339		if ( $watchers ) {
		0 ignored issues – show Bug Best Practice introduced 2016-03-09 18:21 UTC by Report Bug Copy Issue Report The expression `$watchers` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
340		// Update wl_notificationtimestamp for all watching users except the editor
341		$fname = __METHOD__;
342		$dbw->onTransactionIdle(
343		function () use ( $dbw, $timestamp, $watchers, $target, $fname ) {
344		$dbw->update( 'watchlist',
345		[ /* SET */
346		'wl_notificationtimestamp' => $dbw->timestamp( $timestamp )
347		], [ /* WHERE */
348		'wl_user' => $watchers,
349		'wl_namespace' => $target->getNamespace(),
350		'wl_title' => $target->getDBkey(),
351		], $fname
352		);
353		}
354		);
355		}
356
357		$this->loadBalancer->reuseConnection( $dbw );
358
359		return $watchers;
360		}
361
362		/**
363		* Reset the notification timestamp of this entry
364		*
365		* @param User $user
366		* @param Title $title
367		* @param string $force Whether to force the write query to be executed even if the
368		* page is not watched or the notification timestamp is already NULL.
369		* 'force' in order to force
370		* @param int $oldid The revision id being viewed. If not given or 0, latest revision is assumed.
371		*
372		* @return bool success
373		*/
374		public function resetNotificationTimestamp( User $user, Title $title, $force = '', $oldid = 0 ) {
375		// Only loggedin user can have a watchlist
376		if ( $this->loadBalancer->getReadOnlyReason() !== false \|\| $user->isAnon() ) {
377		return false;
378		}
379
380		$item = null;
381		if ( $force != 'force' ) {
382		$item = $this->loadWatchedItem( $user, $title );
383		if ( !$item \|\| $item->getNotificationTimestamp() === null ) {
384		return false;
385		}
386		}
387
388		// If the page is watched by the user (or may be watched), update the timestamp
389		$job = new ActivityUpdateJob(
390		$title,
391		[
392		'type' => 'updateWatchlistNotification',
393		'userid' => $user->getId(),
394		'notifTime' => $this->getNotificationTimestamp( $user, $title, $item, $force, $oldid ),
395		'curTime' => time()
396		]
397		);
398
399		// Try to run this post-send
400		// Calls DeferredUpdates::addCallableUpdate in normal operation
401		call_user_func(
402		$this->deferredUpdatesAddCallableUpdateCallback,
403		function() use ( $job ) {
404		$job->run();
405		}
406		);
407
408		$this->uncache( $user, $title );
409
410		return true;
411		}
412
413		private function getNotificationTimestamp( User $user, Title $title, $item, $force, $oldid ) {
414		if ( !$oldid ) {
415		// No oldid given, assuming latest revision; clear the timestamp.
416		return null;
417		}
418
419		if ( !$title->getNextRevisionID( $oldid ) ) {
		0 ignored issues – show Bug Best Practice introduced 2016-03-09 18:21 UTC by Report Bug Copy Issue Report The expression `$title->getNextRevisionID($oldid)` of type `false\|integer` is loosely compared to `false`; this is ambiguous if the integer can be zero. You might want to explicitly use `=== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
420		// Oldid given and is the latest revision for this title; clear the timestamp.
421		return null;
422		}
423
424		if ( $item === null ) {
425		$item = $this->loadWatchedItem( $user, $title );
426		}
427
428		if ( !$item ) {
429		// This can only happen if $force is enabled.
430		return null;
431		}
432
433		// Oldid given and isn't the latest; update the timestamp.
434		// This will result in no further notification emails being sent!
435		// Calls Revision::getTimestampFromId in normal operation
436		$notificationTimestamp = call_user_func(
437		$this->revisionGetTimestampFromIdCallback,
438		$title,
439		$oldid
440		);
441
442		// We need to go one second to the future because of various strict comparisons
443		// throughout the codebase
444		$ts = new MWTimestamp( $notificationTimestamp );
445		$ts->timestamp->add( new DateInterval( 'PT1S' ) );
446		$notificationTimestamp = $ts->getTimestamp( TS_MW );
447
448		if ( $notificationTimestamp < $item->getNotificationTimestamp() ) {
449		if ( $force != 'force' ) {
450		return false;
451		} else {
452		// This is a little silly…
453		return $item->getNotificationTimestamp();
454		}
455		}
456
457		return $notificationTimestamp;
458		}
459
460		/**
461		* Check if the given title already is watched by the user, and if so
462		* add a watch for the new title.
463		*
464		* To be used for page renames and such.
465		*
466		* @param LinkTarget $oldTarget
467		* @param LinkTarget $newTarget
468		*/
469		public function duplicateAllAssociatedEntries( LinkTarget $oldTarget, LinkTarget $newTarget ) {
470		if ( !$oldTarget instanceof Title ) {
471		$oldTarget = Title::newFromLinkTarget( $oldTarget );
472		}
473		if ( !$newTarget instanceof Title ) {
474		$newTarget = Title::newFromLinkTarget( $newTarget );
475		}
476
477		$this->duplicateEntry( $oldTarget->getSubjectPage(), $newTarget->getSubjectPage() );
478		$this->duplicateEntry( $oldTarget->getTalkPage(), $newTarget->getTalkPage() );
479		}
480
481		/**
482		* Check if the given title already is watched by the user, and if so
483		* add a watch for the new title.
484		*
485		* To be used for page renames and such.
486		* This must be called separately for Subject and Talk pages
487		*
488		* @param LinkTarget $oldTarget
489		* @param LinkTarget $newTarget
490		*/
491		public function duplicateEntry( LinkTarget $oldTarget, LinkTarget $newTarget ) {
492		$dbw = $this->loadBalancer->getConnection( DB_MASTER, [ 'watchlist' ] );
493
494		$result = $dbw->select(
495		'watchlist',
496		[ 'wl_user', 'wl_notificationtimestamp' ],
497		[
498		'wl_namespace' => $oldTarget->getNamespace(),
499		'wl_title' => $oldTarget->getDBkey(),
500		],
501		__METHOD__,
502		[ 'FOR UPDATE' ]
503		);
504
505		$newNamespace = $newTarget->getNamespace();
506		$newDBkey = $newTarget->getDBkey();
507
508		# Construct array to replace into the watchlist
509		$values = [];
510		foreach ( $result as $row ) {
		0 ignored issues – show Bug introduced 2016-02-25 18:13 UTC by Report Bug Copy Issue Report The expression `$result` of type `boolean\|object<ResultWrapper>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
511		$values[] = [
512		'wl_user' => $row->wl_user,
513		'wl_namespace' => $newNamespace,
514		'wl_title' => $newDBkey,
515		'wl_notificationtimestamp' => $row->wl_notificationtimestamp,
516		];
517		}
518
519		if ( !empty( $values ) ) {
520		# Perform replace
521		# Note that multi-row replace is very efficient for MySQL but may be inefficient for
522		# some other DBMSes, mostly due to poor simulation by us
523		$dbw->replace(
524		'watchlist',
525		[ [ 'wl_user', 'wl_namespace', 'wl_title' ] ],
526		$values,
527		__METHOD__
528		);
529		}
530
531		$this->loadBalancer->reuseConnection( $dbw );
532		}
533
534		}
535

wikimedia / mediawiki