mediawiki-extensions-Echo/modules/controller/mw.echo.Controller.js

( function ( mw, $ ) {
	/*global moment:false */
	/**
	 * Controller for Echo notifications
	 *
	 * @param {mw.echo.api.EchoApi} echoApi Echo API
	 * @param {mw.echo.dm.ModelManager} manager Model manager
	 * @param {Object} [config] Configuration
	 */
	mw.echo.Controller = function MwEchoController( echoApi, manager, config ) {
		config = config || {};

		this.api = echoApi;
		this.manager = manager;
	};

	/* Initialization */
	OO.initClass( mw.echo.Controller );

	/**
	 * Update a filter value.
	 * The method accepts a filter name and as many arguments
	 * as needed.
	 *
	 * @param {string} filter Filter name
	 */
	mw.echo.Controller.prototype.setFilter = function ( filter ) {
		var filtersModel = this.manager.getFiltersModel(),
			values = Array.prototype.slice.call( arguments );

		values.shift();

		if ( filter === 'readState' ) {
			filtersModel.setReadState( values[ 0 ] );
		} else if ( filter === 'sourcePage' ) {
			filtersModel.setCurrentSourcePage( values[ 0 ], values[ 1 ] );
			this.manager.getLocalCounter().setSource( filtersModel.getSourcePagesModel().getCurrentSource() );
		}

		// Reset pagination
		this.manager.getPaginationModel().reset();
	};

	/**
	 * Fetch the next page by date
	 *
	 * @return {jQuery.Promise} A promise that resolves with an object where the keys are
	 *  days and the items are item IDs.
	 */
	mw.echo.Controller.prototype.fetchNextPageByDate = function () {
		this.manager.getPaginationModel().forwards();
		return this.fetchLocalNotificationsByDate();
	};

	/**
	 * Fetch the previous page by date
	 *
	 * @return {jQuery.Promise} A promise that resolves with an object where the keys are
	 *  days and the items are item IDs.
	 */
	mw.echo.Controller.prototype.fetchPrevPageByDate = function () {
		this.manager.getPaginationModel().backwards();
		return this.fetchLocalNotificationsByDate();
	};

	/**
	 * Fetch the first page by date
	 *
	 * @return {jQuery.Promise} A promise that resolves with an object where the keys are
	 *  days and the items are item IDs.
	 */
	mw.echo.Controller.prototype.fetchFirstPageByDate = function () {
		this.manager.getPaginationModel().setCurrPageIndex( 0 );
		return this.fetchLocalNotificationsByDate();
	};

	/**
	 * Fetch unread pages in all wikis and create foreign API sources
	 * as needed.
	 *
	 * @return {jQuery.Promise} A promise that resolves when the page filter
	 *  model is updated with the unread notification count per page per wiki
	 */
	mw.echo.Controller.prototype.fetchUnreadPagesByWiki = function () {
		var controller = this,
			filterModel = this.manager.getFiltersModel(),
			sourcePageModel = filterModel.getSourcePagesModel();

		return this.api.fetchUnreadNotificationPages()
			.then( function ( data ) {
				var source,
					result = {},
					foreignSources = {};

				for ( source in data ) {
					if ( source !== mw.config.get( 'wgDBname' ) ) {
						// Collect sources for API
						foreignSources[ source ] = data[ source ].source;
					}
					result[ source === mw.config.get( 'wgDBname' ) ? 'local' : source ] = data[ source ];
				}

				// Register the foreign sources in the API
				controller.api.registerForeignSources( foreignSources, false );

				// Register pages
				sourcePageModel.setAllSources( result );
			} );
	};

	/**
	 * Fetch notifications from the local API and sort them by date.
	 * This method ignores cross-wiki notifications and bundles.
	 *
	 * @param {number} [page] Page number. If not given, it defaults to the current
	 *  page.
	 * @return {jQuery.Promise} A promise that resolves with an object where the keys are
	 *  days and the items are item IDs.
	 */
	mw.echo.Controller.prototype.fetchLocalNotificationsByDate = function ( page ) {
		var controller = this,
			pagination = this.manager.getPaginationModel(),
			filters = this.manager.getFiltersModel(),
			currentSource = filters.getSourcePagesModel().getCurrentSource(),
			continueValue = pagination.getPageContinue( page || pagination.getCurrPageIndex() );

		pagination.setItemsPerPage( this.api.getLimit() );

		return this.api.fetchFilteredNotifications(
			this.manager.getTypeString(),
			currentSource,
			{
				continue: continueValue,
				readState: filters.getReadState(),
				titles: filters.getSourcePagesModel().getGroupedPagesForCurrentTitle()
			}
		)
			.then( function ( data ) {
				var i, notifData, newNotifData, localizedDate, date, itemModel, symbolicName,
					maxSeenTime,
					dateItemIds = {},
					dateItems = {},
					models = {};

				data = data || { list: [] };

				// Go over the data
				for ( i = 0; i < data.list.length; i++ ) {
					notifData = data.list[ i ];

					// Set source's seenTime
					// TODO: This query brings up mixed alert and message notifications.
					// Regularly, each of those will have a different seenTime that is
					// calculated for each badge, but for this page, both are fetched.
					// For the moment, we are picking the max seenTime from
					// either alert or notice and updating both, since the page gives
					// us a mixed view which will update both seenTime to be the same
					// anyways.
					maxSeenTime = data.seenTime.alert < data.seenTime.notice ?
						data.seenTime.notice : data.seenTime.alert;
					controller.manager.getSeenTimeModel().setSeenTimeForSource(
						currentSource,
						maxSeenTime
					);

					// Collect common data
					newNotifData = controller.createNotificationData( notifData );
					if ( notifData.type !== 'foreign' ) {
						localizedDate = moment.utc( newNotifData.timestamp ).local().format( 'YYYYMMDD' );

						newNotifData.modelName = 'local_' + localizedDate;
						newNotifData.source = currentSource;

						// Single notifications
						itemModel = new mw.echo.dm.NotificationItem(
							notifData.id,
							newNotifData
						);

						dateItems[ localizedDate ] = dateItems[ localizedDate ] || [];
						dateItems[ localizedDate ].push( itemModel );

						dateItemIds[ localizedDate ] = dateItemIds[ localizedDate ] || [];
						dateItemIds[ localizedDate ].push( notifData.id );
					}
				}

				// Fill in the models
				for ( date in dateItems ) {
					symbolicName = 'local_' + date;

					// Set up model
					models[ symbolicName ] = new mw.echo.dm.NotificationsList( {
						type: controller.manager.getTypes(),
						name: symbolicName,
						source: currentSource,
						title: date,
						timestamp: date,
						sortingCallback: function ( a, b ) {
							// Reverse sorting. In the special page we want the
							// items sorted only by timestamp, regardless of
							// read/unread state
							if ( b.getTimestamp() < a.getTimestamp() ) {
								return -1;
							} else if ( b.getTimestamp() > a.getTimestamp() ) {
								return 1;
							}

							// Fallback on IDs
							return b.getId() - a.getId();
						}
					} );
					models[ symbolicName ].setItems( dateItems[ date ] );
				}

				// Register local sources
				controller.api.registerLocalSources( Object.keys( models ) );

				// Update the manager
				controller.manager.setNotificationModels( models );

				// Update the pagination
				pagination.setNextPageContinue( data.continue );

				// Update the local counter
				controller.manager.getLocalCounter().update();

				return dateItemIds;
			} );
	};
	/**
	 * Fetch notifications from the local API and update the notifications list.
	 *
	 * @param {boolean} [isForced] Force a renewed fetching promise. If set to false, the
	 *  model will request the stored/cached fetching promise from the API. A 'true' value
	 *  will force the API to re-request that information from the server and update the
	 *  notifications.
	 * @return {jQuery.Promise} A promise that resolves with an array of notification IDs
	 */
	mw.echo.Controller.prototype.fetchLocalNotifications = function ( isForced ) {
		var controller = this,
			// Create a new local list model
			localListModel = new mw.echo.dm.NotificationsList( {
				type: this.manager.getTypes()
			} ),
			localItems = [],
			idArray = [];

		this.manager.counter.update();

		// Fetch the notifications from the database
		// Initially, we're going to have to split the operation
		// between local notifications and x-wiki notifications
		// until the backend gives us the x-wiki notifications as
		// part of the original response.
		return this.api.fetchNotifications( this.manager.getTypeString(), 'local', !!isForced, { unreadFirst: true, bundle: true } /* filters */ )
			.then(
				// Success
				function ( data ) {
					var i, notifData, content, newNotifData,
						foreignListModel, source, itemModel,
						allModels = { local: localListModel },
						createBundledNotification = function ( modelName, rawBundledNotifData ) {
							var bundleNotifData = controller.createNotificationData( rawBundledNotifData );
							bundleNotifData.bundled = true;
							bundleNotifData.modelName = modelName;
							return new mw.echo.dm.NotificationItem(
								rawBundledNotifData.id,
								bundleNotifData
							);
						};

					data = data || { list: [] };

					// Go over the data
					for ( i = 0; i < data.list.length; i++ ) {
						notifData = data.list[ i ];
						content = notifData[ '*' ] || {};

						// Set source's seenTime
						controller.manager.getSeenTimeModel().setSeenTimeForSource(
							'local',
							controller.getTypes().length > 1 ?
								(
									data.seenTime.alert < data.seenTime.notice ?
										data.seenTime.notice : data.seenTime.alert
								) :
								data.seenTime[ controller.getTypeString() ]
						);

						// Collect common data
						newNotifData = controller.createNotificationData( notifData );
						if ( notifData.type === 'foreign' ) {
							// x-wiki notification multi-group
							// We need to request a new list model
							newNotifData.name = 'xwiki';
							allModels.xwiki = foreignListModel = new mw.echo.dm.CrossWikiNotificationItem( notifData.id, newNotifData );
							foreignListModel.setForeign( true );

							// Register foreign sources
							controller.api.registerForeignSources( notifData.sources, true );
							// Add the lists according to the sources
							for ( source in notifData.sources ) {
								foreignListModel.getList().addGroup(
									source,
									notifData.sources[ source ]
								);
							}
						} else if ( newNotifData.bundledNotifications ) {
							// local bundle
							newNotifData.modelName = 'bundle_' + notifData.id;
							itemModel = new mw.echo.dm.BundleNotificationItem(
								notifData.id,
								newNotifData.bundledNotifications.map( createBundledNotification.bind( null, newNotifData.modelName ) ),
								newNotifData
							);
							allModels[ newNotifData.modelName ] = itemModel;
						} else {
							// Local single notifications
							itemModel = new mw.echo.dm.NotificationItem(
								notifData.id,
								newNotifData
							);

							idArray.push( notifData.id );
							localItems.push( itemModel );
						}

					}

					// Refresh local items
					localListModel.addItems( localItems );

					// Update the controller
					controller.manager.setNotificationModels( allModels );

					return idArray;
				},
				// Failure
				function ( errCode, errObj ) {
					if ( !controller.manager.getNotificationModel( 'local' ) ) {
						// Update the controller
						controller.manager.setNotificationModels( { local: localListModel } );
					}
					return {
						errCode: errCode,
						errInfo: OO.getProp( errObj, 'error', 'info' )
					};
				}
			);
	};

	/**
	 * Create notification data config object for notification items from the
	 * given API data.
	 *
	 * @param {Object} apiData API data
	 * @return {Object} Notification config data object
	 */
	mw.echo.Controller.prototype.createNotificationData = function ( apiData ) {
		var utcTimestamp, utcIsoMoment,
			source = this.manager.getFiltersModel().getSourcePagesModel().getCurrentSource(),
			content = apiData[ '*' ] || {};

		if ( apiData.timestamp.utciso8601 ) {
			utcTimestamp = apiData.timestamp.utciso8601;
		} else {
			// Temporary until c05133283af0486e08c9a97a468bc075e238f2d2 rolls out to the
			// whole WMF cluster
			utcIsoMoment = moment.utc( apiData.timestamp.utcunix * 1000 );
			utcTimestamp = utcIsoMoment.format( 'YYYY-MM-DD[T]HH:mm:ss[Z]' );
		}

		return {
			type: apiData.section,
			foreign: false,
			source: 'local',
			count: apiData.count,
			read: !!apiData.read,
			seen: (
				!!apiData.read ||
				utcTimestamp <= this.manager.getSeenTime( source )
			),
			timestamp: utcTimestamp,
			category: apiData.category,
			content: {
				header: content.header,
				compactHeader: content.compactHeader,
				body: content.body
			},
			iconURL: content.iconUrl,
			iconType: content.icon,
			primaryUrl: OO.getProp( content.links, 'primary', 'url' ),
			secondaryUrls: OO.getProp( content.links, 'secondary' ) || [],
			bundledIds: apiData.bundledIds,
			bundledNotifications: apiData.bundledNotifications
		};
	};

	/**
	 * Mark all items within a given list model as read.
	 *
	 * NOTE: This method is strictly for list models, and will not work for
	 * group list models. To mark items as read in the xwiki model, whether
	 * it is pre-populated or not, please see #markEntireCrossWikiItemAsRead
	 *
	 * @param {string} [modelName] Symbolic name for the model
	 * @param {boolean} [isRead=true]
	 * @return {jQuery.Promise} Promise that is resolved when all items
	 *  were marked as read.
	 */
	mw.echo.Controller.prototype.markEntireListModelRead = function ( modelName, isRead ) {
		var i, items, item,
			itemIds = [],
			model = this.manager.getNotificationModel( modelName || 'local' );

		if ( !model ) {
			// Model doesn't exist
			return $.Deferred().reject();
		}

		// Default to true
		isRead = isRead === undefined ? true : isRead;

		items = model.getItems();
		for ( i = 0; i < items.length; i++ ) {
			item = items[ i ];
			if ( item.isRead() !== isRead ) {
				itemIds.push( item.getId() );
			}
		}

		return this.markItemsRead( itemIds, model.getName(), isRead );
	};

	/**
	 * Mark all notifications of a certain source as read, even those that
	 * are not currently displayed.
	 *
	 * @param {string} [source] Notification source. If not given, the currently
	 *  selected source is used.
	 * @return {jQuery.Promise} A promise that is resolved after
	 *  all notifications for the given source were marked as read
	 */
	mw.echo.Controller.prototype.markAllRead = function ( source ) {
		var model,
			controller = this,
			itemIds = [],
			readState = this.manager.getFiltersModel().getReadState(),
			localCounter = this.manager.getLocalCounter();

		source = source || this.manager.getFiltersModel().getSourcePagesModel().getCurrentSource();

		this.manager.getNotificationsBySource( source ).forEach( function ( notification ) {
			if ( !notification.isRead() ) {
				itemIds = itemIds.concat( notification.getAllIds() );
				notification.toggleRead( true );

				if ( readState === 'unread' ) {
					// Remove the items if we are in 'unread' filter state
					model = controller.manager.getNotificationModel( notification.getModelName() );
					model.discardItems( notification );
				}
			}
		} );

		// Update pagination count
		this.manager.updateCurrentPageItemCount();

		localCounter.estimateChange( -itemIds.length );
		return this.api.markAllRead(
				source,
				this.getTypes()
			)
			.then( this.refreshUnreadCount.bind( this ) )
			.then( localCounter.update.bind( localCounter, true ) );
	};

	/**
	 * Mark all local notifications as read
	 *
	 * @return {jQuery.Promise} Promise that is resolved when all
	 *  local notifications have been marked as read.
	 */
	mw.echo.Controller.prototype.markLocalNotificationsRead = function () {
		var modelName, model,
			itemIds = [],
			readState = this.manager.getFiltersModel().getReadState(),
			modelItems = {};

		this.manager.getLocalNotifications().forEach( function ( notification ) {
			if ( !notification.isRead() ) {
				itemIds = itemIds.concat( notification.getAllIds() );
				notification.toggleRead( true );

				modelName = notification.getModelName();
				modelItems[ modelName ] = modelItems[ modelName ] || [];
				modelItems[ modelName ].push( notification );
			}
		} );

		// Remove the items if we are in 'unread' filter state
		if ( readState === 'unread' ) {
			for ( modelName in modelItems ) {
				model = this.manager.getNotificationModel( modelName );
				model.discardItems( modelItems[ modelName ] );
			}
		}

		// Update pagination count
		this.manager.updateCurrentPageItemCount();

		this.manager.getUnreadCounter().estimateChange( -itemIds.length );
		this.manager.getLocalCounter().estimateChange( -itemIds.length );
		return this.api.markItemsRead( itemIds, 'local', true ).then( this.refreshUnreadCount.bind( this ) );
	};

	/**
	 * Fetch notifications from the cross-wiki sources.
	 *
	 * @return {jQuery.Promise} Promise that is resolved when all items
	 *  from the cross-wiki sources are populated into the cross-wiki
	 *  model.
	 */
	mw.echo.Controller.prototype.fetchCrossWikiNotifications = function () {
		var controller = this,
			xwikiModel = this.manager.getNotificationModel( 'xwiki' );

		if ( !xwikiModel ) {
			// There is no xwiki notifications model, so we can't
			// fetch into it
			return $.Deferred().reject().promise();
		}

		return this.api.fetchNotificationGroups( xwikiModel.getSourceNames(), this.manager.getTypeString(), true )
			.then(
				function ( groupList ) {
					var i, notifData, listModel, group, groupItems,
						items = [];

					for ( group in groupList ) {
						listModel = xwikiModel.getItemBySource( group );
						groupItems = groupList[ group ];

						items = [];
						for ( i = 0; i < groupItems.length; i++ ) {
							notifData = controller.createNotificationData( groupItems[ i ] );
							items.push(
								new mw.echo.dm.NotificationItem( groupItems[ i ].id, $.extend( notifData, {
									modelName: 'xwiki',
									source: group,
									bundled: true,
									foreign: true
								} ) )
							);
						}
						// Add items
						listModel.setItems( items );
					}
				},
				function ( errCode, errObj ) {
					return {
						errCode: errCode,
						errInfo: errCode === 'http' ?
							mw.msg( 'echo-api-failure-cross-wiki' ) :
							OO.getProp( errObj, 'error', 'info' )
					};
				}
			);
	};

	/**
	 * Mark local items as read in the API.
	 *
	 * @param {string[]|string} itemIds An array of item IDs, or a single item ID, to mark as read
	 * @param {string} modelName The name of the model that these items belong to
	 * @param {boolean} [isRead=true] The read state of the item; true for marking the
	 *  item as read, false for marking the item as unread
	 * @return {jQuery.Promise} A promise that is resolved when the operation
	 *  is complete, with the number of unread notifications still remaining
	 *  for the set type of this controller, in the given source.
	 */
	mw.echo.Controller.prototype.markItemsRead = function ( itemIds, modelName, isRead ) {
		var items,
			model = this.manager.getNotificationModel( modelName ),
			readState = this.manager.getFiltersModel().getReadState(),
			allIds = [];

		itemIds = Array.isArray( itemIds ) ? itemIds : [ itemIds ];

		// Default to true
		isRead = isRead === undefined ? true : isRead;

		items = model.findByIds( itemIds );

		// If we are only looking at specific read state,
		// then we need to make sure the items are removed
		// from the visible list, because they no longer
		// correspond with the chosen state filter
		if ( readState === 'read' && !isRead ) {
			model.discardItems( items );
		} else if ( readState === 'unread' && isRead ) {
			model.discardItems( items );
			// TODO: We should also find a way to update the pagination
			// here properly. Do we pull more items from the next page
			// when items are cleared? Do we set some threshhold for
			// removed items where if it is reached, we update the list
			// to reflect the new pagination? etc.
		}

		items.forEach( function ( notification ) {
			allIds = allIds.concat( notification.getAllIds() );
			if ( readState === 'all' ) {
				notification.toggleRead( isRead );
			}
		} );

		// Update pagination count
		this.manager.updateCurrentPageItemCount();

		this.manager.getUnreadCounter().estimateChange( isRead ? -allIds.length : allIds.length );
		if ( modelName !== 'xwiki' ) {
			// For the local counter, we should only estimate the change if the items
			// are not cross-wiki
			this.manager.getLocalCounter().estimateChange( isRead ? -allIds.length : allIds.length );
		}

		return this.api.markItemsRead( allIds, model.getSource(), isRead ).then( this.refreshUnreadCount.bind( this ) );
	};

	/**
	 * Mark cross-wiki items as read in the API.
	 *
	 * @param {string[]|string} itemIds An array of item IDs, or a single item ID, to mark as read
	 * @param {string} source The name for the source list that these items belong to
	 * @return {jQuery.Promise} A promise that is resolved when the operation
	 *  is complete, with the number of unread notifications still remaining
	 *  for the set type of this controller, in the given source.
	 */
	mw.echo.Controller.prototype.markCrossWikiItemsRead = function ( itemIds, source ) {
		var sourceModel,
			notifs,
			allIds = [],
			xwikiModel = this.manager.getNotificationModel( 'xwiki' );

		if ( !xwikiModel ) {
			return $.Deferred().reject().promise();
		}
		this.manager.getUnreadCounter().estimateChange( -itemIds.length );

		itemIds = Array.isArray( itemIds ) ? itemIds : [ itemIds ];

		sourceModel = xwikiModel.getList().getGroupByName( source );
		notifs = sourceModel.findByIds( itemIds );
		sourceModel.discardItems( notifs );
		// Update pagination count
		this.manager.updateCurrentPageItemCount();

		notifs.forEach( function ( notif ) {
			allIds = allIds.concat( notif.getAllIds() );
		} );
		return this.api.markItemsRead( allIds, source, true )
			.then( this.refreshUnreadCount.bind( this ) );
	};

	/**
	 * Mark all cross-wiki notifications from all sources as read
	 *
	 * @return {jQuery.Promise} Promise that is resolved when all notifications
	 *  are marked as read
	 */
	mw.echo.Controller.prototype.markEntireCrossWikiItemAsRead = function () {
		var controller = this,
			xwikiModel = this.manager.getNotificationModel( 'xwiki' );

		if ( !xwikiModel ) {
			return $.Deferred().reject().promise();
		}

		this.manager.getUnreadCounter().estimateChange( -xwikiModel.getCount() );

		return this.api.fetchNotificationGroups( xwikiModel.getSourceNames(), this.manager.getTypeString() )
			.then( function ( groupList ) {
				var i, listModel, group, groupItems,
					promises = [],
					idArray = [],
					itemCounter = 0;

				for ( group in groupList ) {
					listModel = xwikiModel.getItemBySource( group );
					groupItems = groupList[ group ];

					idArray = [];
					for ( i = 0; i < groupItems.length; i++ ) {
						idArray = idArray.concat( groupItems[ i ].id ).concat( groupItems[ i ].bundledIds || [] );
					}
					itemCounter += idArray.length;

					// Mark items as read in the API
					promises.push(
						controller.api.markItemsRead( idArray, listModel.getName(), true )
					);
				}

				// Synchronously remove this model from the widget
				controller.removeCrossWikiItem();

				return mw.echo.api.NetworkHandler.static.waitForAllPromises( promises )
							.then( controller.refreshUnreadCount.bind( controller ) );
			} );
	};

	/**
	 * Remove the entire cross-wiki model.
	 */
	mw.echo.Controller.prototype.removeCrossWikiItem = function () {
		this.manager.removeNotificationModel( 'xwiki' );
	};

	/**
	 * Refresh the unread notifications counter
	 *
	 * @return {jQuery.Promise} A promise that is resolved when the counter
	 *  is updated with the actual unread count from the server.
	 */
	mw.echo.Controller.prototype.refreshUnreadCount = function () {
		return this.manager.getUnreadCounter().update();
	};

	/**
	 * Update seenTime for the given source
	 *
	 * @return {jQuery.Promise} A promise that is resolved when the
	 *  seenTime was updated for all the controller's types.
	 */
	mw.echo.Controller.prototype.updateSeenTime = function ( source ) {
		var controller = this;

		return this.api.updateSeenTime( this.getTypes(), source )
			.then( function ( time ) {
				controller.manager.getSeenTimeModel().setSeenTimeForSource( source, time );
			} );
	};

	/**
	 * Update local seen time
	 *
	 * @return {jQuery.Promise} A promise that is resolved when the
	 *  seenTime was updated for all given types.
	 */
	mw.echo.Controller.prototype.updateLocalSeenTime = function () {
		return this.updateSeenTime( 'local' );
	};

	/**
	 * Update seen time for all sources within a cross-wiki bundle.
	 *
	 * @return {jQuery.Promise} A promise that is resolved when the
	 *  seenTime was updated for all available cross-wiki sources.
	 */
	mw.echo.Controller.prototype.updateSeenTimeForCrossWiki = function () {
		var model = this.manager.getNotificationModel( 'xwiki' ),
			controller = this,
			promises = [];

		if ( !model ) {
			// There is no xwiki notifications model
			return $.Deferred().reject().promise();
		}

		model.getSourceNames().forEach( function ( source ) {
			promises.push( controller.updateSeenTime( source ) );
		} );

		return mw.echo.api.NetworkHandler.static.waitForAllPromises( promises );
	};
	/**
	 * Update seenTime for the currently selected source
	 *
	 * @return {jQuery.Promise} A promise that is resolved when the
	 *  seenTime was updated for all given types.
	 */
	mw.echo.Controller.prototype.updateSeenTimeForCurrentSource = function () {
		var currSource = this.manager.getFiltersModel().getSourcePagesModel().getCurrentSource();

		return this.updateSeenTime( currSource );
	};
	/**
	 * Get the types associated with the controller and model
	 *
	 * @return {string[]} Notification types
	 */
	mw.echo.Controller.prototype.getTypes = function () {
		return this.manager.getTypes();
	};

	/**
	 * Return a string representation of the notification type.
	 * It could be 'alert', 'message' or, if both are set, 'all'
	 *
	 * @return {string} String representation of notifications type
	 */
	mw.echo.Controller.prototype.getTypeString = function () {
		return this.manager.getTypeString();
	};
} )( mediaWiki, jQuery );