Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
0.00% covered (danger)
0.00%
0 / 209
0.00% covered (danger)
0.00%
0 / 8
CRAP
0.00% covered (danger)
0.00%
0 / 1
UserOptionsMaintenance
0.00% covered (danger)
0.00%
0 / 206
0.00% covered (danger)
0.00%
0 / 8
2970
0.00% covered (danger)
0.00%
0 / 1
 __construct
0.00% covered (danger)
0.00%
0 / 22
0.00% covered (danger)
0.00%
0 / 1
2
 execute
0.00% covered (danger)
0.00%
0 / 13
0.00% covered (danger)
0.00%
0 / 1
72
 listAvailableOptions
0.00% covered (danger)
0.00%
0 / 8
0.00% covered (danger)
0.00%
0 / 1
12
 showUsageStats
0.00% covered (danger)
0.00%
0 / 26
0.00% covered (danger)
0.00%
0 / 1
90
 updateOptions
0.00% covered (danger)
0.00%
0 / 54
0.00% covered (danger)
0.00%
0 / 1
182
 deleteOptions
0.00% covered (danger)
0.00%
0 / 46
0.00% covered (danger)
0.00%
0 / 1
156
 deleteDefaults
0.00% covered (danger)
0.00%
0 / 33
0.00% covered (danger)
0.00%
0 / 1
42
 warn
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
1<?php
2/**
3 * Script to change users preferences on the fly.
4 *
5 * Made on an original idea by Fooey (freenode)
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20 * http://www.gnu.org/copyleft/gpl.html
21 *
22 * @file
23 * @ingroup Maintenance
24 * @author Antoine Musso <hashar at free dot fr>
25 */
26
27use MediaWiki\User\User;
28use MediaWiki\User\UserIdentityValue;
29use Wikimedia\Rdbms\IExpression;
30use Wikimedia\Rdbms\SelectQueryBuilder;
31
32require_once __DIR__ . '/Maintenance.php';
33
34/**
35 * @ingroup Maintenance
36 */
37class UserOptionsMaintenance extends Maintenance {
38
39    public function __construct() {
40        parent::__construct();
41
42        $this->addDescription( 'Pass through all users and change or delete one of their options.
43The new option is NOT validated.' );
44
45        $this->addOption( 'list', 'List available user options and their default value' );
46        $this->addOption( 'usage', 'Report all options statistics or just one if you specify it' );
47        $this->addOption(
48            'old',
49            'The value to look for. If it is a default value for the option, pass --old-is-default as well.',
50            false, true
51        );
52        $this->addOption( 'old-is-default', 'If passed, --old is interpreted as a default value.' );
53        $this->addOption( 'new', 'New value to update users with', false, true );
54        $this->addOption( 'delete', 'Delete the option instead of updating' );
55        $this->addOption( 'delete-defaults', 'Delete user_properties row matching the default' );
56        $this->addOption( 'fromuserid', 'Start from this user ID when changing/deleting options',
57            false, true );
58        $this->addOption( 'touserid', 'Do not go beyond this user ID when changing/deleting options',
59            false, true );
60        $this->addOption( 'nowarn', 'Hides the 5 seconds warning' );
61        $this->addOption( 'dry', 'Do not save user settings back to database' );
62        $this->addArg( 'option name', 'Name of the option to change or provide statistics about', false );
63        $this->setBatchSize( 100 );
64    }
65
66    /**
67     * Do the actual work
68     */
69    public function execute() {
70        if ( $this->hasOption( 'list' ) ) {
71            $this->listAvailableOptions();
72        } elseif ( $this->hasOption( 'usage' ) ) {
73            $this->showUsageStats();
74        } elseif ( $this->hasOption( 'old' )
75            && $this->hasOption( 'new' )
76            && $this->hasArg( 0 )
77        ) {
78            $this->updateOptions();
79        } elseif ( $this->hasOption( 'delete' ) ) {
80            $this->deleteOptions();
81        } elseif ( $this->hasOption( 'delete-defaults' ) ) {
82            $this->deleteDefaults();
83        } else {
84            $this->maybeHelp( true );
85        }
86    }
87
88    /**
89     * List default options and their value
90     */
91    private function listAvailableOptions() {
92        $userOptionsLookup = $this->getServiceContainer()->getUserOptionsLookup();
93        $def = $userOptionsLookup->getDefaultOptions( null );
94        ksort( $def );
95        $maxOpt = 0;
96        foreach ( $def as $opt => $value ) {
97            $maxOpt = max( $maxOpt, strlen( $opt ) );
98        }
99        foreach ( $def as $opt => $value ) {
100            $this->output( sprintf( "%-{$maxOpt}s: %s\n", $opt, $value ) );
101        }
102    }
103
104    /**
105     * List options usage
106     */
107    private function showUsageStats() {
108        $option = $this->getArg( 0 );
109
110        $ret = [];
111        $userOptionsLookup = $this->getServiceContainer()->getUserOptionsLookup();
112        $defaultOptions = $userOptionsLookup->getDefaultOptions();
113
114        // We list user by user_id from one of the replica DBs
115        $dbr = $this->getServiceContainer()->getConnectionProvider()->getReplicaDatabase();
116
117        $result = $dbr->newSelectQueryBuilder()
118            ->select( [ 'user_id' ] )
119            ->from( 'user' )
120            ->caller( __METHOD__ )->fetchResultSet();
121
122        foreach ( $result as $id ) {
123            $user = User::newFromId( $id->user_id );
124
125            // Get the options and update stats
126            if ( $option ) {
127                if ( !array_key_exists( $option, $defaultOptions ) ) {
128                    $this->fatalError( "Invalid user option. Use --list to see valid choices\n" );
129                }
130
131                $userValue = $userOptionsLookup->getOption( $user, $option );
132                if ( $userValue != $defaultOptions[$option] ) {
133                    $ret[$option][$userValue] = ( $ret[$option][$userValue] ?? 0 ) + 1;
134                }
135            } else {
136                foreach ( $defaultOptions as $name => $defaultValue ) {
137                    $userValue = $userOptionsLookup->getOption( $user, $name );
138                    if ( $userValue != $defaultValue ) {
139                        $ret[$name][$userValue] = ( $ret[$name][$userValue] ?? 0 ) + 1;
140                    }
141                }
142            }
143        }
144
145        foreach ( $ret as $optionName => $usageStats ) {
146            $this->output( "Usage for <$optionName> (default: '{$defaultOptions[$optionName]}'):\n" );
147            foreach ( $usageStats as $value => $count ) {
148                $this->output( " $count user(s): '$value'\n" );
149            }
150            print "\n";
151        }
152    }
153
154    /**
155     * Change our users options
156     */
157    private function updateOptions() {
158        $dryRun = $this->hasOption( 'dry' );
159        $settingWord = $dryRun ? 'Would set' : 'Setting';
160        $option = $this->getArg( 0 );
161        $fromIsDefault = $this->hasOption( 'old-is-default' );
162        $from = $this->getOption( 'old' );
163        $to = $this->getOption( 'new' );
164
165        // The fromuserid parameter is inclusive, but iterating is easier with an exclusive
166        // range so convert it.
167        $fromUserId = (int)$this->getOption( 'fromuserid', 1 ) - 1;
168        $toUserId = (int)$this->getOption( 'touserid', 0 ) ?: null;
169
170        if ( !$dryRun ) {
171            $forUsers = ( $fromUserId || $toUserId ) ? "some users (ID $fromUserId-$toUserId)" : 'ALL USERS';
172            $this->warn(
173                <<<WARN
174The script is about to change the options for $forUsers in the database.
175Users with option <$option> = '$from' will be made to use '$to'.
176
177Abort with control-c in the next five seconds....
178WARN
179            );
180        }
181
182        $userOptionsManager = $this->getServiceContainer()->getUserOptionsManager();
183        $tempUserConfig = $this->getServiceContainer()->getTempUserConfig();
184        $dbr = $this->getReplicaDB();
185        $queryBuilderTemplate = $dbr->newSelectQueryBuilder()
186            ->table( 'user' )
187            ->leftJoin( 'user_properties', null, [
188                'user_id = up_user',
189                'up_property' => $option,
190            ] )
191            ->fields( [ 'user_id', 'user_name' ] )
192            // up_value is unindexed so this can be slow, but should be acceptable in a script
193            ->where( [ 'up_value' => $fromIsDefault ? null : $from ] )
194            // need to order by ID so we can use ID ranges for query continuation
195            // also needed for the fromuserid / touserid parameters to work
196            ->orderBy( 'user_id', SelectQueryBuilder::SORT_ASC )
197            ->limit( $this->getBatchSize() )
198            ->caller( __METHOD__ );
199        if ( $toUserId ) {
200            $queryBuilderTemplate->andWhere( $dbr->expr( 'user_id', '<=', $toUserId ) );
201        }
202
203        if ( $tempUserConfig->isKnown() ) {
204            $queryBuilderTemplate->andWhere(
205                $tempUserConfig->getMatchCondition( $dbr, 'user_name', IExpression::NOT_LIKE )
206            );
207        }
208
209        do {
210            $queryBuilder = clone $queryBuilderTemplate;
211            $queryBuilder->andWhere( $dbr->expr( 'user_id', '>', $fromUserId ) );
212            $result = $queryBuilder->fetchResultSet();
213            foreach ( $result as $row ) {
214                $fromUserId = (int)$row->user_id;
215
216                $user = UserIdentityValue::newRegistered( $row->user_id, $row->user_name );
217                if ( $fromIsDefault ) {
218                    // $user has the default value for $option; skip if it doesn't match
219                    // NOTE: This is intentionally a loose comparison. $from is always a string
220                    // (coming from the command line), but the default value might be of a
221                    // different type.
222                    if ( $from != $userOptionsManager->getDefaultOption( $option, $user ) ) {
223                        continue;
224                    }
225                }
226
227                $this->output( "$settingWord {$option} for {$row->user_name} from '{$from}' to '{$to}'\n" );
228                if ( !$dryRun ) {
229                    $userOptionsManager->setOption( $user, $option, $to );
230                    $userOptionsManager->saveOptions( $user );
231                }
232            }
233            $this->waitForReplication();
234        } while ( $result->numRows() );
235    }
236
237    /**
238     * Delete occurrences of the option (with the given value, if provided)
239     */
240    private function deleteOptions() {
241        $dryRun = $this->hasOption( 'dry' );
242        $option = $this->getArg( 0 );
243        $fromUserId = (int)$this->getOption( 'fromuserid', 0 );
244        $toUserId = (int)$this->getOption( 'touserid', 0 ) ?: null;
245        $old = $this->getOption( 'old' );
246
247        if ( !$dryRun ) {
248            $forUsers = ( $fromUserId || $toUserId ) ? "some users (ID $fromUserId-$toUserId)" : 'ALL USERS';
249            $this->warn( <<<WARN
250The script is about to delete '$option' option for $forUsers from user_properties table.
251This action is IRREVERSIBLE.
252
253Abort with control-c in the next five seconds....
254WARN
255            );
256        }
257
258        $dbr = $this->getReplicaDB();
259        $dbw = $this->getPrimaryDB();
260
261        $rowsNum = 0;
262        $rowsInThisBatch = -1;
263        $minUserId = $fromUserId;
264        while ( $rowsInThisBatch != 0 ) {
265            $queryBuilder = $dbr->newSelectQueryBuilder()
266                ->select( 'up_user' )
267                ->from( 'user_properties' )
268                ->where( [ 'up_property' => $option, $dbr->expr( 'up_user', '>', $minUserId ) ] );
269            if ( $this->hasOption( 'touserid' ) ) {
270                $queryBuilder->andWhere( $dbr->expr( 'up_user', '<', $toUserId ) );
271            }
272            if ( $this->hasOption( 'old' ) ) {
273                $queryBuilder->andWhere( [ 'up_value' => $old ] );
274            }
275            // need to order by ID so we can use ID ranges for query continuation
276            $queryBuilder
277                ->orderBy( 'up_user', SelectQueryBuilder::SORT_ASC )
278                ->limit( $this->getBatchSize() );
279
280            $userIds = $queryBuilder->caller( __METHOD__ )->fetchFieldValues();
281            if ( $userIds === [] ) {
282                // no rows left
283                break;
284            }
285
286            if ( !$dryRun ) {
287                $delete = $dbw->newDeleteQueryBuilder()
288                    ->deleteFrom( 'user_properties' )
289                    ->where( [ 'up_property' => $option, 'up_user' => $userIds ] );
290                if ( $this->hasOption( 'old' ) ) {
291                    $delete->andWhere( [ 'up_value' => $old ] );
292                }
293                $delete->caller( __METHOD__ )->execute();
294                $rowsInThisBatch = $dbw->affectedRows();
295            } else {
296                $rowsInThisBatch = count( $userIds );
297            }
298
299            $this->waitForReplication();
300            $rowsNum += $rowsInThisBatch;
301            $minUserId = max( $userIds );
302        }
303
304        if ( !$dryRun ) {
305            $this->output( "Done! Deleted $rowsNum rows.\n" );
306        } else {
307            $this->output( "Would delete $rowsNum rows.\n" );
308        }
309    }
310
311    private function deleteDefaults() {
312        $dryRun = $this->hasOption( 'dry' );
313        $option = $this->getArg( 0 );
314        $fromUserId = (int)$this->getOption( 'fromuserid', 0 );
315        $toUserId = (int)$this->getOption( 'touserid', 0 ) ?: null;
316
317        if ( $option === null ) {
318            $this->fatalError( "Option name is required" );
319        }
320
321        if ( !$dryRun ) {
322            $this->warn( <<<WARN
323This script is about to delete all rows in user_properties that match the current
324defaults for the user (including conditional defaults).
325This action is IRREVERSIBLE.
326
327Abort with control-c in the next five seconds....
328WARN
329            );
330        }
331
332        $dbr = $this->getDB( DB_REPLICA );
333        $dbw = $this->getDB( DB_PRIMARY );
334
335        $queryBuilderTemplate = $dbr->newSelectQueryBuilder()
336            ->select( [ 'user_id', 'user_name', 'up_value' ] )
337            ->from( 'user_properties' )
338            ->join( 'user', null, [ 'up_user = user_id' ] )
339            ->where( [ 'up_property' => $option ] )
340            ->limit( $this->getBatchSize() )
341            ->caller( __METHOD__ );
342
343        if ( $toUserId !== null ) {
344            $queryBuilderTemplate->andWhere( $dbr->expr( 'up_user', '<=', $toUserId ) );
345        }
346
347        $userOptionsManager = $this->getServiceContainer()->getUserOptionsManager();
348        do {
349            $queryBuilder = clone $queryBuilderTemplate;
350            $queryBuilder->andWhere( $dbr->expr( 'up_user', '>', $fromUserId ) );
351            $result = $queryBuilder->fetchResultSet();
352            foreach ( $result as $row ) {
353                $fromUserId = (int)$row->user_id;
354
355                // NOTE: If up_value equals to the default, this will drop the row. Otherwise, it
356                // is going to be a no-op.
357                $user = UserIdentityValue::newRegistered( $row->user_id, $row->user_name );
358                $userOptionsManager->setOption( $user, $option, $row->up_value );
359                $userOptionsManager->saveOptions( $user );
360            }
361            $this->waitForReplication();
362        } while ( $result->numRows() );
363
364        $this->output( "Done!\n" );
365    }
366
367    /**
368     * The warning message and countdown
369     *
370     * @param string $message
371     */
372    private function warn( string $message ) {
373        if ( $this->hasOption( 'nowarn' ) ) {
374            return;
375        }
376
377        $this->output( $message );
378        $this->countDown( 5 );
379    }
380}
381
382$maintClass = UserOptionsMaintenance::class;
383require_once RUN_MAINTENANCE_IF_MAIN;