2012-04-27 15:14:24 +00:00
|
|
|
<?php
|
|
|
|
|
|
|
|
class EchoHooks {
|
2012-11-16 21:03:57 +00:00
|
|
|
const EMAIL_NEVER = -1; // Never send email notifications
|
|
|
|
const EMAIL_IMMEDIATELY = 0; // Send email notificaitons immediately as they come in
|
|
|
|
const EMAIL_DAILY_DIGEST = 1; // Send daily email digests
|
|
|
|
const EMAIL_WEEKLY_DIGEST = 7; // Send weekly email digests
|
2012-05-17 00:29:37 +00:00
|
|
|
|
2013-01-15 23:21:39 +00:00
|
|
|
/**
|
|
|
|
* Initialize Echo extension with necessary data, this function is invoked
|
|
|
|
* from $wgExtensionFunctions
|
|
|
|
*/
|
|
|
|
public static function initEchoExtension() {
|
2013-02-16 02:20:34 +00:00
|
|
|
global $wgEchoBackend, $wgEchoBackendName, $wgEchoNotifications,
|
2013-04-29 03:40:56 +00:00
|
|
|
$wgEchoNotificationCategories, $wgEchoNotificationIcons, $wgEchoConfig;
|
2013-02-16 02:20:34 +00:00
|
|
|
|
|
|
|
// allow extensions to define their own event
|
2013-04-29 03:40:56 +00:00
|
|
|
wfRunHooks( 'BeforeCreateEchoEvent', array( &$wgEchoNotifications, &$wgEchoNotificationCategories, &$wgEchoNotificationIcons ) );
|
2013-02-16 02:20:34 +00:00
|
|
|
|
2013-01-15 23:21:39 +00:00
|
|
|
$wgEchoBackend = MWEchoBackend::factory( $wgEchoBackendName );
|
2013-03-06 21:22:17 +00:00
|
|
|
|
|
|
|
// turn schema off if eventLogging is not enabled
|
|
|
|
if ( !function_exists( 'efLogServerSideEvent' ) ) {
|
|
|
|
foreach ( $wgEchoConfig['eventlogging'] as $schema => $property ) {
|
|
|
|
if ( $property['enabled'] ) {
|
|
|
|
$wgEchoConfig['eventlogging'][$schema]['enabled'] = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-01-15 23:21:39 +00:00
|
|
|
}
|
|
|
|
|
2013-03-01 00:26:59 +00:00
|
|
|
/**
|
|
|
|
* Handler for ResourceLoaderRegisterModules hook
|
|
|
|
*/
|
|
|
|
public static function onResourceLoaderRegisterModules( ResourceLoader &$resourceLoader ) {
|
|
|
|
global $wgResourceModules, $wgEchoConfig;
|
|
|
|
|
|
|
|
foreach ( $wgEchoConfig['eventlogging'] as $schema => $property ) {
|
2013-03-06 21:22:17 +00:00
|
|
|
if ( $property['enabled'] ) {
|
2013-03-01 00:26:59 +00:00
|
|
|
$wgResourceModules[ 'schema.' . $schema ] = array(
|
|
|
|
'class' => 'ResourceLoaderSchemaModule',
|
|
|
|
'schema' => $schema,
|
|
|
|
'revision' => $property['revision'],
|
|
|
|
);
|
|
|
|
$wgResourceModules['ext.echo.base']['dependencies'][] = 'schema.' . $schema;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Attempt to log the event
|
|
|
|
* @param $schema string
|
|
|
|
* @param $data array
|
|
|
|
*/
|
|
|
|
public static function logEvent( $schema, $data ) {
|
|
|
|
global $wgEchoConfig;
|
|
|
|
|
|
|
|
if ( !empty( $wgEchoConfig['eventlogging'][$schema]['enabled'] ) ) {
|
|
|
|
efLogServerSideEvent( $schema, $wgEchoConfig['eventlogging'][$schema]['revision'], $data );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-17 00:29:37 +00:00
|
|
|
/**
|
|
|
|
* @param $updater DatabaseUpdater object
|
2012-09-02 09:30:38 +00:00
|
|
|
* @return bool true in all cases
|
2012-05-17 00:29:37 +00:00
|
|
|
*/
|
|
|
|
public static function getSchemaUpdates( $updater ) {
|
2012-08-31 21:50:46 +00:00
|
|
|
$dir = __DIR__;
|
2012-04-27 15:14:24 +00:00
|
|
|
$baseSQLFile = "$dir/echo.sql";
|
2013-03-26 00:57:42 +00:00
|
|
|
$updater->addExtensionTable( 'echo_event', $baseSQLFile );
|
2012-11-27 01:53:35 +00:00
|
|
|
$updater->addExtensionTable( 'echo_email_batch', "$dir/db_patches/echo_email_batch.sql" );
|
2012-04-27 15:14:24 +00:00
|
|
|
|
2013-01-15 23:21:39 +00:00
|
|
|
$updater->modifyExtensionField( 'echo_event', 'event_agent', "$dir/db_patches/patch-event_agent-split.sql" );
|
|
|
|
$updater->modifyExtensionField( 'echo_event', 'event_variant', "$dir/db_patches/patch-event_variant_nullability.sql" );
|
|
|
|
$updater->modifyExtensionField( 'echo_event', 'event_extra', "$dir/db_patches/patch-event_extra-size.sql" );
|
|
|
|
$updater->modifyExtensionField( 'echo_event', 'event_agent_ip', "$dir/db_patches/patch-event_agent_ip-size.sql" );
|
|
|
|
|
|
|
|
$updater->addExtensionField( 'echo_notification', 'notification_bundle_base',
|
|
|
|
"$dir/db_patches/patch-notification-bundling-field.sql" );
|
|
|
|
$updater->addExtensionIndex( 'echo_event', 'event_type', "$dir/db_patches/patch-alter-type_page-index.sql" );
|
2013-03-26 00:57:42 +00:00
|
|
|
$updater->dropTable( 'echo_subscription' );
|
|
|
|
$updater->dropExtensionField( 'echo_event', 'event_timestamp', "$dir/db_patches/patch-drop-echo_event-event_timestamp.sql" );
|
2013-03-06 00:04:48 +00:00
|
|
|
$updater->addExtensionField( 'echo_email_batch', 'eeb_event_hash',
|
|
|
|
"$dir/db_patches/patch-email_batch-new-field.sql" );
|
2013-01-15 23:21:39 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handler for EchoGetBundleRule hook, which defines the bundle rule for each notification
|
|
|
|
* @param $event EchoEvent
|
|
|
|
* @param $bundleString string Determines how the notification should be bundled, for example,
|
|
|
|
* talk page notification is bundled based on namespace and title, the bundle string would be
|
|
|
|
* 'edit-user-talk-' + namespace + title, email digest/email bundling would use this hash as
|
|
|
|
* a key to identify bundle-able event. For web bundling, we bundle further based on user's
|
|
|
|
* visit to the overlay, we would generate a display hash based on the hash of $bundleString
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
public static function onEchoGetBundleRules( $event, &$bundleString ) {
|
|
|
|
switch ( $event->getType() ) {
|
|
|
|
case 'edit-user-talk':
|
|
|
|
$bundleString = 'edit-user-talk';
|
|
|
|
if ( $event->getTitle() ) {
|
|
|
|
$bundleString .= '-' . $event->getTitle()->getNamespace()
|
|
|
|
. '-' . $event->getTitle()->getDBkey();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'page-linked':
|
|
|
|
$bundleString = 'page-linked';
|
|
|
|
if ( $event->getTitle() ) {
|
|
|
|
$bundleString .= '-' . $event->getTitle()->getNamespace()
|
|
|
|
. '-' . $event->getTitle()->getDBkey();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2012-04-27 15:14:24 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-05-17 00:29:37 +00:00
|
|
|
/**
|
|
|
|
* Handler for EchoGetDefaultNotifiedUsers hook.
|
2012-09-02 09:30:38 +00:00
|
|
|
* @param $event EchoEvent to get implicitly subscribed users for
|
2012-05-17 00:29:37 +00:00
|
|
|
* @param &$users Array to append implicitly subscribed users to.
|
2012-09-02 09:30:38 +00:00
|
|
|
* @return bool true in all cases
|
2012-05-17 00:29:37 +00:00
|
|
|
*/
|
|
|
|
public static function getDefaultNotifiedUsers( $event, &$users ) {
|
2012-08-31 21:50:46 +00:00
|
|
|
switch ( $event->getType() ) {
|
2012-08-01 19:53:05 +00:00
|
|
|
// Everyone deserves to know when something happens
|
2012-10-28 16:47:41 +00:00
|
|
|
// on their user talk page
|
2012-04-27 15:14:24 +00:00
|
|
|
case 'edit-user-talk':
|
|
|
|
if ( !$event->getTitle() || !$event->getTitle()->getNamespace() == NS_USER_TALK ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
$username = $event->getTitle()->getText();
|
|
|
|
$user = User::newFromName( $username );
|
2012-08-01 19:53:05 +00:00
|
|
|
if ( $user && $user->getId() ) {
|
2012-04-27 15:14:24 +00:00
|
|
|
$users[$user->getId()] = $user;
|
|
|
|
}
|
2012-08-31 21:50:46 +00:00
|
|
|
break;
|
2012-07-27 22:16:19 +00:00
|
|
|
case 'add-comment':
|
|
|
|
case 'add-talkpage-topic':
|
2012-08-01 19:53:05 +00:00
|
|
|
// Handled by EchoDiscussionParser
|
2012-07-27 22:16:19 +00:00
|
|
|
$extraData = $event->getExtra();
|
|
|
|
|
|
|
|
if ( !isset( $extraData['revid'] ) || !$extraData['revid'] ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
$revision = Revision::newFromId( $extraData['revid'] );
|
2012-10-28 16:47:41 +00:00
|
|
|
if ( $revision ) {
|
|
|
|
$users += EchoDiscussionParser::getNotifiedUsersForComment( $revision );
|
|
|
|
}
|
2012-08-31 21:50:46 +00:00
|
|
|
break;
|
2012-08-31 23:35:16 +00:00
|
|
|
case 'welcome':
|
|
|
|
$users[$event->getAgent()->getId()] = $event->getAgent();
|
|
|
|
break;
|
2012-07-18 19:39:33 +00:00
|
|
|
case 'reverted':
|
|
|
|
$extra = $event->getExtra();
|
|
|
|
|
|
|
|
if ( !$extra || !isset( $extra['reverted-user-id'] ) ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
$victimID = $extra['reverted-user-id'];
|
|
|
|
$victim = User::newFromId( $victimID );
|
|
|
|
$users[$victim->getId()] = $victim;
|
|
|
|
break;
|
2013-01-15 23:21:39 +00:00
|
|
|
case 'page-linked':
|
2012-12-26 22:05:29 +00:00
|
|
|
$agent = $event->getAgent();
|
2013-01-15 23:21:39 +00:00
|
|
|
$title = $event->getTitle();
|
2012-12-26 22:05:29 +00:00
|
|
|
|
2013-01-15 23:21:39 +00:00
|
|
|
if ( !$title || $title->getArticleID() <= 0 || !$agent ) {
|
2012-12-26 22:05:29 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
$dbr = wfGetDB( DB_SLAVE );
|
|
|
|
|
2013-01-15 23:21:39 +00:00
|
|
|
$res = $dbr->selectRow(
|
|
|
|
array( 'revision' ),
|
|
|
|
array( 'rev_user' ),
|
|
|
|
array( 'rev_page' => $title->getArticleID() ),
|
|
|
|
__METHOD__,
|
|
|
|
array( 'LIMIT' => 1, 'ORDER BY' => 'rev_timestamp, rev_id' )
|
|
|
|
);
|
|
|
|
// No notification if agents link their own articles
|
|
|
|
if ( $res && $res->rev_user && $agent->getID() != $res->rev_user ) {
|
|
|
|
// Map each linked page to a corresponding author
|
|
|
|
$user = User::newFromId( $res->rev_user );
|
|
|
|
if ( $user ) {
|
|
|
|
$users[$user->getID()] = $user;
|
2012-12-26 22:05:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2012-10-28 16:47:41 +00:00
|
|
|
case 'mention':
|
|
|
|
$extraData = $event->getExtra();
|
2013-03-13 19:30:20 +00:00
|
|
|
foreach ( $extraData['mentioned-users'] as $userId ) {
|
|
|
|
//backward compatibility
|
|
|
|
if ( $userId instanceof User ) {
|
|
|
|
$users[$userId->getID()] = $userId;
|
|
|
|
} else {
|
|
|
|
$users[$userId] = User::newFromId( $userId );
|
|
|
|
}
|
|
|
|
}
|
2012-10-28 16:47:41 +00:00
|
|
|
break;
|
2013-03-13 00:49:19 +00:00
|
|
|
case 'user-rights':
|
|
|
|
$extraData = $event->getExtra();
|
|
|
|
$users[$extraData['user']] = User::newFromId( $extraData['user'] );
|
|
|
|
break;
|
2012-04-27 15:14:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-02-28 23:52:12 +00:00
|
|
|
/**
|
2013-01-15 23:21:39 +00:00
|
|
|
* Handler for EchoGetNotificationTypes hook, Adjust the notify types (e.g. web, email) which
|
|
|
|
* are applicable to this event and user based on various user options. In other words, allow
|
|
|
|
* certain non-echo user options to override the echo notification options.
|
|
|
|
* @param $user User
|
2013-02-28 23:52:12 +00:00
|
|
|
* @param $event EchoEvent
|
|
|
|
* @param $notifyTypes
|
|
|
|
* @return bool
|
|
|
|
*/
|
2013-01-15 23:21:39 +00:00
|
|
|
public static function getNotificationTypes( $user, $event, &$notifyTypes ) {
|
2012-06-08 05:27:59 +00:00
|
|
|
$type = $event->getType();
|
|
|
|
|
|
|
|
// Figure out when to disallow email notifications
|
|
|
|
if ( $type == 'edit' ) {
|
2012-08-31 21:50:46 +00:00
|
|
|
if ( !$user->getOption( 'enotifwatchlistpages' ) ) {
|
2012-08-30 16:04:39 +00:00
|
|
|
$notifyTypes = array_diff( $notifyTypes, array( 'email' ) );
|
2012-06-08 05:27:59 +00:00
|
|
|
}
|
|
|
|
} elseif ( $type == 'edit-user-talk' ) {
|
2012-08-31 21:50:46 +00:00
|
|
|
if ( !$user->getOption( 'enotifusertalkpages' ) ) {
|
2012-08-30 16:04:39 +00:00
|
|
|
$notifyTypes = array_diff( $notifyTypes, array( 'email' ) );
|
2012-06-08 05:27:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-31 21:50:46 +00:00
|
|
|
if ( !$user->getOption( 'enotifminoredits' ) ) {
|
2012-06-08 05:27:59 +00:00
|
|
|
$extra = $event->getExtra();
|
2012-08-30 16:04:39 +00:00
|
|
|
if ( !empty( $extra['revid'] ) ) {
|
|
|
|
$rev = Revision::newFromID( $extra['revid'] );
|
2012-06-08 05:27:59 +00:00
|
|
|
|
|
|
|
if ( $rev->isMinor() ) {
|
2012-08-30 16:04:39 +00:00
|
|
|
$notifyTypes = array_diff( $notifyTypes, array( 'email' ) );
|
2012-06-08 05:27:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-05-17 00:29:37 +00:00
|
|
|
/**
|
|
|
|
* Handler for GetPreferences hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/GetPreferences
|
|
|
|
* @param $user User to get preferences for
|
|
|
|
* @param &$preferences Preferences array
|
2012-09-02 09:30:38 +00:00
|
|
|
* @return bool true in all cases
|
2012-05-17 00:29:37 +00:00
|
|
|
*/
|
2012-04-27 15:14:24 +00:00
|
|
|
public static function getPreferences( $user, &$preferences ) {
|
2013-02-16 02:20:34 +00:00
|
|
|
global $wgEchoDefaultNotificationTypes, $wgAuth, $wgEchoEnableEmailBatch,
|
2013-04-28 21:55:05 +00:00
|
|
|
$wgEchoNotifiers, $wgEchoNotificationCategories, $wgEchoNotifications;
|
2012-11-16 21:03:57 +00:00
|
|
|
|
|
|
|
// Show email frequency options
|
|
|
|
$never = wfMessage( 'echo-pref-email-frequency-never' )->plain();
|
|
|
|
$immediately = wfMessage( 'echo-pref-email-frequency-immediately' )->plain();
|
2012-12-14 20:48:41 +00:00
|
|
|
$freqOptions = array(
|
|
|
|
$never => self::EMAIL_NEVER,
|
|
|
|
$immediately => self::EMAIL_IMMEDIATELY,
|
|
|
|
);
|
|
|
|
// Only show digest options if email batch is enabled
|
|
|
|
if ( $wgEchoEnableEmailBatch ) {
|
|
|
|
$daily = wfMessage( 'echo-pref-email-frequency-daily' )->plain();
|
|
|
|
$weekly = wfMessage( 'echo-pref-email-frequency-weekly' )->plain();
|
|
|
|
$freqOptions += array(
|
|
|
|
$daily => self::EMAIL_DAILY_DIGEST,
|
|
|
|
$weekly => self::EMAIL_WEEKLY_DIGEST
|
|
|
|
);
|
|
|
|
}
|
2012-11-16 21:03:57 +00:00
|
|
|
$preferences['echo-email-frequency'] = array(
|
|
|
|
'type' => 'select',
|
2013-04-18 00:44:20 +00:00
|
|
|
'label-message' => 'echo-pref-send-me',
|
|
|
|
'section' => 'echo/emailsettings',
|
2012-12-14 20:48:41 +00:00
|
|
|
'options' => $freqOptions
|
2012-11-16 21:03:57 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
// Display information about the user's currently set email address
|
|
|
|
$prefsTitle = SpecialPage::getTitleFor( 'Preferences', false, 'mw-prefsection-echo' );
|
|
|
|
$link = Linker::link(
|
|
|
|
SpecialPage::getTitleFor( 'ChangeEmail' ),
|
|
|
|
wfMessage( $user->getEmail() ? 'prefs-changeemail' : 'prefs-setemail' )->escaped(),
|
|
|
|
array(),
|
|
|
|
array( 'returnto' => $prefsTitle->getFullText() )
|
|
|
|
);
|
|
|
|
$emailAddress = $user->getEmail() ? htmlspecialchars( $user->getEmail() ) : '';
|
|
|
|
if ( $wgAuth->allowPropChange( 'emailaddress' ) ) {
|
|
|
|
if ( $emailAddress === '' ) {
|
|
|
|
$emailAddress .= $link;
|
|
|
|
} else {
|
|
|
|
$emailAddress .= wfMessage( 'word-separator' )->escaped()
|
|
|
|
. wfMessage( 'parentheses' )->rawParams( $link )->escaped();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$preferences['echo-emailaddress'] = array(
|
|
|
|
'type' => 'info',
|
|
|
|
'raw' => true,
|
2013-04-18 00:44:20 +00:00
|
|
|
'default' => $emailAddress,
|
|
|
|
'label-message' => 'echo-pref-send-to',
|
|
|
|
'section' => 'echo/emailsettings'
|
2012-11-16 21:03:57 +00:00
|
|
|
);
|
|
|
|
|
2013-02-16 02:20:34 +00:00
|
|
|
// Sort notification categories by priority
|
|
|
|
$categoriesAndPriorities = array();
|
|
|
|
foreach ( $wgEchoNotificationCategories as $category => $categoryData ) {
|
|
|
|
// See if the category is not dismissable at all. Must do strict
|
|
|
|
// comparison to true since no-dismiss can also be an array
|
|
|
|
if ( isset( $categoryData['no-dismiss'] ) && in_array( 'all' , $categoryData['no-dismiss'] ) ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// See if user is eligible to recieve this notification (per user group restrictions)
|
|
|
|
if ( EchoNotificationController::getCategoryEligibility( $user, $category ) ) {
|
|
|
|
$categoriesAndPriorities[$category] = EchoNotificationController::getCategoryPriority( $category );
|
2013-01-14 23:52:46 +00:00
|
|
|
}
|
|
|
|
}
|
2013-02-16 02:20:34 +00:00
|
|
|
asort( $categoriesAndPriorities );
|
|
|
|
$validSortedCategories = array_keys( $categoriesAndPriorities );
|
2013-01-14 23:52:46 +00:00
|
|
|
|
|
|
|
// Show subscription options
|
2013-02-16 02:20:34 +00:00
|
|
|
|
|
|
|
// Build the columns (output formats)
|
|
|
|
$columns = array();
|
|
|
|
foreach ( $wgEchoNotifiers as $notifierType => $notifierData ) {
|
2013-04-16 22:40:45 +00:00
|
|
|
$formatMessage = wfMessage( 'echo-pref-' . $notifierType )->escaped();
|
2013-02-16 02:20:34 +00:00
|
|
|
$columns[$formatMessage] = $notifierType;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build the rows (notification categories)
|
|
|
|
$rows = array();
|
|
|
|
foreach ( $validSortedCategories as $category ) {
|
2013-04-16 22:40:45 +00:00
|
|
|
$categoryMessage = wfMessage( 'echo-category-title-' . $category )->numParams( 1 )->escaped();
|
2013-02-16 02:20:34 +00:00
|
|
|
$rows[$categoryMessage] = $category;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Figure out the individual exceptions in the matrix and make them disabled
|
|
|
|
$removeOptions = array();
|
|
|
|
foreach ( $wgEchoNotifiers as $notifierType => $notifierData ) {
|
|
|
|
foreach ( $validSortedCategories as $category ) {
|
|
|
|
// See if this output format is non-dismissable
|
|
|
|
if ( isset( $wgEchoNotificationCategories[$category]['no-dismiss'] )
|
|
|
|
&& in_array( $notifierType, $wgEchoNotificationCategories[$category]['no-dismiss'] ) )
|
2013-01-14 23:52:46 +00:00
|
|
|
{
|
2013-02-16 02:20:34 +00:00
|
|
|
$removeOptions[] = "$notifierType-$category";
|
2013-01-14 23:52:46 +00:00
|
|
|
}
|
2013-02-16 02:20:34 +00:00
|
|
|
|
|
|
|
// Make sure this output format is possible for this notification category
|
|
|
|
if ( isset( $wgEchoDefaultNotificationTypes[$category] ) ) {
|
|
|
|
if ( !$wgEchoDefaultNotificationTypes[$category][$notifierType] ) {
|
|
|
|
$removeOptions[] = "$notifierType-$category";
|
2013-01-14 23:52:46 +00:00
|
|
|
}
|
2013-02-16 02:20:34 +00:00
|
|
|
} elseif ( !$wgEchoDefaultNotificationTypes['all'][$notifierType] ) {
|
|
|
|
$removeOptions[] = "$notifierType-$category";
|
2013-01-14 23:52:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-16 02:20:34 +00:00
|
|
|
$preferences['echo-subscriptions'] = array(
|
|
|
|
'class' => 'HTMLCheckMatrix',
|
|
|
|
'section' => 'echo/echosubscriptions',
|
|
|
|
'rows' => $rows,
|
|
|
|
'columns' => $columns,
|
|
|
|
'remove-options' => $removeOptions,
|
2012-04-27 15:14:24 +00:00
|
|
|
);
|
2013-03-20 01:10:23 +00:00
|
|
|
|
2013-04-28 21:55:05 +00:00
|
|
|
// If we're using Echo to handle user talk page post notifications,
|
|
|
|
// hide the old (non-Echo) preference for this. If Echo is moved to core
|
|
|
|
// we'll want to remove this old user option entirely. For now, though,
|
|
|
|
// we need to keep it defined in case Echo is ever uninstalled.
|
|
|
|
// Otherwise, that preference could be lost entirely. This hiding logic
|
|
|
|
// is not abstracted since there is only a single preference in core
|
|
|
|
// that is potentially made obsolete by Echo.
|
|
|
|
if ( isset( $wgEchoNotifications['edit-user-talk'] ) ) {
|
|
|
|
$preferences['enotifusertalkpages']['type'] = 'hidden';
|
|
|
|
unset( $preferences['enotifusertalkpages']['section'] );
|
|
|
|
}
|
|
|
|
|
2013-03-20 01:10:23 +00:00
|
|
|
// Show fly-out display prefs
|
2013-04-23 18:36:48 +00:00
|
|
|
// Per bug 47562, we're going to hide this pref for now until we see
|
|
|
|
// what the community reaction to Echo is on en.wiki.
|
2013-03-20 01:10:23 +00:00
|
|
|
$preferences['echo-notify-show-link'] = array(
|
2013-04-23 18:36:48 +00:00
|
|
|
'type' => 'hidden',
|
2013-03-20 01:10:23 +00:00
|
|
|
'label-message' => 'echo-pref-notify-show-link',
|
2013-04-23 18:36:48 +00:00
|
|
|
//'section' => 'echo/displaynotifications',
|
2013-03-20 01:10:23 +00:00
|
|
|
);
|
2012-04-27 15:14:24 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-05-17 00:29:37 +00:00
|
|
|
/**
|
|
|
|
* Handler for ArticleSaveComplete hook
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/ArticleSaveComplete
|
|
|
|
* @param $article Article edited
|
|
|
|
* @param $user User who edited
|
2012-09-02 09:30:38 +00:00
|
|
|
* @param $text string New article text
|
|
|
|
* @param $summary string Edit summary
|
|
|
|
* @param $minoredit bool Minor edit or not
|
|
|
|
* @param $watchthis bool Watch this article?
|
2012-09-26 05:09:43 +00:00
|
|
|
* @param $sectionanchor string Section that was edited
|
|
|
|
* @param $flags int Edit flags
|
2012-05-17 00:29:37 +00:00
|
|
|
* @param $revision Revision that was created
|
|
|
|
* @param $status Status
|
2012-09-02 09:30:38 +00:00
|
|
|
* @return bool true in all cases
|
2012-05-17 00:29:37 +00:00
|
|
|
*/
|
2012-08-31 21:50:46 +00:00
|
|
|
public static function onArticleSaved( &$article, &$user, $text, $summary, $minoredit, $watchthis, $sectionanchor, &$flags, $revision, &$status ) {
|
2013-02-16 02:20:34 +00:00
|
|
|
global $wgEchoNotifications, $wgRequest;
|
2012-07-18 19:39:33 +00:00
|
|
|
if ( $revision ) {
|
|
|
|
if ( $article->getTitle()->isTalkPage() ) {
|
|
|
|
EchoDiscussionParser::generateEventsForRevision( $revision );
|
|
|
|
}
|
2012-07-27 22:16:19 +00:00
|
|
|
|
2012-07-18 19:39:33 +00:00
|
|
|
// Handle the case of someone undoing an edit, either through the
|
|
|
|
// 'undo' link in the article history or via the API.
|
2013-02-16 02:20:34 +00:00
|
|
|
if ( isset( $wgEchoNotifications['reverted'] ) ) {
|
2013-01-17 01:38:46 +00:00
|
|
|
$undidRevId = $wgRequest->getVal( 'wpUndidRevision' );
|
2012-11-01 20:15:37 +00:00
|
|
|
if ( $undidRevId ) {
|
|
|
|
$undidRevision = Revision::newFromId( $undidRevId );
|
|
|
|
if ( $undidRevision ) {
|
|
|
|
$victimId = $undidRevision->getUser();
|
|
|
|
if ( $victimId ) { // No notifications for anonymous users
|
|
|
|
EchoEvent::create( array(
|
|
|
|
'type' => 'reverted',
|
|
|
|
'title' => $article->getTitle(),
|
|
|
|
'extra' => array(
|
|
|
|
'revid' => $revision->getId(),
|
|
|
|
'reverted-user-id' => $victimId,
|
|
|
|
'reverted-revision-id' => $undidRevId,
|
|
|
|
'method' => 'undo',
|
|
|
|
),
|
|
|
|
'agent' => $user,
|
|
|
|
) );
|
|
|
|
}
|
2012-07-18 19:39:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-04-27 15:14:24 +00:00
|
|
|
|
2012-11-01 20:15:37 +00:00
|
|
|
}
|
2012-04-27 15:14:24 +00:00
|
|
|
return true;
|
|
|
|
}
|
2012-06-01 10:57:09 +00:00
|
|
|
|
2012-08-31 23:35:16 +00:00
|
|
|
/**
|
|
|
|
* Handler for AddNewAccount hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/AddNewAccount
|
|
|
|
* @param $user User object that was created.
|
|
|
|
* @param $byEmail bool True when account was created "by email".
|
2012-09-26 05:09:43 +00:00
|
|
|
* @return bool
|
2012-08-31 23:35:16 +00:00
|
|
|
*/
|
|
|
|
public static function onAccountCreated( $user, $byEmail ) {
|
2013-04-25 00:41:47 +00:00
|
|
|
|
|
|
|
// new users get echo preferences set that are not the default settings for existing users
|
|
|
|
$user->setOption( 'echo-subscriptions-web-reverted', false );
|
|
|
|
$user->setOption( 'echo-subscriptions-email-reverted', false );
|
|
|
|
$user->setOption( 'echo-subscriptions-web-article-linked', true );
|
|
|
|
$user->setOption( 'echo-subscriptions-email-mention', true );
|
|
|
|
$user->setOption( 'echo-subscriptions-email-article-linked', true );
|
|
|
|
$user->saveSettings();
|
|
|
|
|
2012-09-26 05:09:43 +00:00
|
|
|
EchoEvent::create( array(
|
2012-08-31 23:35:16 +00:00
|
|
|
'type' => 'welcome',
|
|
|
|
'agent' => $user,
|
|
|
|
) );
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-03-13 00:49:19 +00:00
|
|
|
/**
|
|
|
|
* Handler for UserRights hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/UserRights
|
|
|
|
* @param $user User User object that was changed
|
|
|
|
* @param $add array Array of strings corresponding to groups added
|
|
|
|
* @param $remove array Array of strings corresponding to groups removed
|
|
|
|
*/
|
|
|
|
public static function onUserRights( &$user, $add, $remove ) {
|
|
|
|
global $wgUser;
|
|
|
|
|
|
|
|
if ( !$user->isAnon() && $wgUser->getId() != $user->getId() && ( $add || $remove ) ) {
|
|
|
|
EchoEvent::create(
|
|
|
|
array(
|
|
|
|
'type' => 'user-rights',
|
|
|
|
'title' => Title::newMainPage(),
|
|
|
|
'extra' => array(
|
|
|
|
'user' => $user->getID(),
|
|
|
|
'add' => $add,
|
|
|
|
'remove' => $remove
|
|
|
|
),
|
|
|
|
'agent' => $wgUser,
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-12-26 22:05:29 +00:00
|
|
|
/**
|
|
|
|
* Handler for LinksUpdateAfterInsert hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/LinksUpdateAfterInsert
|
|
|
|
* @param $linksUpdate LinksUpdate
|
|
|
|
* @param $table string
|
|
|
|
* @param $insertions array
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public static function onLinksUpdateAfterInsert( $linksUpdate, $table, $insertions ) {
|
2013-03-18 21:48:33 +00:00
|
|
|
global $wgRequest, $wgUser;
|
|
|
|
|
|
|
|
// Rollback or undo should not trigger link notification
|
|
|
|
// @Todo Implement a better solution so it doesn't depend on the checking of
|
|
|
|
// a specific set of request variables
|
|
|
|
if ( $wgRequest->getVal( 'wpUndidRevision' ) || $wgRequest->getVal( 'action' ) == 'rollback' ) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-01-16 00:13:58 +00:00
|
|
|
// Handle only
|
|
|
|
// 1. inserts to pagelinks table &&
|
|
|
|
// 2. content namespace pages &&
|
|
|
|
// 3. non-transcluding pages &&
|
|
|
|
// 4. non-redirect pages
|
|
|
|
if ( $table !== 'pagelinks' || !MWNamespace::isContent( $linksUpdate->mTitle->getNamespace() )
|
|
|
|
|| !$linksUpdate->mRecursive || $linksUpdate->mTitle->isRedirect() )
|
|
|
|
{
|
2013-01-04 01:36:12 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-01-15 23:21:39 +00:00
|
|
|
global $wgUser;
|
|
|
|
|
|
|
|
// link notification is boundless as you can include infinite number of links in a page
|
|
|
|
// db insert is expensive, limit it to a reasonable amount, we can increase this limit
|
|
|
|
// once the storage is on Redis
|
|
|
|
$max = 10;
|
2013-01-08 23:57:28 +00:00
|
|
|
// Only create notifications for links to content namespace pages
|
2013-01-15 23:21:39 +00:00
|
|
|
// @Todo - use one big insert instead of individual insert inside foreach loop
|
2013-01-04 01:36:12 +00:00
|
|
|
foreach ( $insertions as $key => $page ) {
|
2013-01-15 23:21:39 +00:00
|
|
|
if ( MWNamespace::isContent( $page['pl_namespace'] ) ) {
|
|
|
|
$title = Title::makeTitle( $page['pl_namespace'], $page['pl_title'] );
|
|
|
|
EchoEvent::create( array(
|
|
|
|
'type' => 'page-linked',
|
|
|
|
'title' => $title,
|
|
|
|
'agent' => $wgUser,
|
|
|
|
'extra' => array(
|
|
|
|
'link-from-namespace' => $linksUpdate->mTitle->getNamespace(),
|
|
|
|
'link-from-title' => $linksUpdate->mTitle->getDBkey(),
|
|
|
|
)
|
|
|
|
) );
|
|
|
|
$max--;
|
|
|
|
}
|
|
|
|
if ( $max < 0 ) {
|
|
|
|
break;
|
2013-01-04 01:36:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-26 22:05:29 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-05-17 00:29:37 +00:00
|
|
|
/**
|
|
|
|
* Handler for BeforePageDisplay hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/BeforePageDisplay
|
|
|
|
* @param $out OutputPage object
|
|
|
|
* @param $skin Skin being used.
|
2012-09-02 09:30:38 +00:00
|
|
|
* @return bool true in all cases
|
2012-05-17 00:29:37 +00:00
|
|
|
*/
|
2012-06-01 10:57:09 +00:00
|
|
|
static function beforePageDisplay( $out, $skin ) {
|
2012-11-01 21:59:53 +00:00
|
|
|
$user = $out->getUser();
|
2013-03-20 01:10:23 +00:00
|
|
|
if ( $user->isLoggedIn() && $user->getOption( 'echo-notify-show-link' ) ) {
|
2012-11-01 21:59:53 +00:00
|
|
|
// Load the module for the Notifications flyout
|
2012-08-30 16:04:39 +00:00
|
|
|
$out->addModules( array( 'ext.echo.overlay' ) );
|
2012-06-01 10:57:09 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-05-17 00:29:37 +00:00
|
|
|
/**
|
|
|
|
* Handler for PersonalUrls hook.
|
2012-11-01 21:59:53 +00:00
|
|
|
* Add a "Notifications" item to the user toolbar ('personal URLs').
|
2012-05-17 00:29:37 +00:00
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/PersonalUrls
|
|
|
|
* @param &$personal_urls Array of URLs to append to.
|
|
|
|
* @param &$title Title of page being visited.
|
2012-09-02 09:30:38 +00:00
|
|
|
* @return bool true in all cases
|
2012-05-17 00:29:37 +00:00
|
|
|
*/
|
2012-06-01 10:57:09 +00:00
|
|
|
static function onPersonalUrls( &$personal_urls, &$title ) {
|
2012-12-12 02:18:51 +00:00
|
|
|
global $wgUser, $wgEchoShowFullNotificationsLink;
|
2012-11-16 21:03:57 +00:00
|
|
|
// Add a "My notifications" item to personal URLs
|
2013-03-20 01:10:23 +00:00
|
|
|
if ( $wgUser->isAnon() || !$wgUser->getOption( 'echo-notify-show-link' ) ) {
|
2012-06-01 10:57:09 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
$notificationCount = EchoNotificationController::getNotificationCount( $wgUser );
|
2012-12-12 02:18:51 +00:00
|
|
|
if ( $wgEchoShowFullNotificationsLink ) {
|
|
|
|
// Add a "Notifications" item to personal URLs
|
|
|
|
$msg = wfMessage( $notificationCount == 0 ? 'echo-link' : 'echo-link-new' );
|
|
|
|
$text = $msg->params( EchoNotificationController::formatNotificationCount( $notificationCount ) )->text();
|
|
|
|
} else {
|
|
|
|
// Just add a number
|
2013-01-15 23:21:39 +00:00
|
|
|
$text = wfMessage( 'parentheses', EchoNotificationController::formatNotificationCount( $notificationCount ) )->plain();
|
2012-12-12 02:18:51 +00:00
|
|
|
}
|
2012-06-01 10:57:09 +00:00
|
|
|
$url = SpecialPage::getTitleFor( 'Notifications' )->getLocalURL();
|
|
|
|
|
|
|
|
$notificationsLink = array(
|
|
|
|
'href' => $url,
|
2012-12-12 02:18:51 +00:00
|
|
|
'text' => $text,
|
|
|
|
'active' => ( $url == $title->getLocalUrl() ),
|
2012-06-01 10:57:09 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
$insertUrls = array( 'notifications' => $notificationsLink );
|
2012-12-14 02:01:04 +00:00
|
|
|
if ( $wgEchoShowFullNotificationsLink ) {
|
|
|
|
$personal_urls = wfArrayInsertAfter( $personal_urls, $insertUrls, 'mytalk' );
|
|
|
|
} else {
|
|
|
|
$personal_urls = wfArrayInsertAfter( $personal_urls, $insertUrls, 'userpage' );
|
|
|
|
}
|
2012-06-01 10:57:09 +00:00
|
|
|
return true;
|
|
|
|
}
|
2012-07-17 22:19:32 +00:00
|
|
|
|
2012-05-17 00:29:37 +00:00
|
|
|
/**
|
2012-12-19 22:35:45 +00:00
|
|
|
* Handler for AbortEmailNotification and UpdateUserMailerFormattedPageStatus hook.
|
2012-05-17 00:29:37 +00:00
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/AbortEmailNotification
|
2012-12-19 22:35:45 +00:00
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/UpdateUserMailerFormattedPageStatus
|
2012-09-02 09:30:38 +00:00
|
|
|
* @return bool true in all cases
|
2012-05-17 00:29:37 +00:00
|
|
|
*/
|
2012-12-19 22:35:45 +00:00
|
|
|
static function disableStandUserTalkEnotif() {
|
2013-02-16 02:20:34 +00:00
|
|
|
global $wgEchoNotifications, $wgEnotifUserTalk;
|
|
|
|
if ( isset( $wgEchoNotifications['edit-user-talk'] ) ) {
|
2012-11-16 21:03:57 +00:00
|
|
|
// Disable the standard email notification for talk page messages
|
|
|
|
$wgEnotifUserTalk = false;
|
|
|
|
}
|
|
|
|
// Don't abort watchlist email notifications
|
|
|
|
return true;
|
2012-07-17 22:19:32 +00:00
|
|
|
}
|
2012-07-31 21:18:16 +00:00
|
|
|
|
2012-11-01 21:59:53 +00:00
|
|
|
/**
|
|
|
|
* Handler for MakeGlobalVariablesScript hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/MakeGlobalVariablesScript
|
2013-02-28 23:52:12 +00:00
|
|
|
* @param &$vars array Variables to be added into the output
|
2012-11-01 21:59:53 +00:00
|
|
|
* @param $outputPage OutputPage instance calling the hook
|
|
|
|
* @return bool true in all cases
|
|
|
|
*/
|
2012-09-02 09:30:38 +00:00
|
|
|
public static function makeGlobalVariablesScript( &$vars, OutputPage $outputPage ) {
|
2013-04-17 01:00:21 +00:00
|
|
|
global $wgEchoShowFullNotificationsLink, $wgEchoHelpPage, $wgEchoMaxNotificationCount;
|
2012-07-31 21:18:16 +00:00
|
|
|
$user = $outputPage->getUser();
|
|
|
|
|
2012-08-01 19:53:05 +00:00
|
|
|
// Provide info for the Overlay
|
|
|
|
|
2012-09-02 09:30:38 +00:00
|
|
|
$timestamp = new MWTimestamp( wfTimestampNow() );
|
|
|
|
if ( ! $user->isAnon() ) {
|
2012-07-31 21:18:16 +00:00
|
|
|
$vars['wgEchoOverlayConfiguration'] = array(
|
2012-12-12 02:18:51 +00:00
|
|
|
'notifications-link-full' => $wgEchoShowFullNotificationsLink,
|
2012-09-02 09:30:38 +00:00
|
|
|
'timestamp' => $timestamp->getTimestamp( TS_UNIX ),
|
2012-11-13 23:06:11 +00:00
|
|
|
'notification-count' => EchoNotificationController::getFormattedNotificationCount( $user ),
|
2013-04-17 01:00:21 +00:00
|
|
|
'max-notification-count' => $wgEchoMaxNotificationCount,
|
2012-07-31 21:18:16 +00:00
|
|
|
);
|
2013-01-04 21:56:30 +00:00
|
|
|
$vars['wgEchoHelpPage'] = $wgEchoHelpPage;
|
2012-07-31 21:18:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2012-07-31 00:29:49 +00:00
|
|
|
|
2012-11-01 21:59:53 +00:00
|
|
|
/**
|
|
|
|
* Handler for UnitTestsList hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/UnitTestsList
|
|
|
|
* @param &$files Array of unit test files
|
|
|
|
* @return bool true in all cases
|
|
|
|
*/
|
2012-07-31 00:29:49 +00:00
|
|
|
static function getUnitTests( &$files ) {
|
|
|
|
$dir = dirname( __FILE__ ) . '/tests';
|
|
|
|
$files[] = "$dir/DiscussionParserTest.php";
|
2012-08-07 18:54:42 +00:00
|
|
|
return true;
|
2012-07-31 00:29:49 +00:00
|
|
|
}
|
2012-07-31 20:44:43 +00:00
|
|
|
|
2012-11-01 21:59:53 +00:00
|
|
|
/**
|
|
|
|
* Handler for ArticleEditUpdateNewTalk hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/ArticleEditUpdateNewTalk
|
2013-03-20 01:10:23 +00:00
|
|
|
* @param &$page WikiPage The WikiPage object of the talk page being updated
|
|
|
|
* @param $recipient User The user who's talk page was edited
|
|
|
|
* @return bool Should return false to prevent the orange notification bar
|
|
|
|
* or true to allow the orange notification bar
|
2012-11-01 21:59:53 +00:00
|
|
|
*/
|
2013-03-20 01:10:23 +00:00
|
|
|
static function abortNewTalkNotification( &$page, $recipient ) {
|
|
|
|
global $wgEchoNotifications;
|
2012-11-01 21:59:53 +00:00
|
|
|
// If the user has the notifications flyout turned on and is receiving
|
2013-03-20 01:10:23 +00:00
|
|
|
// notifications for talk page messages, disable the orange-bar-style notice.
|
|
|
|
if ( $recipient->getOption( 'echo-notify-show-link' )
|
|
|
|
&& isset( $wgEchoNotifications['edit-user-talk'] )
|
|
|
|
) {
|
|
|
|
// hide orange bar
|
2012-11-01 21:59:53 +00:00
|
|
|
return false;
|
|
|
|
} else {
|
2013-03-20 01:10:23 +00:00
|
|
|
// show orange bar
|
2012-11-01 21:59:53 +00:00
|
|
|
return true;
|
|
|
|
}
|
2012-07-31 20:44:43 +00:00
|
|
|
}
|
2012-07-18 19:39:33 +00:00
|
|
|
|
2012-11-01 21:59:53 +00:00
|
|
|
/**
|
|
|
|
* Handler for ArticleRollbackComplete hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/ArticleRollbackComplete
|
2013-02-28 23:52:12 +00:00
|
|
|
* @param $page WikiPage The article that was edited
|
|
|
|
* @param $agent User The user who did the rollback
|
|
|
|
* @param $newRevision Revision The revision the page was reverted back to
|
|
|
|
* @param $oldRevision Revision The revision of the top edit that was reverted
|
2012-11-01 21:59:53 +00:00
|
|
|
* @return bool true in all cases
|
|
|
|
*/
|
2012-07-18 19:39:33 +00:00
|
|
|
static function onRollbackComplete( $page, $agent, $newRevision, $oldRevision ) {
|
|
|
|
$victimId = $oldRevision->getUser();
|
|
|
|
|
|
|
|
if ( $victimId ) { // No notifications for anonymous users
|
|
|
|
EchoEvent::create( array(
|
|
|
|
'type' => 'reverted',
|
|
|
|
'title' => $page->getTitle(),
|
|
|
|
'extra' => array(
|
|
|
|
'revid' => $page->getRevision()->getId(),
|
|
|
|
'reverted-user-id' => $victimId,
|
|
|
|
'reverted-revision-id' => $oldRevision->getId(),
|
|
|
|
'method' => 'rollback',
|
|
|
|
),
|
|
|
|
'agent' => $agent,
|
|
|
|
) );
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2013-04-12 22:12:22 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Handler for UserSaveSettings hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/UserSaveSettings
|
|
|
|
* @param $user User whose settings were saved
|
|
|
|
* @return bool true in all cases
|
|
|
|
*/
|
|
|
|
static function onUserSaveSettings( $user ) {
|
|
|
|
// Reset the notification count since it may have changed due to user
|
|
|
|
// option changes. This covers both explicit changes in the preferences
|
|
|
|
// and changes made through the options API (since both call this hook).
|
2013-04-20 15:06:25 +00:00
|
|
|
EchoNotificationController::resetNotificationCount( $user );
|
2013-04-12 22:12:22 +00:00
|
|
|
return true;
|
|
|
|
}
|
2013-04-26 16:08:40 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Handler for UserLoadOptions hook.
|
|
|
|
* @see http://www.mediawiki.org/wiki/Manual:Hooks/UserLoadOptions
|
|
|
|
* @param $user User whose options were loaded
|
|
|
|
* @param $options Options can be modified
|
|
|
|
* @return bool true in all cases
|
|
|
|
*/
|
|
|
|
public static function onUserLoadOptions( $user, &$options ) {
|
|
|
|
// If the user had opted out of the old version of talk page notification emails
|
|
|
|
// but we have not migrated a new style preference for the same preference
|
|
|
|
// then fake a new style one too
|
|
|
|
// Only check while we are migrating
|
|
|
|
global $wgRecentEchoInstall;
|
|
|
|
if ( $wgRecentEchoInstall ) {
|
|
|
|
if ( isset( $options['enotifusertalkpages'] ) &&
|
|
|
|
!$options['enotifusertalkpages']
|
|
|
|
) {
|
|
|
|
$options['echo-subscriptions-email-edit-user-talk'] = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// note not calling saveSettings()
|
|
|
|
// so will not change on disk until user saves for some other reason
|
|
|
|
return true;
|
|
|
|
}
|
2012-07-18 16:28:41 +00:00
|
|
|
}
|