EmailNotification.php

Go to the documentation of this file.

<?php
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Mail\RecentChangeMailComposer;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Notification\RecipientSet;
use MediaWiki\Permissions\Authority;
use MediaWiki\RecentChanges\RecentChange;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
use MediaWiki\User\UserArray;
use MediaWiki\User\UserIdentity;
use MediaWiki\Watchlist\RecentChangeNotification;
 
class EmailNotification {
 
    protected string $pageStatus = '';
 
    public function getPageStatus() {
        return $this->pageStatus;
    }
 
    public function notifyOnPageChange(
        RecentChange $recentChange
    ): bool {
        $mwServices = MediaWikiServices::getInstance();
        $editor = $mwServices->getUserFactory()
            ->newFromUserIdentity( $recentChange->getPerformerIdentity() );
 
        $title = Title::castFromPageReference( $recentChange->getPage() );
        if ( $title === null || $title->getNamespace() < 0 ) {
            return false;
        }
 
        $timestamp = $recentChange->mAttribs['rc_timestamp'];
        $summary = $recentChange->mAttribs['rc_comment'];
        $minorEdit = $recentChange->mAttribs['rc_minor'];
        $oldid = $recentChange->mAttribs['rc_last_oldid'];
        $pageStatus = $recentChange->mExtra['pageStatus'] ?? 'changed';
 
        $config = $mwServices->getMainConfig();
 
        / update wl_notificationtimestamp for watchers
        $watchers = [];
        if ( $config->get( MainConfigNames::EnotifWatchlist ) || $config->get( MainConfigNames::ShowUpdatedMarker ) ) {
            $watchers = $mwServices->getWatchedItemStore()->updateNotificationTimestamp(
                $editor,
                $title,
                $timestamp
            );
        }
 
        / Don't send email for bots
        if ( $editor->isBot() ) {
            return false;
        }
 
        $sendNotification = true;
        / $watchers deals with $wgEnotifWatchlist.
        / If nobody is watching the page, and there are no users notified on all changes
        / don't bother creating a job/trying to send emails, unless it's a
        / talk page with an applicable notification.
        if ( $watchers === [] &&
            !count( $config->get( MainConfigNames::UsersNotifiedOnAllChanges ) )
        ) {
            $sendNotification = false;
            / Only send notification for non minor edits, unless $wgEnotifMinorEdits
            if ( !$minorEdit ||
                ( $config->get( MainConfigNames::EnotifMinorEdits ) &&
                    !$editor->isAllowed( 'nominornewtalk' ) )
            ) {
                if ( $config->get( MainConfigNames::EnotifUserTalk )
                    && $title->getNamespace() === NS_USER_TALK
                    && $this->canSendUserTalkEmail( $editor, $title, $minorEdit )
                ) {
                    $sendNotification = true;
                }
            }
        }
 
        if ( $sendNotification ) {
            $mwServices->getJobQueueGroup()->lazyPush( new EnotifNotifyJob(
                $title,
                [
                    'editor' => $editor->getName(),
                    'editorID' => $editor->getId(),
                    'timestamp' => $timestamp,
                    'summary' => $summary,
                    'minorEdit' => $minorEdit,
                    'oldid' => $oldid,
                    'watchers' => $watchers,
                    'pageStatus' => $pageStatus,
                    / not used yet, passed to support T388663 and T389618 in the future
                    'rc_id' => $recentChange->getAttribute( 'rc_id' ),
                ]
            ) );
        }
 
        return $sendNotification;
    }
 
