SpecialWatchlistLabels.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Specials;
 
use InvalidArgumentException;
use MediaWiki\Exception\UserNotLoggedIn;
use MediaWiki\Html\Html;
use MediaWiki\HTMLForm\HTMLForm;
use MediaWiki\MainConfigNames;
use MediaWiki\Message\Message;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Status\Status;
use MediaWiki\Watchlist\WatchlistLabel;
use MediaWiki\Watchlist\WatchlistLabelStore;
use MediaWiki\Watchlist\WatchlistSpecialPage;
use StatusValue;
use Wikimedia\Codex\Builder\TableBuilder;
use Wikimedia\Codex\Utility\Codex;
 
class SpecialWatchlistLabels extends SpecialPage {
 
    private const SUBPAGE_EDIT = 'edit';
    private const SUBPAGE_DELETE = 'delete';
    private const PARAM_ID = 'wll_id';
    private const PARAM_IDS = 'wll_ids';
    private const PARAM_NAME = 'wll_name';
    private const SESSION_SUCCESS_TYPE = 'watchlistLabelsSuccessType';
    private const SESSION_SUCCESS_COUNT = 'watchlistLabelsSuccessCount';
    private const SESSION_SUCCESS_LABEL_NAME = 'watchlistLabelsSuccessLabelName';
    private const SESSION_SUCCESS_OLD_LABEL_NAME = 'watchlistLabelsSuccessOldLabelName';
    private const SUCCESS_CREATE = 'create';
    private const SUCCESS_EDIT = 'edit';
    private const SUCCESS_DELETE = 'delete';
 
    use WatchlistSpecialPage;
 
    private ?WatchlistLabel $watchlistLabel = null;
 
    public function __construct(
        private WatchlistLabelStore $labelStore,
        $name = 'WatchlistLabels',
        $restriction = 'viewmywatchlist',
    ) {
        parent::__construct( $name, $restriction, false );
    }
 
    public function doesWrites() {
        return true;
    }
 
    public function execute( $subPage ) {
        $user = $this->getUser();
        $right = $subPage === self::SUBPAGE_EDIT ? 'editmywatchlist' : 'viewmywatchlist';
        if ( !$user->isRegistered()
            || ( $user->isTemp() && !$user->isAllowed( $right ) )
        ) {
            // The message used here will be one of:
            // * watchlistlabels-not-logged-in
            // * watchlistlabels-not-logged-in-for-temp-user
            throw new UserNotLoggedIn( 'watchlistlabels-not-logged-in' );
        }
        $this->checkPermissions();
 
        $output = $this->getOutput();
        $output->setPageTitleMsg( $this->msg( 'watchlistlabels-title' ) );
        $output->addModuleStyles( 'mediawiki.codex.messagebox.styles' );
        $this->addHelpLink( 'Help:Watchlist labels' );
        if ( !$this->getConfig()->get( MainConfigNames::EnableWatchlistLabels ) ) {
            $output->addHTML( Html::errorBox( $this->msg( 'watchlistlabels-not-enabled' )->escaped() ) );
            return;
        }
 
        $this->outputSubtitle();
 
        if ( $subPage === self::SUBPAGE_EDIT ) {
            $this->showEditForm();
        } elseif ( $subPage === self::SUBPAGE_DELETE ) {
            $this->showDeleteConfirmation();
        } else {
            $this->showTable();
        }
    }
 
