SpecialRandomInCategory.php

Go to the documentation of this file.

<?php
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\RequestTimeout\TimeoutException;
 
class SpecialRandomInCategory extends FormSpecialPage {
    protected $extra = []; // Extra SQL statements
    protected $category = false; // Title object of category
    protected $maxOffset = 30; // Max amount to fudge randomness by.
    private $maxTimestamp = null;
    private $minTimestamp = null;
 
    private $loadBalancer;
 
    public function __construct( ILoadBalancer $loadBalancer ) {
        parent::__construct( 'RandomInCategory' );
        $this->loadBalancer = $loadBalancer;
    }
 
    public function setCategory( Title $cat ) {
        $this->category = $cat;
        $this->maxTimestamp = null;
        $this->minTimestamp = null;
    }
 
    protected function getFormFields() {
        $this->addHelpLink( 'Help:RandomInCategory' );
 
        return [
            'category' => [
                'type' => 'title',
                'namespace' => NS_CATEGORY,
                'relative' => true,
                'label-message' => 'randomincategory-category',
                'required' => true,
            ]
        ];
    }
 
    public function requiresWrite() {
        return false;
    }
 
    public function requiresUnblock() {
        return false;
    }
 
    protected function getDisplayFormat() {
        return 'ooui';
    }
 
    protected function alterForm( HTMLForm $form ) {
        $form->setSubmitTextMsg( 'randomincategory-submit' );
    }
 
    protected function setParameter( $par ) {
        // if subpage present, fake form submission
        $this->onSubmit( [ 'category' => $par ] );
    }
 
    public function onSubmit( array $data ) {
        $cat = false;
 
        $categoryStr = $data['category'];
 
        if ( $categoryStr ) {
            $cat = Title::newFromText( $categoryStr, NS_CATEGORY );
        }
 
        if ( $cat && $cat->getNamespace() !== NS_CATEGORY ) {
            // Someone searching for something like "Wikipedia:Foo"
            $cat = Title::makeTitleSafe( NS_CATEGORY, $categoryStr );
        }
 
        if ( $cat ) {
            $this->setCategory( $cat );
        }
 
        if ( !$this->category && $categoryStr ) {
            $msg = $this->msg( 'randomincategory-invalidcategory',
                wfEscapeWikiText( $categoryStr ) );
 
            return Status::newFatal( $msg );
 
        } elseif ( !$this->category ) {
            return false; // no data sent
        }
 
        $title = $this->getRandomTitle();
 
        if ( $title === null ) {
            $msg = $this->msg( 'randomincategory-nopages',
                $this->category->getText() );
 
            return Status::newFatal( $msg );
        }
 
        $query = $this->getRequest()->getQueryValues();
        unset( $query['title'] );
        $this->getOutput()->redirect( $title->getFullURL( $query ) );
    }
 
    public function getRandomTitle() {
        // Convert to float, since we do math with the random number.
        $rand = (float)wfRandom();
 
        // Given that timestamps are rather unevenly distributed, we also
        // use an offset between 0 and 30 to make any biases less noticeable.
        $offset = mt_rand( 0, $this->maxOffset );
 
        if ( mt_rand( 0, 1 ) ) {
            $up = true;
        } else {
            $up = false;
        }
 
        $row = $this->selectRandomPageFromDB( $rand, $offset, $up, __METHOD__ );
 
        // Try again without the timestamp offset (wrap around the end)
        if ( !$row ) {
            $row = $this->selectRandomPageFromDB( false, $offset, $up, __METHOD__ );
        }
 
        // Maybe the category is really small and offset too high
        if ( !$row ) {
            $row = $this->selectRandomPageFromDB( $rand, 0, $up, __METHOD__ );
        }
 
        // Just get the first entry.
        if ( !$row ) {
            $row = $this->selectRandomPageFromDB( false, 0, true, __METHOD__ );
        }
 
        if ( $row ) {
            return Title::makeTitle( $row->page_namespace, $row->page_title );
        }
 
        return null;
    }
 
    protected function getQueryInfo( $rand, $offset, $up ) {
        $op = $up ? '>=' : '<=';
        $dir = $up ? 'ASC' : 'DESC';
        if ( !$this->category instanceof Title ) {
            throw new MWException( 'No category set' );
        }
        $qi = [
            'tables' => [ 'categorylinks', 'page' ],
            'fields' => [ 'page_title', 'page_namespace' ],
            'conds' => array_merge( [
                'cl_to' => $this->category->getDBkey(),
            ], $this->extra ),
            'options' => [
                'ORDER BY' => 'cl_timestamp ' . $dir,
                'LIMIT' => 1,
                'OFFSET' => $offset
            ],
            'join_conds' => [
                'page' => [ 'JOIN', 'cl_from = page_id' ]
            ]
        ];
 
        $dbr = $this->loadBalancer->getConnectionRef( ILoadBalancer::DB_REPLICA );
        $minClTime = $this->getTimestampOffset( $rand );
        if ( $minClTime ) {
            $qi['conds'][] = 'cl_timestamp ' . $op . ' ' .
                $dbr->addQuotes( $dbr->timestamp( $minClTime ) );
        }
 
        return $qi;
    }
 
    protected function getTimestampOffset( $rand ) {
        if ( $rand === false ) {
            return false;
        }
        if ( !$this->minTimestamp || !$this->maxTimestamp ) {
            try {
                list( $this->minTimestamp, $this->maxTimestamp ) = $this->getMinAndMaxForCat( $this->category );
            } catch ( TimeoutException $e ) {
                throw $e;
            } catch ( Exception $e ) {
                // Possibly no entries in category.
                return false;
            }
        }
 
        $ts = ( $this->maxTimestamp - $this->minTimestamp ) * $rand + $this->minTimestamp;
 
        return intval( $ts );
    }
 
    protected function getMinAndMaxForCat( Title $category ) {
        $dbr = $this->loadBalancer->getConnectionRef( ILoadBalancer::DB_REPLICA );
        $res = $dbr->selectRow(
            'categorylinks',
            [
                'low' => 'MIN( cl_timestamp )',
                'high' => 'MAX( cl_timestamp )'
            ],
            [
                'cl_to' => $this->category->getDBkey(),
            ],
            __METHOD__
        );
        if ( !$res ) {
            throw new MWException( 'No entries in category' );
        }
 
        return [ (int)wfTimestamp( TS_UNIX, $res->low ), (int)wfTimestamp( TS_UNIX, $res->high ) ];
    }
 
    private function selectRandomPageFromDB( $rand, $offset, $up, $fname = __METHOD__ ) {
        $dbr = $this->loadBalancer->getConnectionRef( ILoadBalancer::DB_REPLICA );
 
        $query = $this->getQueryInfo( $rand, $offset, $up );
        $res = $dbr->select(
            $query['tables'],
            $query['fields'],
            $query['conds'],
            $fname,
            $query['options'],
            $query['join_conds']
        );
 
        return $res->fetchObject();
    }
 
    protected function getGroupName() {
        return 'redirects';
    }
}