SpecialMediaStatistics.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Specials;
 
use MediaWiki\Cache\LinkBatchFactory;
use MediaWiki\Html\Html;
use MediaWiki\Output\OutputPage;
use MediaWiki\SpecialPage\QueryPage;
use MediaWiki\SpecialPage\SpecialPage;
use MimeAnalyzer;
use Skin;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\IReadableDatabase;
use Wikimedia\Rdbms\IResultWrapper;
 
class SpecialMediaStatistics extends QueryPage {
 
    public const MAX_LIMIT = 5000;
 
    protected int $totalCount = 0;
    protected int $totalBytes = 0;
 
    protected $totalPerType = 0;
 
    protected $countPerType = 0;
 
    protected $totalSize = 0;
 
    private MimeAnalyzer $mimeAnalyzer;
 
    public function __construct(
        MimeAnalyzer $mimeAnalyzer,
        IConnectionProvider $dbProvider,
        LinkBatchFactory $linkBatchFactory
    ) {
        parent::__construct( 'MediaStatistics' );
        // Generally speaking there is only a small number of file types,
        // so just show all of them.
        $this->limit = self::MAX_LIMIT;
        $this->shownavigation = false;
        $this->mimeAnalyzer = $mimeAnalyzer;
        $this->setDatabaseProvider( $dbProvider );
        $this->setLinkBatchFactory( $linkBatchFactory );
    }
 
    public function isExpensive() {
        return true;
    }
 
    public function getQueryInfo() {
        $dbr = $this->getDatabaseProvider()->getReplicaDatabase();
        $fakeTitle = $dbr->buildConcat( [
            'img_media_type',
            $dbr->addQuotes( ';' ),
            'img_major_mime',
            $dbr->addQuotes( '/' ),
            'img_minor_mime',
            $dbr->addQuotes( ';' ),
            $dbr->buildStringCast( 'COUNT(*)' ),
            $dbr->addQuotes( ';' ),
            $dbr->buildStringCast( 'SUM( img_size )' )
        ] );
        return [
            'tables' => [ 'image' ],
            'fields' => [
                'title' => $fakeTitle,
                'namespace' => NS_MEDIA, /* needs to be something */
                'value' => '1'
            ],
            'options' => [
                'GROUP BY' => [
                    'img_media_type',
                    'img_major_mime',
                    'img_minor_mime',
                ]
            ]
        ];
    }
 
    protected function getOrderFields() {
        return [ 'img_media_type', 'count(*)', 'img_major_mime', 'img_minor_mime' ];
    }
 
    protected function outputResults( $out, $skin, $dbr, $res, $num, $offset ) {
        $prevMediaType = null;
        foreach ( $res as $row ) {
            $mediaStats = $this->splitFakeTitle( $row->title );
            if ( count( $mediaStats ) < 4 ) {
                continue;
            }
            [ $mediaType, $mime, $totalCount, $totalBytes ] = $mediaStats;
            if ( $prevMediaType !== $mediaType ) {
                if ( $prevMediaType !== null ) {
                    // We're not at beginning, so we have to
                    // close the previous table.
                    $this->outputTableEnd();
                }
                $this->outputMediaType( $mediaType );
                $this->totalPerType = 0;
                $this->countPerType = 0;
                $this->outputTableStart( $mediaType );
                $prevMediaType = $mediaType;
            }
            $this->outputTableRow( $mime, intval( $totalCount ), intval( $totalBytes ) );
        }
        if ( $prevMediaType !== null ) {
            $this->outputTableEnd();
            // add total size of all files
            $this->outputMediaType( 'total' );
            $this->getOutput()->addWikiTextAsInterface(
                $this->msg( 'mediastatistics-allbytes' )
                    ->numParams( $this->totalSize )
                    ->sizeParams( $this->totalSize )
                    ->numParams( $this->totalCount )
                    ->text()
            );
        }
    }
 
    protected function outputTableEnd() {
        $this->getOutput()->addHTML(
            Html::closeElement( 'tbody' ) .
            Html::closeElement( 'table' )
        );
        $this->getOutput()->addWikiTextAsInterface(
                $this->msg( 'mediastatistics-bytespertype' )
                    ->numParams( $this->totalPerType )
                    ->sizeParams( $this->totalPerType )
                    ->numParams( $this->makePercentPretty( $this->totalPerType / $this->totalBytes ) )
                    ->numParams( $this->countPerType )
                    ->numParams( $this->makePercentPretty( $this->countPerType / $this->totalCount ) )
                    ->text()
        );
        $this->totalSize += $this->totalPerType;
    }
 