    private function showEditForm() {
        $id = $this->getRequest()->getInt( self::PARAM_ID );
        $descriptor = [
            self::PARAM_NAME => [
                'type' => 'text',
                'name' => self::PARAM_NAME,
                'label-message' => 'watchlistlabels-form-field-name',
                'validation-callback' => [ $this, 'validateName' ],
                'filter-callback' => [ $this, 'filterName' ],
                'required' => true,
            ],
        ];
        $msgSuffix = 'new';
        if ( $id ) {
            $this->watchlistLabel = $this->labelStore->loadById( $this->getUser(), $id );
            if ( $this->watchlistLabel ) {
                $descriptor[self::PARAM_NAME]['default'] = $this->watchlistLabel->getName();
                $descriptor[self::PARAM_ID] = [
                    'type' => 'hidden',
                    'name' => self::PARAM_ID,
                    'default' => $this->watchlistLabel->getId(),
                ];
                $msgSuffix = 'edit';
            }
        }
        $form = HTMLForm::factory( 'codex', $descriptor, $this->getContext() )
            // Messages used here:
            // - watchlistlabels-form-header-new
            // - watchlistlabels-form-header-edit
            ->setHeaderHtml( Html::element( 'h3', [], $this->msg( "watchlistlabels-form-header-$msgSuffix" )->text() ) )
            ->showCancel( true )
            ->setCancelTarget( $this->getPageTitle() )
            // Messages used here:
            // - watchlistlabels-form-submit-new
            // - watchlistlabels-form-submit-edit
            ->setSubmitTextMsg( "watchlistlabels-form-submit-$msgSuffix" )
            ->setSubmitCallback( [ $this, 'onEditFormSubmit' ] );
        $form->show();
    }
 
    public function filterName( $value, ?array $alldata, ?HTMLForm $form ) {
        $label = new WatchlistLabel( $this->getUser(), $value ?? '' );
        return $label->getName();
    }
 
    public function validateName( $value, ?array $alldata, ?HTMLForm $form ) {
        $length = strlen( trim( $value ) );
        if ( $length === 0 ) {
            return StatusValue::newFatal( 'watchlistlabels-form-name-too-short', $length );
        }
        if ( $length > 255 ) {
            return StatusValue::newFatal( 'watchlistlabels-form-name-too-long', $length );
        }
        $existingLabel = $this->labelStore->loadByName( $this->getUser(), $value );
        $thisId = $alldata[self::PARAM_ID] ?? null;
        if ( $existingLabel && $existingLabel->getId() !== (int)$thisId ) {
            return StatusValue::newFatal( 'watchlistlabels-form-name-exists', $existingLabel->getName() );
        }
        return StatusValue::newGood();
    }
 
    public function onEditFormSubmit( $data ): Status {
        if ( !isset( $data[self::PARAM_NAME] ) ) {
            throw new InvalidArgumentException( 'No name data submitted.' );
        }
        $successType = self::SUCCESS_CREATE;
        $oldName = null;
        if ( $this->watchlistLabel && $this->watchlistLabel->getId() ) {
            $successType = self::SUCCESS_EDIT;
            $oldName = $this->watchlistLabel->getName();
        }
        if ( !$this->watchlistLabel ) {
            $this->watchlistLabel = new WatchlistLabel( $this->getUser(), $data[self::PARAM_NAME] );
        } else {
            $this->watchlistLabel->setName( $data[self::PARAM_NAME] );
        }
        $saved = $this->labelStore->save( $this->watchlistLabel );
        if ( $saved->isOK() ) {
            $session = $this->getRequest()->getSession();
            $session->set( self::SESSION_SUCCESS_TYPE, $successType );
            $session->set( self::SESSION_SUCCESS_LABEL_NAME, $this->watchlistLabel->getName() );
            if ( $successType === self::SUCCESS_EDIT && $oldName !== null ) {
                $session->set( self::SESSION_SUCCESS_OLD_LABEL_NAME, $oldName );
            }
            $this->getOutput()->redirect( $this->getPageTitle()->getFullUrlForRedirect() );
        }
        return Status::cast( $saved );
    }
 
