includes/specials/SpecialPagesWithProp.php

   1 <?php
   2 /**
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  * http://www.gnu.org/copyleft/gpl.html
  17  *
  18  * @file
  19  */
  20
  21 namespace MediaWiki\Specials;
  22
  23 use MediaWiki\Html\Html;
  24 use MediaWiki\HTMLForm\HTMLForm;
  25 use MediaWiki\SpecialPage\QueryPage;
  26 use MediaWiki\Title\Title;
  27 use Skin;
  28 use stdClass;
  29 use Wikimedia\Rdbms\IConnectionProvider;
  30
  31 /**
  32  * Special:PagesWithProp to search the page_props table
  33  *
  34  * @ingroup SpecialPage
  35  * @since 1.21
  36  */
  37 class SpecialPagesWithProp extends QueryPage {
  38
  39         /**
  40          * @var string|null
  41          */
  42         private $propName = null;
  43
  44         /**
  45          * @var string[]|null
  46          */
  47         private $existingPropNames = null;
  48
  49         /**
  50          * @var int|null
  51          */
  52         private $ns;
  53
  54         /**
  55          * @var bool
  56          */
  57         private $reverse = false;
  58
  59         /**
  60          * @var bool
  61          */
  62         private $sortByValue = false;
  63
  64         public function __construct( IConnectionProvider $dbProvider ) {
  65                 parent::__construct( 'PagesWithProp' );
  66                 $this->setDatabaseProvider( $dbProvider );
  67         }
  68
  69         public function isCacheable() {
  70                 return false;
  71         }
  72
  73         public function execute( $par ) {
  74                 $this->setHeaders();
  75                 $this->outputHeader();
  76                 $this->getOutput()->addModuleStyles( 'mediawiki.special' );
  77
  78                 $request = $this->getRequest();
  79                 $propname = $request->getVal( 'propname', $par );
  80                 $this->ns = $request->getIntOrNull( 'namespace' );
  81                 $this->reverse = $request->getBool( 'reverse' );
  82                 $this->sortByValue = $request->getBool( 'sortbyvalue' );
  83
  84                 $propnames = $this->getExistingPropNames();
  85
  86                 $fields = [
  87                         'propname' => [
  88                                 'type' => 'combobox',
  89                                 'name' => 'propname',
  90                                 'options' => $propnames,
  91                                 'default' => $propname,
  92                                 'label-message' => 'pageswithprop-prop',
  93                                 'required' => true,
  94                         ],
  95                         'namespace' => [
  96                                 'type' => 'namespaceselect',
  97                                 'name' => 'namespace',
  98                                 'label-message' => 'namespace',
  99                                 'all' => '',
 100                                 'default' => $this->ns,
 101                         ],
 102                         'reverse' => [
 103                                 'type' => 'check',
 104                                 'name' => 'reverse',
 105                                 'default' => $this->reverse,
 106                                 'label-message' => 'pageswithprop-reverse',
 107                                 'required' => false,
 108                         ],
 109                         'sortbyvalue' => [
 110                                 'type' => 'check',
 111                                 'name' => 'sortbyvalue',
 112                                 'default' => $this->sortByValue,
 113                                 'label-message' => 'pageswithprop-sortbyvalue',
 114                                 'required' => false,
 115                         ]
 116                 ];
 117
 118                 $form = HTMLForm::factory( 'ooui', $fields, $this->getContext() )
 119                         ->setMethod( 'get' )
 120                         ->setTitle( $this->getPageTitle() ) // Remove subpage
 121                         ->setSubmitCallback( [ $this, 'onSubmit' ] )
 122                         ->setWrapperLegendMsg( 'pageswithprop-legend' )
 123                         ->addHeaderHtml( $this->msg( 'pageswithprop-text' )->parseAsBlock() )
 124                         ->setSubmitTextMsg( 'pageswithprop-submit' )
 125                         ->prepareForm();
 126                 $form->displayForm( false );
 127                 if ( $propname !== '' && $propname !== null ) {
 128                         $form->trySubmit();
 129                 }
 130         }
 131
 132         public function onSubmit( $data, $form ) {
 133                 $this->propName = $data['propname'];
 134                 parent::execute( $data['propname'] );
 135         }
 136
 137         /**
 138          * Return an array of subpages beginning with $search that this special page will accept.
 139          *
 140          * @param string $search Prefix to search for
 141          * @param int $limit Maximum number of results to return
 142          * @param int $offset Number of pages to skip
 143          * @return string[] Matching subpages
 144          */
 145         public function prefixSearchSubpages( $search, $limit, $offset ) {
 146                 $subpages = array_keys( $this->queryExistingProps( $limit, $offset ) );
 147                 // We've already limited and offsetted, set to N and 0 respectively.
 148                 return self::prefixSearchArray( $search, count( $subpages ), $subpages, 0 );
 149         }
 150
 151         /**
 152          * Disable RSS/Atom feeds
 153          * @return bool
 154          */
 155         public function isSyndicated() {
 156                 return false;
 157         }
 158
 159         /**
 160          * @inheritDoc
 161          */
 162         protected function linkParameters() {
 163                 $params = [
 164                         'reverse' => $this->reverse,
 165                         'sortbyvalue' => $this->sortByValue,
 166                 ];
 167                 if ( $this->ns !== null ) {
 168                         $params['namespace'] = $this->ns;
 169                 }
 170                 return $params;
 171         }
 172
 173         public function getQueryInfo() {
 174                 $query = [
 175                         'tables' => [ 'page_props', 'page' ],
 176                         'fields' => [
 177                                 'page_id' => 'pp_page',
 178                                 'page_namespace',
 179                                 'page_title',
 180                                 'page_len',
 181                                 'page_is_redirect',
 182                                 'page_latest',
 183                                 'pp_value',
 184                         ],
 185                         'conds' => [
 186                                 'pp_propname' => $this->propName,
 187                         ],
 188                         'join_conds' => [
 189                                 'page' => [ 'JOIN', 'page_id = pp_page' ]
 190                         ],
 191                         'options' => []
 192                 ];
 193
 194                 if ( $this->ns !== null ) {
 195                         $query['conds']['page_namespace'] = $this->ns;
 196                 }
 197
 198                 return $query;
 199         }
 200
 201         protected function getOrderFields() {
 202                 $sort = [ 'page_id' ];
 203                 if ( $this->sortByValue ) {
 204                         array_unshift( $sort, 'pp_sortkey' );
 205                 }
 206                 return $sort;
 207         }
 208
 209         /**
 210          * @return bool
 211          */
 212         public function sortDescending() {
 213                 return !$this->reverse;
 214         }
 215
 216         /**
 217          * @param Skin $skin
 218          * @param stdClass $result Result row
 219          * @return string
 220          */
 221         public function formatResult( $skin, $result ) {
 222                 $title = Title::newFromRow( $result );
 223                 $ret = $this->getLinkRenderer()->makeKnownLink( $title );
 224                 if ( $result->pp_value !== '' ) {
 225                         // Do not show very long or binary values on the special page
 226                         $valueLength = strlen( $result->pp_value );
 227                         $isBinary = str_contains( $result->pp_value, "\0" );
 228                         $isTooLong = $valueLength > 1024;
 229
 230                         if ( $isBinary || $isTooLong ) {
 231                                 $message = $this
 232                                         ->msg( $isBinary ? 'pageswithprop-prophidden-binary' : 'pageswithprop-prophidden-long' )
 233                                         ->sizeParams( $valueLength );
 234
 235                                 $propValue = Html::element( 'span', [ 'class' => 'prop-value-hidden' ], $message->text() );
 236                         } else {
 237                                 $propValue = Html::element( 'span', [ 'class' => 'prop-value' ], $result->pp_value );
 238                         }
 239
 240                         $ret .= $this->msg( 'colon-separator' )->escaped() . $propValue;
 241                 }
 242
 243                 return $ret;
 244         }
 245
 246         public function getExistingPropNames() {
 247                 if ( $this->existingPropNames === null ) {
 248                         $this->existingPropNames = $this->queryExistingProps();
 249                 }
 250                 return $this->existingPropNames;
 251         }
 252
 253         protected function queryExistingProps( $limit = null, $offset = 0 ) {
 254                 $queryBuilder = $this->getDatabaseProvider()
 255                         ->getReplicaDatabase()
 256                         ->newSelectQueryBuilder()
 257                         ->select( 'pp_propname' )
 258                         ->distinct()
 259                         ->from( 'page_props' )
 260                         ->orderBy( 'pp_propname' );
 261
 262                 if ( $limit ) {
 263                         $queryBuilder->limit( $limit );
 264                 }
 265                 if ( $offset ) {
 266                         $queryBuilder->offset( $offset );
 267                 }
 268                 $res = $queryBuilder->caller( __METHOD__ )->fetchResultSet();
 269
 270                 $propnames = [];
 271                 foreach ( $res as $row ) {
 272                         $propnames[$row->pp_propname] = $row->pp_propname;
 273                 }
 274
 275                 return $propnames;
 276         }
 277
 278         protected function getGroupName() {
 279                 return 'pages';
 280         }
 281 }
 282
 283 /**
 284  * Retain the old class name for backwards compatibility.
 285  * @deprecated since 1.41
 286  */
 287 class_alias( SpecialPagesWithProp::class, 'SpecialPagesWithProp' );