SpecialRandomInCategory.php

Go to the documentation of this file.

<?php
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;

    public function __construct( $name = 'RandomInCategory' ) {
        parent::__construct( $name );
    }

    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 ( is_null( $title ) ) {
            $msg = $this->msg( 'randomincategory-nopages',
                $this->category->getText() );

            return Status::newFatal( $msg );
        }

        $this->getOutput()->redirect( $title->getFullURL() );
    }

    public function getRandomTitle() {
        // Convert to float, since we do math with the random number.
        $rand = (float)wfRandom();
        $title = null;

        // 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 );

        // Try again without the timestamp offset (wrap around the end)
        if ( !$row ) {
            $row = $this->selectRandomPageFromDB( false, $offset, $up );
        }

        // Maybe the category is really small and offset too high
        if ( !$row ) {
            $row = $this->selectRandomPageFromDB( $rand, 0, $up );
        }

        // Just get the first entry.
        if ( !$row ) {
            $row = $this->selectRandomPageFromDB( false, 0, true );
        }

        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' => [ 'INNER JOIN', 'cl_from = page_id' ]
            ]
        ];

        $dbr = wfGetDB( 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 ( 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 = wfGetDB( DB_REPLICA );
        $res = $dbr->selectRow(
            'categorylinks',
            [
                'low' => 'MIN( cl_timestamp )',
                'high' => 'MAX( cl_timestamp )'
            ],
            [
                'cl_to' => $this->category->getDBkey(),
            ],
            __METHOD__,
            [
                'LIMIT' => 1
            ]
        );
        if ( !$res ) {
            throw new MWException( 'No entries in category' );
        }

        return [ wfTimestamp( TS_UNIX, $res->low ), wfTimestamp( TS_UNIX, $res->high ) ];
    }

    private function selectRandomPageFromDB( $rand, $offset, $up, $fname = __METHOD__ ) {
        $dbr = wfGetDB( 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';
    }
}