    private function showDeleteConfirmation(): void {
        $ids = $this->getRequest()->getArray( self::PARAM_IDS ) ?? [];
        $labels = $this->labelStore->loadAllForUser( $this->getUser() );
        $toDelete = array_intersect_key( $labels, array_flip( $ids ) );
        $labelCounts = $this->labelStore->countItems( array_keys( $labels ) );
        $listItems = '';
        foreach ( $toDelete as $label ) {
            $listItems .= Html::rawElement( 'li', [], $this->getDeleteConfirmationListItem( $label, $labelCounts ) );
        }
        $count = count( $toDelete );
        $formattedCount = $this->getLanguage()->formatNum( $count );
        $msg = $this->msg( 'watchlistlabels-delete-warning', $count, $formattedCount )->text();
        $warning = Html::element( 'p', [], $msg );
        $list = Html::rawElement( 'ol', [], $listItems );
        $descriptor = [
            'list' => [
                'type' => 'info',
                'default' => $warning . $list,
                'rawrow' => true,
            ],
            self::PARAM_IDS => [
                'type' => 'hidden',
                'name' => self::PARAM_IDS,
                'default' => implode( ',', array_keys( $toDelete ) ),
            ],
        ];
        $header = $this->msg( 'watchlistlabels-delete-header', $count )->text();
        HTMLForm::factory( 'codex', $descriptor, $this->getContext() )
            ->setHeaderHtml( Html::element( 'h3', [], $header ) )
            ->showCancel( true )
            ->setCancelTarget( $this->getPageTitle() )
            ->setSubmitTextMsg( 'delete' )
            ->setSubmitDestructive()
            ->setSubmitCallback( [ $this, 'onDeleteFormSubmit' ] )
            ->show();
    }
 
    private function getDeleteConfirmationListItem( WatchlistLabel $label, array $labelCounts ): string {
        $id = $label->getId();
        if ( !$id ) {
            return '';
        }
        $itemCount = $labelCounts[ $id ];
        if ( $labelCounts[ $id ] > 0 ) {
            $labelCountMsg = $this->msg(
                'watchlistlabels-delete-count',
                $this->getLanguage()->formatNum( $itemCount ),
                $itemCount
            )->escaped();
        } else {
            $labelCountMsg = $this->msg( 'watchlistlabels-delete-unused' )->escaped();
        }
        return Html::element( 'span', [], $label->getName() )
            . $this->msg( 'word-separator' )->escaped()
            . $this->msg( 'parentheses-start' )->escaped()
            . Html::rawElement( 'em', [], $labelCountMsg )
            . $this->msg( 'parentheses-end' )->escaped();
    }
 
    public function onDeleteFormSubmit( $data ) {
        if ( !isset( $data[self::PARAM_IDS] ) ) {
            throw new InvalidArgumentException( 'No name data submitted.' );
        }
        $ids = array_map( 'intval', array_filter( explode( ',', $data[self::PARAM_IDS] ) ) );
        $labels = $this->labelStore->loadAllForUser( $this->getUser() );
        $deletedLabelNames = [];
        foreach ( $ids as $id ) {
            if ( isset( $labels[$id] ) ) {
                $deletedLabelNames[] = $labels[$id]->getName();
            }
        }
        if ( $this->labelStore->delete( $this->getUser(), $ids ) ) {
            $session = $this->getRequest()->getSession();
            $session->set( self::SESSION_SUCCESS_TYPE, self::SUCCESS_DELETE );
            $session->set( self::SESSION_SUCCESS_COUNT, count( $ids ) );
            if ( count( $deletedLabelNames ) === 1 ) {
                $session->set( self::SESSION_SUCCESS_LABEL_NAME, $deletedLabelNames[0] );
            }
            $this->getOutput()->redirect( $this->getPageTitle()->getFullUrlForRedirect() );
            return Status::newGood();
        }
        return Status::newFatal( 'watchlistlabels-delete-failed' );
    }
 