    public function actuallyNotifyOnPageChange(
        Authority $editor,
        $title,
        $timestamp,
        $summary,
        $minorEdit,
        $oldid,
        $watchers,
        $pageStatus = 'changed'
    ) {
        # we use $wgPasswordSender as sender's address
        $mwServices = MediaWikiServices::getInstance();
        $config = $mwServices->getMainConfig();
        $notifService = $mwServices->getNotificationService();
        $userFactory = $mwServices->getUserFactory();
 
        # The following code is only run, if several conditions are met:
        # 1. EmailNotification for pages (other than user_talk pages) must be enabled
        # 2. minor edits (changes) are only regarded if the global flag indicates so
        $this->pageStatus = $pageStatus;
 
        $formattedPageStatus = [ 'deleted', 'created', 'moved', 'restored', 'changed' ];
 
        $hookRunner = new HookRunner( $mwServices->getHookContainer() );
        $hookRunner->onUpdateUserMailerFormattedPageStatus( $formattedPageStatus );
        if ( !in_array( $this->pageStatus, $formattedPageStatus ) ) {
            throw new UnexpectedValueException( 'Not a valid page status!' );
        }
 
        $composer = new RecentChangeMailComposer(
            $editor,
            $title,
            $summary,
            $minorEdit,
            $oldid,
            $timestamp,
            $pageStatus
        );
 
        $userTalkId = false;
 
        if ( !$minorEdit ||
            ( $config->get( MainConfigNames::EnotifMinorEdits ) &&
                !$editor->isAllowed( 'nominornewtalk' ) )
        ) {
            if ( $config->get( MainConfigNames::EnotifUserTalk )
                && $title->getNamespace() === NS_USER_TALK
                && $this->canSendUserTalkEmail( $editor->getUser(), $title, $minorEdit )
            ) {
                $targetUser = $userFactory->newFromName( $title->getText() );
                if ( $targetUser ) {
                    $talkNotification = new RecentChangeNotification(
                        $mwServices->getUserFactory()->newFromAuthority( $editor ),
                        $title,
                        $summary,
                        $minorEdit,
                        $oldid,
                        $timestamp,
                        $pageStatus,
                        RecentChangeNotification::TALK_NOTIFICATION
                    );
                    $notifService->notify( $talkNotification, new RecipientSet( [ $targetUser ] ) );
                    $userTalkId = $targetUser->getId();
                }
            }
 
            if ( $config->get( MainConfigNames::EnotifWatchlist ) ) {
                $userOptionsLookup = $mwServices->getUserOptionsLookup();
                / Send updates to watchers other than the current editor
                / and don't send to watchers who are blocked and cannot login
                $userArray = UserArray::newFromIDs( $watchers );
                foreach ( $userArray as $watchingUser ) {
                    if ( $userOptionsLookup->getOption( $watchingUser, 'enotifwatchlistpages' )
                        && ( !$minorEdit || $userOptionsLookup->getOption( $watchingUser, 'enotifminoredits' ) )
                        && $watchingUser->isEmailConfirmed()
                        && $watchingUser->getId() != $userTalkId
                        && !in_array( $watchingUser->getName(),
                            $config->get( MainConfigNames::UsersNotifiedOnAllChanges ) )
                        / @TODO Partial blocks should not prevent the user from logging in.
                        /       see: https://phabricator.wikimedia.org/T208895
                        && !( $config->get( MainConfigNames::BlockDisablesLogin ) &&
                            $watchingUser->getBlock() )
                        && $hookRunner->onSendWatchlistEmailNotification( $watchingUser, $title, $this )
                    ) {
                        $composer->compose( $watchingUser, RecentChangeMailComposer::WATCHLIST );
                    }
                }
            }
        }
 
        foreach ( $config->get( MainConfigNames::UsersNotifiedOnAllChanges ) as $name ) {
            $admins = [];
            if ( $editor->getUser()->getName() == $name ) {
                / No point notifying the user that actually made the change!
                continue;
            }
            $user = $userFactory->newFromName( $name );
            if ( $user instanceof User ) {
                $admins[] = $user;
            }
            $notifService->notify(
                new RecentChangeNotification(
                    $mwServices->getUserFactory()->newFromAuthority( $editor ),
                    $title,
                    $summary,
                    $minorEdit,
                    $oldid,
                    $timestamp,
                    $pageStatus,
                    RecentChangeNotification::ADMIN_NOTIFICATION
                ),
                new RecipientSet( $admins )
            );
 
        }
        $composer->sendMails();
    }
 
    private function canSendUserTalkEmail( UserIdentity $editor, $title, $minorEdit ) {
        $services = MediaWikiServices::getInstance();
        $config = $services->getMainConfig();
 
        if ( !$config->get( MainConfigNames::EnotifUserTalk ) || $title->getNamespace() !== NS_USER_TALK ) {
            return false;
        }
 
        $userOptionsLookup = $services->getUserOptionsLookup();
        $targetUser = User::newFromName( $title->getText() );
 
        if ( !$targetUser || $targetUser->isAnon() ) {
            wfDebug( __METHOD__ . ": user talk page edited, but user does not exist" );
        } elseif ( $targetUser->getId() == $editor->getId() ) {
            wfDebug( __METHOD__ . ": user edited their own talk page, no notification sent" );
        } elseif ( $targetUser->isTemp() ) {
            wfDebug( __METHOD__ . ": talk page owner is a temporary user so doesn't have email" );
        } elseif ( $config->get( MainConfigNames::BlockDisablesLogin ) &&
            $targetUser->getBlock()
        ) {
            / @TODO Partial blocks should not prevent the user from logging in.
            /       see: https://phabricator.wikimedia.org/T208895
            wfDebug( __METHOD__ . ": talk page owner is blocked and cannot login, no notification sent" );
        } elseif ( $userOptionsLookup->getOption( $targetUser, 'enotifusertalkpages' )
            && ( !$minorEdit || $userOptionsLookup->getOption( $targetUser, 'enotifminoredits' ) )
        ) {
            if ( !$targetUser->isEmailConfirmed() ) {
                wfDebug( __METHOD__ . ": talk page owner doesn't have validated email" );
            } elseif ( !( new HookRunner( $services->getHookContainer() ) )
                ->onAbortTalkPageEmailNotification( $targetUser, $title )
            ) {
                wfDebug( __METHOD__ . ": talk page update notification is aborted for this user" );
            } else {
                wfDebug( __METHOD__ . ": sending talk page update notification" );
                return true;
            }
        } else {
            wfDebug( __METHOD__ . ": talk page owner doesn't want notifications" );
        }
        return false;
    }
 
}