WatchAction.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Actions;
 
use MediaWiki\Context\IContextSource;
use MediaWiki\Exception\PermissionsError;
use MediaWiki\Exception\ReadOnlyError;
use MediaWiki\Exception\UserBlockedError;
use MediaWiki\Exception\UserNotLoggedIn;
use MediaWiki\HTMLForm\HTMLForm;
use MediaWiki\Language\MessageLocalizer;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\Article;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Status\Status;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\User\User;
use MediaWiki\Watchlist\WatchedItem;
use MediaWiki\Watchlist\WatchedItemStoreInterface;
use MediaWiki\Watchlist\WatchlistLabel;
use MediaWiki\Watchlist\WatchlistLabelStore;
use MediaWiki\Watchlist\WatchlistManager;
use MediaWiki\Xml\XmlSelect;
use Wikimedia\Message\MessageValue;
use Wikimedia\ParamValidator\TypeDef\ExpiryDef;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class WatchAction extends FormAction {
 
    protected readonly bool $watchlistExpiry;
 
    private readonly bool $enableWatchlistLabels;
 
    protected $expiryFormFieldName = 'expiry';
 
    protected $watchedItem = false;
 
    public function __construct(
        Article $article,
        IContextSource $context,
        private readonly WatchlistManager $watchlistManager,
        private readonly WatchedItemStoreInterface $watchedItemStore,
        protected readonly WatchlistLabelStore $watchlistLabelStore,
        private readonly UserOptionsLookup $userOptionsLookup,
    ) {
        parent::__construct( $article, $context );
        $this->watchlistExpiry = $this->getContext()->getConfig()->get( MainConfigNames::WatchlistExpiry );
        $this->enableWatchlistLabels = $this->getContext()->getConfig()->get( MainConfigNames::EnableWatchlistLabels );
        if ( $this->watchlistExpiry || $this->enableWatchlistLabels ) {
            // The watchedItem is only used in this action's form if $wgWatchlistExpiry is enabled.
            $this->watchedItem = $watchedItemStore->getWatchedItem(
                $this->getUser(),
                $this->getTitle()
            );
        }
    }
 
    public function getName() {
        return 'watch';
    }
 
    public function requiresUnblock() {
        return false;
    }
 
    protected function getDescription() {
        return '';
    }
 
    public function onSubmit( $data ) {
        // Even though we're never unwatching here, use WatchlistManager::setWatch()
        // because it also checks for changed expiry.
        $result = $this->watchlistManager->setWatch(
            true,
            $this->getAuthority(),
            $this->getTitle(),
            $this->getRequest()->getVal( 'wp' . $this->expiryFormFieldName ),
            $this->getRequest()->getArray( 'wplabels', [] )
        );
 
        return Status::wrap( $result );
    }
 
    protected function checkCanExecute( User $user ) {
        if ( !$user->isRegistered()
            || ( $user->isTemp() && !$user->isAllowed( 'editmywatchlist' ) )
        ) {
            throw new UserNotLoggedIn( 'watchlistanontext', 'watchnologin' );
        }
 
        parent::checkCanExecute( $user );
    }
 
    public function getRestriction() {
        return 'editmywatchlist';
    }
 
    protected function usesOOUI() {
        return true;
    }
 
    protected function getFormFields() {
        // If neither expiries or labels are enabled, return a simple confirmation message.
        if ( !$this->watchlistExpiry && !$this->enableWatchlistLabels ) {
            return [
                'intro' => [
                    'type' => 'info',
                    'raw' => true,
                    'default' => $this->msg( 'confirm-watch-top' )->parse(),
                ],
            ];
        }
 
        $fields = [];
 
        // Use a select-list of expiries, where the default is the user's
        // preferred expiry time (or the existing watch duration if already temporarily watched).
        if ( $this->watchlistExpiry ) {
            $default = $this->userOptionsLookup->getOption( $this->getUser(), 'watchstar-expiry' );
            $expiryOptions = static::getExpiryOptions( $this->getContext(), $this->watchedItem, $default );
            $fields[ $this->expiryFormFieldName] = [
                'type' => 'select',
                'label-message' => 'confirm-watch-label',
                'options' => $expiryOptions['options'],
                'default' => $expiryOptions['default'],
            ];
        }
 
        // Show all of a user's labels as checkboxes.
        if ( $this->enableWatchlistLabels ) {
            $options = [];
            foreach ( $this->watchlistLabelStore->loadAllForUser( $this->getUser() ) as $label ) {
                $options[ htmlspecialchars( $label->getName() ) ] = $label->getId();
            }
            $default = $this->watchedItem instanceof WatchedItem
                ? array_map( static fn ( WatchlistLabel $l ) => $l->getId(), $this->watchedItem->getLabels() )
                : [];
            $fields[ 'labels' ] = [
                'label-message' => 'watchlistlabels-watchaction-label',
                'type' => 'multiselect',
                'options' => $options,
                'default' => $default,
            ];
        }
 
        return $fields;
    }
 
    public static function getExpiryOptions(
        MessageLocalizer $msgLocalizer,
        $watchedItem,
        string $defaultExpiry = 'infinite'
    ) {
        $expiryOptions = self::getExpiryOptionsFromMessage( $msgLocalizer );
 
        if ( !in_array( $defaultExpiry, $expiryOptions ) ) {
            $expiryOptions = array_merge( [ $defaultExpiry => $defaultExpiry ], $expiryOptions );
        }
 
        if ( $watchedItem instanceof WatchedItem && $watchedItem->getExpiry() ) {
            // If it's already being temporarily watched, add the existing expiry as an option in the dropdown.
            $currentExpiry = $watchedItem->getExpiry( TS::ISO_8601 );
            $daysLeft = $watchedItem->getExpiryInDaysText( $msgLocalizer, true );
            $expiryOptions = array_merge( [ $daysLeft => $currentExpiry ], $expiryOptions );
 
            // Always preselect the existing expiry.
            $defaultExpiry = $currentExpiry;
        }
 
        return [
            'options' => $expiryOptions,
            'default' => $defaultExpiry,
        ];
    }
 
    public static function getExpiryOptionsFromMessage(
        MessageLocalizer $msgLocalizer, ?string $lang = null
    ): array {
        $expiryOptionsMsg = $msgLocalizer->msg( 'watchlist-expiry-options' );
        $optionsText = !$lang ? $expiryOptionsMsg->text() : $expiryOptionsMsg->inLanguage( $lang )->text();
        $options = XmlSelect::parseOptionsMessage(
            $optionsText
        );
 
        $expiryOptions = [];
        foreach ( $options as $label => $value ) {
            if ( strtotime( $value ) || wfIsInfinity( $value ) ) {
                $expiryOptions[$label] = $value;
            }
        }
 
        // If message options is invalid try to recover by returning
        // english options (T267611)
        if ( !$expiryOptions && $expiryOptionsMsg->getLanguage()->getCode() !== 'en' ) {
            return self::getExpiryOptionsFromMessage( $msgLocalizer, 'en' );
        }
 
        return $expiryOptions;
    }
 
    protected function alterForm( HTMLForm $form ) {
        $msg = $this->watchlistExpiry && $this->watchedItem ? 'updatewatchlist' : 'addwatch';
        $form->setWrapperLegendMsg( $msg );
        $submitMsg = $this->watchlistExpiry ? 'confirm-watch-button-expiry' : 'confirm-watch-button';
        $form->setSubmitTextMsg( $submitMsg );
        $form->setTokenSalt( 'watch' );
    }
 
    public function onSuccess() {
        // Add success message for watching and (optionally) expiry.
        $submittedExpiry = $this->getContext()->getRequest()->getText( 'wp' . $this->expiryFormFieldName );
        $this->getOutput()->addWikiMsg( $this->makeSuccessMessage( $submittedExpiry ) );
        // Also add a line for labels if any were saved.
        $labelIds = $this->getRequest()->getArray( 'wplabels' );
        if ( $labelIds ) {
            $this->getOutput()->addWikiMsg(
                'watchlistlabels-watchaction-success',
                count( $labelIds ),
                SpecialPage::getTitleFor( 'WatchlistLabels' )->getFullText()
            );
        }
    }
 
    protected function makeSuccessMessage( string $submittedExpiry ): MessageValue {
        $msgKey = $this->getTitle()->isTalkPage() ? 'addedwatchtext-talk' : 'addedwatchtext';
        $params = [];
        if ( $submittedExpiry ) {
            // We can't use $this->watchedItem to get the expiry because it's not been saved at this
            // point in the request and so its values are those from before saving.
            $expiry = ExpiryDef::normalizeExpiry( $submittedExpiry, TS::ISO_8601 );
 
            // If the expiry label isn't one of the predefined ones in the dropdown, calculate 'x days'.
            $expiryDays = WatchedItem::calculateExpiryInDays( $expiry );
            $defaultLabels = static::getExpiryOptionsFromMessage( $this->getContext() );
            $localizedExpiry = array_search( $submittedExpiry, $defaultLabels );
 
            // Determine which message to use, depending on whether this is a talk page or not
            // and whether an expiry was selected.
            $isTalk = $this->getTitle()->isTalkPage();
            if ( wfIsInfinity( $expiry ) ) {
                $msgKey = $isTalk ? 'addedwatchindefinitelytext-talk' : 'addedwatchindefinitelytext';
            } elseif ( $expiryDays >= 1 ) {
                $msgKey = $isTalk ? 'addedwatchexpirytext-talk' : 'addedwatchexpirytext';
                $params[] = $localizedExpiry === false
                    ? $this->getContext()->msg( 'days', $expiryDays )->text()
                    : $localizedExpiry;
            } else {
                // Less than one day.
                $msgKey = $isTalk ? 'addedwatchexpiryhours-talk' : 'addedwatchexpiryhours';
            }
        }
        return MessageValue::new( $msgKey )->params( $this->getTitle()->getPrefixedText(), ...$params );
    }
 
    public function doesWrites() {
        return true;
    }
}
 
class_alias( WatchAction::class, 'WatchAction' );