    private function showTable() {
        $codex = new Codex();
        $this->getOutput()->addModules( 'mediawiki.special.watchlistlabels' );
        $this->getOutput()->addModuleStyles( 'mediawiki.special.watchlistlabels.styles' );
        $this->showSuccessMessage();
 
        // Page title and description.
        $this->getOutput()->addHTML(
            Html::element( 'h3', [], $this->msg( 'watchlistlabels-table-title' )->text() )
            . Html::element( 'p', [], $this->msg( 'watchlistlabels-table-description' )->text() ),
        );
 
        // Buttons in the table header.
        $params = [
            'href' => $this->getPageTitle( self::SUBPAGE_EDIT )->getLinkURL(),
            // @todo Remove Codex classes when T406372 is resolved.
            'class' => 'cdx-button cdx-button--fake-button cdx-button--fake-button--enabled'
                . ' cdx-button--action-progressive cdx-button--weight-primary'
        ];
        $newIcon = Html::element( 'span', [
            'class' => 'cdx-button__icon mw-specialwatchlistlabels-icon--add',
            'aria-hidden' => 'true',
        ] );
        $createLabel = $newIcon . ' ' . $this->msg( 'watchlistlabels-table-new-link' )->escaped();
        $createButton = Html::rawElement( 'a', $params, $createLabel );
        $deleteButton = $codex->button()
            ->setAttributes( [ 'class' => 'mw-specialwatchlistlabels-delete-button' ] )
            ->setLabel( $this->msg( 'watchlistlabels-table-delete-link' )->text() )
            ->setIconClass( 'mw-specialwatchlistlabels-icon--trash' )
            ->setType( 'submit' )
            ->setAction( 'destructive' )
            ->build()
            ->getHtml();
 
        // Data.
        $data = [];
        $labels = $this->labelStore->loadAllForUser( $this->getUser() );
        $labelCounts = $this->labelStore->countItems( array_keys( $labels ) );
        $editIcon = Html::element( 'span', [ 'class' => 'cdx-button__icon mw-specialwatchlistlabels-icon--edit' ] );
        foreach ( $labels as $label ) {
            $id = $label->getId();
            if ( !$id ) {
                continue;
            }
            $url = $this->getPageTitle( self::SUBPAGE_EDIT )->getLocalURL( [ self::PARAM_ID => $id ] );
            $params = [
                'href' => $url,
                'role' => 'button',
                'class' => 'cdx-button cdx-button--fake-button cdx-button--fake-button--enabled'
                    . ' cdx-button--weight-quiet cdx-button--icon-only cdx-button--size-small',
                'title' => $this->msg( 'watchlistlabels-table-edit' )->text(),
            ];
            $checkboxId = self::PARAM_IDS . '_' . $id;
            $labelVal = Html::element( 'bdi', [], $label->getName() );
            // The sortable columns must have matching '*-sort' elements containing unformatted data for sorting.
            $data[] = [
                'select' => $this->getCheckbox( $checkboxId, (string)$id ),
                'name' => Html::rawElement( 'label', [ 'for' => $checkboxId ], $labelVal ),
                'name-sort' => mb_strtolower( $label->getName() ),
                'count' => $this->getLanguage()->formatNum( $labelCounts[ $id ] ),
                'count-sort' => $labelCounts[ $id ],
                'edit' => Html::rawElement( 'a', $params, $editIcon ),
            ];
        }
 
        // Sort by count by default, and others as requested.
        // We sort here rather than in the DB because we're combining multiple queries' data,
        // and there's only ever one page of results to show (up to 100).
        $sortCol = $this->getRequest()->getText( 'sort', 'count' );
        $sortDir = $this->getRequest()->getBool( 'asc' ) ? TableBuilder::SORT_ASCENDING : TableBuilder::SORT_DESCENDING;
        $sortColName = $sortCol . '-sort';
        usort(
            $data,
            static function ( $a, $b ) use ( $sortDir, $sortColName ) {
                if ( !isset( $a[$sortColName] )
                    || !isset( $b[$sortColName] )
                    || $a[$sortColName] === $b[$sortColName]
                ) {
                    return 0;
                }
                return $sortDir === TableBuilder::SORT_ASCENDING
                    ? $a[$sortColName] <=> $b[$sortColName]
                    : $b[$sortColName] <=> $a[$sortColName];
            }
        );
 
        // Put it all together in the table.
        $table = $codex->table()
            ->setCurrentSortColumn( $sortCol )
            ->setCurrentSortDirection( $sortDir )
            ->setAttributes( [ 'class' => 'mw-specialwatchlistlabels-table' ] )
            ->setCaption( $this->msg( 'watchlistlabels-table-header' )->text() )
            ->setHeaderContent( "$createButton $deleteButton" )
            ->setColumns( [
                [
                    'id' => 'select',
                    'label' => '',
                ],
                [
                    'id' => 'name',
                    'label' => $this->msg( 'watchlistlabels-table-col-name' )->escaped(),
                    'sortable' => true,
                ],
                [
                    'id' => 'count',
                    'label' => $this->msg( 'watchlistlabels-table-col-count' )->escaped(),
                    'sortable' => true,
                ],
                [
                    'id' => 'edit',
                    'label' => $this->msg( 'watchlistlabels-table-col-actions' )->escaped(),
                ],
            ] )
            ->setData( $data )
            ->setPaginate( false )
            ->build();
        $deleteUrl = $this->getPageTitle( self::SUBPAGE_DELETE )->getLocalURL();
        $form = Html::rawElement( 'form', [ 'action' => $deleteUrl ], $table->getHtml() );
        $this->getOutput()->addHTML( $form );
    }
 