    protected function outputTableRow( $mime, $count, $bytes ) {
        $mimeSearch = SpecialPage::getTitleFor( 'MIMEsearch', $mime );
        $linkRenderer = $this->getLinkRenderer();
        $row = Html::rawElement(
            'td',
            [],
            $linkRenderer->makeLink( $mimeSearch, $mime )
        );
        $row .= Html::rawElement(
            'td',
            [],
            $this->getExtensionList( $mime )
        );
        $row .= Html::rawElement(
            'td',
            // Make sure js sorts it in numeric order
            [ 'data-sort-value' => $count ],
            $this->msg( 'mediastatistics-nfiles' )
                ->numParams( $count )
                ->numParams( $this->makePercentPretty( $count / $this->totalCount ) )
                ->parse()
        );
        $row .= Html::rawElement(
            'td',
            // Make sure js sorts it in numeric order
            [ 'data-sort-value' => $bytes ],
            $this->msg( 'mediastatistics-nbytes' )
                ->numParams( $bytes )
                ->sizeParams( $bytes )
                ->numParams( $this->makePercentPretty( $bytes / $this->totalBytes ) )
                ->parse()
        );
        $this->totalPerType += $bytes;
        $this->countPerType += $count;
        $this->getOutput()->addHTML( Html::rawElement( 'tr', [], $row ) );
    }
 
    protected function makePercentPretty( $decimal ) {
        $decimal *= 100;
        // Always show three useful digits
        if ( $decimal == 0 ) {
            return '0';
        }
        if ( $decimal >= 100 ) {
            return '100';
        }
        $percent = sprintf( "%." . max( 0, 2 - floor( log10( $decimal ) ) ) . "f", $decimal );
        // Then remove any trailing 0's
        return preg_replace( '/\.?0*$/', '', $percent );
    }
 
    private function getExtensionList( $mime ) {
        $exts = $this->mimeAnalyzer->getExtensionsFromMimeType( $mime );
        if ( !$exts ) {
            return '';
        }
        foreach ( $exts as &$ext ) {
            $ext = htmlspecialchars( '.' . $ext );
        }
 
        return $this->getLanguage()->commaList( $exts );
    }
 
    protected function outputTableStart( $mediaType ) {
        $out = $this->getOutput();
        $out->addModuleStyles( 'jquery.tablesorter.styles' );
        $out->addModules( 'jquery.tablesorter' );
        $out->addHTML(
            Html::openElement(
                'table',
                [ 'class' => [
                    'mw-mediastats-table',
                    'mw-mediastats-table-' . strtolower( $mediaType ),
                    'sortable',
                    'wikitable'
                ] ]
            ) .
            Html::rawElement( 'thead', [], $this->getTableHeaderRow() ) .
            Html::openElement( 'tbody' )
        );
    }
 
    protected function getTableHeaderRow() {
        $headers = [ 'mimetype', 'extensions', 'count', 'totalbytes' ];
        $ths = '';
        foreach ( $headers as $header ) {
            $ths .= Html::rawElement(
                'th',
                [],
                // for grep:
                // mediastatistics-table-mimetype, mediastatistics-table-extensions
                // mediastatistics-table-count, mediastatistics-table-totalbytes
                $this->msg( 'mediastatistics-table-' . $header )->parse()
            );
        }
        return Html::rawElement( 'tr', [], $ths );
    }
 
    protected function outputMediaType( $mediaType ) {
        $this->getOutput()->addHTML(
            Html::element(
                'h2',
                [ 'class' => [
                    'mw-mediastats-mediatype',
                    'mw-mediastats-mediatype-' . strtolower( $mediaType )
                ] ],
                // for grep
                // mediastatistics-header-unknown, mediastatistics-header-bitmap,
                // mediastatistics-header-drawing, mediastatistics-header-audio,
                // mediastatistics-header-video, mediastatistics-header-multimedia,
                // mediastatistics-header-office, mediastatistics-header-text,
                // mediastatistics-header-executable, mediastatistics-header-archive,
                // mediastatistics-header-3d,
                $this->msg( 'mediastatistics-header-' . strtolower( $mediaType ) )->text()
            )
        );
    }
 
    private function splitFakeTitle( $fakeTitle ) {
        return explode( ';', $fakeTitle, 4 );
    }
 
    protected function getGroupName() {
        return 'media';
    }
 
    public function formatResult( $skin, $result ) {
        return false;
    }
 
    public function preprocessResults( $dbr, $res ) {
        $this->executeLBFromResultWrapper( $res );
        $this->totalCount = $this->totalBytes = 0;
        foreach ( $res as $row ) {
            $mediaStats = $this->splitFakeTitle( $row->title );
            $this->totalCount += $mediaStats[2] ?? 0;
            $this->totalBytes += $mediaStats[3] ?? 0;
        }
        $res->seek( 0 );
    }
}
 
class_alias( SpecialMediaStatistics::class, 'SpecialMediaStatistics' );