    private function showSuccessMessage(): void {
        $session = $this->getRequest()->getSession();
        $successType = $session->get( self::SESSION_SUCCESS_TYPE );
        if ( !$successType ) {
            return;
        }
        $successCount = $session->get( self::SESSION_SUCCESS_COUNT );
        $successLabelName = $session->get( self::SESSION_SUCCESS_LABEL_NAME );
        $successOldLabelName = $session->get( self::SESSION_SUCCESS_OLD_LABEL_NAME );
 
        // Clear session data after reading
        $session->remove( self::SESSION_SUCCESS_TYPE );
        $session->remove( self::SESSION_SUCCESS_COUNT );
        $session->remove( self::SESSION_SUCCESS_LABEL_NAME );
        $session->remove( self::SESSION_SUCCESS_OLD_LABEL_NAME );
 
        $message = null;
        switch ( $successType ) {
            case self::SUCCESS_CREATE:
                $message = $this->msg( 'watchlistlabels-success-created', $successLabelName )->escaped();
                break;
            case self::SUCCESS_EDIT:
                if ( !$successOldLabelName || !$successLabelName ) {
                    return;
                }
                $message = $this->msg(
                    'watchlistlabels-success-edited',
                    $successOldLabelName,
                    $successLabelName
                )->escaped();
                break;
            case self::SUCCESS_DELETE:
                $count = max( 0, (int)$successCount );
                if ( $count === 0 ) {
                    return;
                }
                $message = $this->msg( 'watchlistlabels-success-deleted', $successLabelName, $count )->escaped();
                break;
        }
 
        if ( $message !== null ) {
            $this->getOutput()->addHTML( Html::successBox( $message ) );
        }
    }
 
    private function getCheckbox( string $id, string $value ): string {
        $checkbox = Html::check(
            self::PARAM_IDS . '[]',
            false,
            [ 'value' => $value, 'class' => 'cdx-checkbox__input', 'id' => $id ]
        );
        $checkboxIcon = Html::element( 'span', [ 'class' => 'cdx-checkbox__icon' ] );
        $checkboxWrapper = Html::rawElement(
            'div',
            [ 'class' => 'cdx-checkbox__wrapper' ],
            $checkbox . $checkboxIcon
        );
        return Html::rawElement( 'div', [ 'class' => 'cdx-checkbox' ], $checkboxWrapper );
    }
}