| blob | b6a7ca8de6c50c8061eb2b978fcaf5f5eb50818d |
1 <?php
2 /**
3 *
4 *
5 * Created on Sep 5, 2006
6 *
7 * Copyright © 2006, 2010 Yuri Astrakhan "<Firstname><Lastname>@gmail.com"
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write to the Free Software Foundation, Inc.,
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22 * http://www.gnu.org/copyleft/gpl.html
23 *
24 * @file
25 */
27 /**
28 * This abstract class implements many basic API functions, and is the base of
29 * all API classes.
30 * The class functions are divided into several areas of functionality:
31 *
32 * Module parameters: Derived classes can define getAllowedParams() to specify
33 * which parameters to expect, how to parse and validate them.
34 *
35 * Profiling: various methods to allow keeping tabs on various tasks and their
36 * time costs
37 *
38 * Self-documentation: code to allow the API to document its own state
39 *
40 * @ingroup API
41 */
43 // These constants allow modules to specify exactly how to treat incoming parameters.
45 // Default value of the parameter
47 // Boolean, do we accept more than one item for this parameter (e.g.: titles)?
49 // Can be either a string type (e.g.: 'integer') or an array of allowed values
51 // Max value allowed for a parameter. Only applies if TYPE='integer'
53 // Max value allowed for a parameter for bots and sysops. Only applies if TYPE='integer'
55 // Lowest value allowed for a parameter. Only applies if TYPE='integer'
57 // Boolean, do we allow the same value to be set more than once when ISMULTI=true
59 // Boolean, is the parameter deprecated (will show a warning)
61 /// @since 1.17
63 /// @since 1.17
64 // Boolean, if MIN/MAX are set, enforce (die) these?
65 // Only applies if TYPE='integer' Use with extreme caution
68 // Name of property group that is on the root element of the result,
69 // i.e. not part of a list
71 // Boolean, is the result multiple items? Defaults to true for query modules,
72 // to false for other modules
75 // Boolean, can the property be not included in the result? Defaults to false
83 /**
84 * getAllowedParams() flag: When set, the result could take longer to generate,
85 * but should be more thorough. E.g. get the list of generators for ApiSandBox extension
86 * @since 1.21
87 */
94 /**
95 * Constructor
96 * @param $mainModule ApiMain object
97 * @param string $moduleName Name of this module
98 * @param string $modulePrefix Prefix to use for parameter names
99 */
107 }
108 }
110 /*****************************************************************************
111 * ABSTRACT METHODS *
112 *****************************************************************************/
114 /**
115 * Evaluates the parameters, performs the requested query, and sets up
116 * the result. Concrete implementations of ApiBase must override this
117 * method to provide whatever functionality their module offers.
118 * Implementations must not produce any output on their own and are not
119 * expected to handle any errors.
120 *
121 * The execute() method will be invoked directly by ApiMain immediately
122 * before the result of the module is output. Aside from the
123 * constructor, implementations should assume that no other methods
124 * will be called externally on the module before the result is
125 * processed.
126 *
127 * The result data should be stored in the ApiResult object available
128 * through getResult().
129 */
132 /**
133 * Returns a string that identifies the version of the extending class.
134 * Typically includes the class name, the svn revision, timestamp, and
135 * last author. Usually done with SVN's Id keyword
136 * @return string
137 * @deprecated since 1.21, version string is no longer supported
138 */
143 }
145 /**
146 * Get the name of the module being executed by this instance
147 * @return string
148 */
151 }
153 /**
154 * Get the module manager, or null if this module has no sub-modules
155 * @since 1.21
156 * @return ApiModuleManager
157 */
160 }
162 /**
163 * Get parameter prefix (usually two letters or an empty string).
164 * @return string
165 */
168 }
170 /**
171 * Get the name of the module as shown in the profiler log
172 *
173 * @param $db DatabaseBase|bool
174 *
175 * @return string
176 */
180 }
183 }
185 /**
186 * Get the main module
187 * @return ApiMain object
188 */
191 }
193 /**
194 * Returns true if this module is the main module ($this === $this->mMainModule),
195 * false otherwise.
196 * @return bool
197 */
200 }
202 /**
203 * Get the result object
204 * @return ApiResult
205 */
207 // Main module has getResult() method overridden
208 // Safety - avoid infinite loop:
211 }
214 }
216 /**
217 * Get the result data array (read-only)
218 * @return array
219 */
222 }
224 /**
225 * Create a new RequestContext object to use e.g. for calls to other parts
226 * the software.
227 * The object will have the WebRequest and the User object set to the ones
228 * used in this instance.
229 *
230 * @deprecated since 1.19 use getContext to get the current context
231 * @return DerivativeContext
232 */
237 }
239 /**
240 * Set warning section for this module. Users should monitor this
241 * section to notice any changes in API. Multiple calls to this
242 * function will result in the warning messages being separated by
243 * newlines
244 * @param string $warning Warning message
245 */
251 // Don't add duplicate warnings
254 // If $warning was found in $oldWarning, check if it starts at 0 or after "\n"
256 // Check if $warning is followed by "\n" or the end of the $oldWarning
260 }
261 }
262 // If there is a warning already, append it to the existing one
264 }
271 }
273 /**
274 * If the module may only be used with a certain format module,
275 * it should override this method to return an instance of that formatter.
276 * A value of null means the default format will be used.
277 * @return mixed instance of a derived class of ApiFormatBase, or null
278 */
281 }
283 /**
284 * Generates help message for this module, or false if there is no description
285 * @return mixed string or false
286 */
296 $msg
297 );
298 }
305 }
308 }
311 }
314 ) {
316 }
318 // Parameters
322 }
328 $examples
329 );
330 }
340 }
343 }
344 }
345 }
346 }
349 }
351 /**
352 * @param $item string
353 * @return string
354 */
357 }
359 /**
360 * @param string $prefix Text to split output items
361 * @param string $title What is being output
362 * @param $input string|array
363 * @return string
364 */
368 }
371 }
378 }
382 }
385 }
387 /**
388 * Generates the parameter descriptions for this module, to be displayed in the
389 * module's help.
390 * @return string or false
391 */
404 }
406 //handle shorthand
410 );
411 }
413 //handle missing type
424 }
425 }
429 ) {
431 }
435 ) {
437 }
451 }
461 }
462 }
470 // Special handling because namespaces are
471 // type-limited, yet they are not given
481 }
498 }
501 }
506 }
507 }
512 }
517 ) {
520 }
521 }
522 }
527 }
530 }
533 }
536 }
538 /**
539 * Returns the description string for this module
540 * @return mixed string or array of strings
541 */
544 }
546 /**
547 * Returns usage examples for this module. Return false if no examples are available.
548 * @return bool|string|array
549 */
552 }
554 /**
555 * Returns an array of allowed parameters (parameter name) => (default
556 * value) or (parameter name) => (array with PARAM_* constants as keys)
557 * Don't call this function directly: use getFinalParams() to allow
558 * hooks to modify parameters as needed.
559 *
560 * Some derived classes may choose to handle an integer $flags parameter
561 * in the overriding methods. Callers of this method can pass zero or
562 * more OR-ed flags like GET_VALUES_FOR_HELP.
563 *
564 * @return array|bool
565 */
567 // int $flags is not declared because it causes "Strict standards"
568 // warning. Most derived classes do not implement it.
570 }
572 /**
573 * Returns an array of parameter descriptions.
574 * Don't call this function directly: use getFinalParamDescription() to
575 * allow hooks to modify descriptions as needed.
576 * @return array|bool False on no parameter descriptions
577 */
580 }
582 /**
583 * Get final list of parameters, after hooks have had a chance to
584 * tweak it as needed.
585 *
586 * @param int $flags Zero or more flags like GET_VALUES_FOR_HELP
587 * @return array|Bool False on no parameters
588 * @since 1.21 $flags param added
589 */
595 }
597 /**
598 * Get final parameter descriptions, after hooks have had a chance to tweak it as
599 * needed.
600 *
601 * @return array|bool False on no parameter descriptions
602 */
608 }
610 /**
611 * Returns possible properties in the result, grouped by the value of the prop parameter
612 * that shows them.
613 *
614 * Properties that are shown always are in a group with empty string as a key.
615 * Properties that can be shown by several values of prop are included multiple times.
616 * If some properties are part of a list and some are on the root object (see ApiQueryQueryPage),
617 * those on the root object are under the key PROP_ROOT.
618 * The array can also contain a boolean under the key PROP_LIST,
619 * indicating whether the result is a list.
620 *
621 * Don't call this function directly: use getFinalResultProperties() to
622 * allow hooks to modify descriptions as needed.
623 *
624 * @return array|bool False on no properties
625 */
628 }
630 /**
631 * Get final possible result properties, after hooks have had a chance to tweak it as
632 * needed.
633 *
634 * @return array
635 */
641 }
643 /**
644 * Add token properties to the array used by getResultProperties,
645 * based on a token functions mapping.
646 */
652 );
653 }
654 }
656 /**
657 * Get final module description, after hooks have had a chance to tweak it as
658 * needed.
659 *
660 * @return array|bool False on no parameters
661 */
667 }
669 /**
670 * This method mangles parameter name based on the prefix supplied to the constructor.
671 * Override this method to change parameter name during runtime
672 * @param string $paramName Parameter name
673 * @return string Prefixed parameter name
674 */
677 }
679 /**
680 * Using getAllowedParams(), this function makes an array of the values
681 * provided by the user, with key being the name of the variable, and
682 * value - validated value from user or default. limits will not be
683 * parsed if $parseLimit is set to false; use this when the max
684 * limit is not definitive yet, e.g. when getting revisions.
685 * @param $parseLimit Boolean: true by default
686 * @return array
687 */
689 // Cache parameters, for performance and to avoid bug 24564.
698 }
699 }
701 }
704 }
706 /**
707 * Get a value for the given parameter
708 * @param string $paramName Parameter name
709 * @param bool $parseLimit see extractRequestParams()
710 * @return mixed Parameter value
711 */
717 }
719 /**
720 * Die if none or more than one of a certain set of parameters is set and not false.
721 * @param array $params of parameter names
722 */
738 'missingparam'
739 );
740 }
741 }
743 /**
744 * Generates the possible errors requireOnlyOneParameter() can die with
745 *
746 * @param $params array
747 * @return array
748 */
757 ),
761 )
762 );
763 }
765 /**
766 * Die if more than one of a certain set of parameters is set and not false.
767 *
768 * @param $params array
769 */
781 'invalidparammix'
782 );
783 }
784 }
786 /**
787 * Generates the possible error requireMaxOneParameter() can die with
788 *
789 * @param $params array
790 * @return array
791 */
800 )
801 );
802 }
804 /**
805 * @param $params array
806 * @param bool|string $load Whether load the object's state from the database:
807 * - false: don't load (if the pageid is given, it will still be loaded)
808 * - 'fromdb': load from a slave database
809 * - 'fromdbmaster': load from the master database
810 * @return WikiPage
811 */
820 }
823 }
827 }
831 }
835 }
836 }
839 }
841 /**
842 * @return array
843 */
850 )
851 );
852 }
854 /**
855 * Callback function used in requireOnlyOneParameter to check whether required parameters are set
856 *
857 * @param $x object Parameter to check is not null/false
858 * @return bool
859 */
862 }
864 /**
865 * @deprecated since 1.17 use MWNamespace::getValidNamespaces()
866 *
867 * @return array
868 */
873 }
875 /**
876 * Return true if we're to watch the page, false if not, null if no change.
877 * @param string $watchlist Valid values: 'watch', 'unwatch', 'preferences', 'nochange'
878 * @param $titleObj Title the page under consideration
879 * @param string $userOption The user option to consider when $watchlist=preferences.
880 * If not set will use watchdefault always and watchcreations if $titleObj doesn't exist.
881 * @return bool
882 */
895 # If the user is already watching, don't bother checking
898 }
899 # If no user option was passed, use watchdefault and watchcreations
903 }
905 # Watch the article based on the user preference
913 }
914 }
916 /**
917 * Set a watch (or unwatch) based the based on a watchlist parameter.
918 * @param string $watch Valid values: 'watch', 'unwatch', 'preferences', 'nochange'
919 * @param $titleObj Title the article's title to change
920 * @param string $userOption The user option to consider when $watch=preferences
921 */
926 }
929 }
931 /**
932 * Using the settings determine the value for the given parameter
933 *
934 * @param string $paramName parameter name
935 * @param array|mixed $paramSettings default value or an array of settings
936 * using PARAM_* constants.
937 * @param $parseLimit Boolean: parse limit?
938 * @return mixed Parameter value
939 */
941 // Some classes may decide to change parameter names
971 // When type is not given, and no choices, the type is the same as $default
977 }
978 }
979 }
983 // Having a default value of anything other than 'false' is not allowed
985 __METHOD__,
987 "Boolean parameters must default to false."
988 );
989 }
994 // Having a default value is not allowed
996 __METHOD__,
999 }
1002 }
1005 // This will get the value without trying to normalize it
1006 // (because trying to normalize a large binary file
1007 // accidentally uploaded as a field fails spectacularly)
1015 );
1016 }
1017 }
1023 }
1024 }
1032 );
1033 }
1035 // More validation only when choices were not given
1036 // choices were validated in parseMultiValue()
1045 }
1058 }
1059 }
1064 }
1065 }
1069 // Don't do any validation whatsoever
1071 }
1074 ) {
1076 __METHOD__,
1078 );
1079 }
1082 }
1097 );
1098 }
1103 }
1109 }
1112 }
1118 }
1121 }
1127 }
1128 }
1130 // Throw out duplicates if requested
1133 }
1135 // Set a warning if a deprecated parameter has been passed
1138 }
1141 }
1144 }
1146 /**
1147 * Return an array of values that were given in a 'a|b|c' notation,
1148 * after it optionally validates them against the list allowed values.
1149 *
1150 * @param string $valueName The name of the parameter (for error
1151 * reporting)
1152 * @param $value mixed The value being parsed
1153 * @param bool $allowMultiple Can $value contain more than one value
1154 * separated by '|'?
1155 * @param $allowedValues mixed An array of values to check against. If
1156 * null, all values are accepted.
1157 * @return mixed (allowMultiple ? an_array_of_values : a_single_value)
1158 */
1162 }
1164 // This is a bit awkward, but we want to avoid calling canApiHighLimits()
1165 // because it unstubs $wgUser
1168 ? self::LIMIT_SML2
1174 }
1177 // Bug 33482 - Allow entries with | in them for non-multiple values
1180 }
1188 );
1189 }
1192 // Check for unknown values
1203 );
1204 }
1205 }
1206 // Now throw them out
1208 }
1211 }
1213 /**
1214 * Validate the value against the minimum and user/bot maximum limits.
1215 * Prints usage info on failure.
1216 * @param string $paramName Parameter name
1217 * @param int $value Parameter value
1218 * @param int|null $min Minimum value
1219 * @param int|null $max Maximum value for users
1220 * @param int $botMax Maximum value for sysops/bots
1221 * @param $enforceLimits Boolean Whether to enforce (die) if value is outside limits
1222 */
1223 function validateLimit( $paramName, &$value, $min, $max, $botMax = null, $enforceLimits = false ) {
1229 }
1231 // Minimum is always validated, whereas maximum is checked only if not
1232 // running in internal call mode
1235 }
1237 // Optimization: do not check user's bot status unless really needed -- skips db query
1238 // assumes $botMax >= $max
1246 }
1248 $msg = $this->encodeParamName( $paramName ) . " may not be over $max (set to $value) for users";
1251 }
1252 }
1253 }
1255 /**
1256 * Validate and normalize of parameters of type 'timestamp'
1257 * @param string $value Parameter value
1258 * @param string $encParamName Parameter name
1259 * @return string Validated and normalized parameter
1260 */
1267 );
1268 }
1271 }
1273 /**
1274 * Validate and normalize of parameters of type 'user'
1275 * @param string $value Parameter value
1276 * @param string $encParamName Parameter name
1277 * @return string Validated and normalized parameter
1278 */
1285 );
1286 }
1289 }
1291 /**
1292 * Adds a warning to the output, else dies
1293 *
1294 * @param $msg String Message to show as a warning, or error message if dying
1295 * @param $enforceLimits Boolean Whether this is an enforce (die)
1296 */
1300 }
1303 }
1305 /**
1306 * Truncate an array to a certain length.
1307 * @param array $arr Array to truncate
1308 * @param int $limit Maximum length
1309 * @return bool True if the array was truncated, false otherwise
1310 */
1316 }
1319 }
1321 /**
1322 * Throw a UsageException, which will (if uncaught) call the main module's
1323 * error handler and die with an error message.
1324 *
1325 * @param string $description One-line human-readable description of the
1326 * error condition, e.g., "The API requires a valid action parameter"
1327 * @param string $errorCode Brief, arbitrary, stable string to allow easy
1328 * automated identification of the error, e.g., 'unknown_action'
1329 * @param int $httpRespCode HTTP response code
1330 * @param array $extradata Data to add to the "<error>" element; array in ApiResult format
1331 * @throws UsageException
1332 */
1339 $extradata
1340 );
1341 }
1343 /**
1344 * Throw a UsageException based on the errors in the Status object.
1345 *
1346 * @since 1.22
1347 * @param Status $status Status object
1348 * @throws MWException
1349 */
1353 }
1357 // No errors? Assume the warnings should be treated as errors
1359 }
1361 // Still no errors? Punt
1363 }
1365 // Cannot use dieUsageMsg() because extensions might return custom
1366 // error messages.
1373 }
1375 // Translate message to code, for backwards compatability
1377 }
1379 }
1381 // @codingStandardsIgnoreStart Allow long lines. Cannot split these.
1382 /**
1383 * Array that maps message keys to error messages. $1 and friends are replaced.
1384 */
1386 // This one MUST be present, or dieUsageMsg() will recurse infinitely
1390 // Messages from Title::getUserPermissionsErrors()
1394 ),
1398 ),
1402 ),
1406 ),
1410 ),
1413 'info' => "The page you're trying to edit is protected because it's included in a cascade-protected page"
1414 ),
1418 ),
1422 ),
1430 ),
1434 ),
1438 ),
1442 ),
1446 ),
1450 ),
1454 ),
1458 ),
1461 'info' => "Your IP address has been blocked automatically, because it was used by a blocked user"
1462 ),
1464 // Miscellaneous interface messages
1468 ),
1472 ),
1476 ),
1480 ),
1487 ),
1491 ),
1493 ),
1497 ),
1501 ),
1505 ),
1509 ),
1513 ),
1517 ),
1521 ),
1522 // 'badarticleerror' => shouldn't happen
1523 // 'badtitletext' => shouldn't happen
1528 ),
1532 ),
1538 ),
1541 'info' => "IP address \"\$1\" was blocked as part of range \"\$2\". You can't unblock the IP individually, but you can unblock the range as a whole."
1542 ),
1546 ),
1549 'info' => "You are not logged in, you do not have a confirmed email address, or you are not allowed to send email to other users, so you cannot send email"
1550 ),
1554 ),
1558 ),
1562 ),
1566 ),
1570 ),
1573 'info' => "The user has not specified a valid email address, or has chosen not to receive email from other users"
1574 ),
1578 ),
1582 ),
1586 ),
1590 ),
1594 ),
1598 ),
1605 ),
1609 ),
1611 // API-specific messages
1615 ),
1618 'info' => "Editing of this wiki through the API is disabled. Make sure the \$wgEnableWriteAPI=true; statement is included in the wiki's LocalSettings.php file"
1619 ),
1623 ),
1627 'nosuchrevid' => array( 'code' => 'nosuchrevid', 'info' => "There is no revision with ID \$1" ),
1630 'invalidexpiry' => array( 'code' => 'invalidexpiry', 'info' => "Invalid expiry time \"\$1\"" ),
1631 'pastexpiry' => array( 'code' => 'pastexpiry', 'info' => "Expiry time \"\$1\" is in the past" ),
1635 ),
1639 ),
1642 ),
1646 ),
1650 ),
1654 ),
1658 ),
1662 ),
1665 'info' => "Couldn't undelete: the requested revisions may not exist, or may have been undeleted already"
1666 ),
1670 ),
1674 ),
1678 ),
1682 ),
1686 ),
1690 ),
1694 ),
1698 ),
1702 ),
1707 ),
1711 ),
1715 ),
1719 ),
1723 ),
1727 ),
1731 ),
1734 'info' => 'The target file exists on a shared repository and you do not have permission to override it'
1735 ),
1738 'info' => 'The target file exists on a shared repository. Use the ignorewarnings parameter to override it.'
1739 ),
1743 ),
1747 ),
1751 ),
1755 ),
1759 ),
1763 ),
1766 'info' => 'A file with name "$1" already exists in the shared file repository, and cannot be overwritten.'
1767 ),
1771 ),
1773 // ApiEditPage messages
1777 ),
1781 ),
1785 ),
1789 ),
1790 'noedit-anon' => array( 'code' => 'noedit-anon', 'info' => "Anonymous users can't edit pages" ),
1795 ),
1799 ),
1801 'hashcheckfailed' => array( 'code' => 'badmd5', 'info' => "The supplied MD5 hash was incorrect" ),
1805 ),
1809 ),
1813 ),
1817 ),
1819 // Messages from WikiPage::doEit()
1823 ),
1827 ),
1832 ),
1834 // uploadMsgs
1839 'info' => 'Uploads are not enabled. Make sure $wgEnableUploads is set to true in LocalSettings.php and the PHP ini setting file_uploads is true'
1840 ),
1843 'info' => 'Uploads by URL is not enabled. Make sure $wgAllowCopyUploads is set to true in LocalSettings.php.'
1844 ),
1848 ),
1852 ),
1857 ),
1858 'filename-toolong' => array( 'code' => 'filename-toolong', 'info' => 'The filename is too long' ),
1862 ),
1866 ),
1868 'mustbeloggedin' => array( 'code' => 'mustbeloggedin', 'info' => 'You must be logged in to $1.' )
1869 );
1870 // @codingStandardsIgnoreEnd
1872 /**
1873 * Helper function for readonly errors
1874 */
1879 }
1881 /**
1882 * Output the error message related to a certain array
1883 * @param $error (array|string) Element of a getUserPermissionsErrors()-style array
1884 */
1886 # most of the time we send a 1 element, so we might as well send it as
1887 # a string and make this an array here.
1890 }
1893 }
1895 /**
1896 * Will only set a warning instead of failing if the global $wgDebugAPI
1897 * is set to true. Otherwise behaves exactly as dieUsageMsg().
1898 * @param $error (array|string) Element of a getUserPermissionsErrors()-style array
1899 * @since 1.21
1900 */
1905 }
1909 }
1913 }
1915 /**
1916 * Die with the $prefix.'badcontinue' error. This call is common enough to
1917 * make it into the base method.
1918 * @param $condition boolean will only die if this value is true
1919 * @since 1.21
1920 */
1926 }
1927 }
1929 /**
1930 * Return the error message related to a certain array
1931 * @param array $error Element of a getUserPermissionsErrors()-style array
1932 * @return array('code' => code, 'info' => info)
1933 */
1938 // Check whether the error array was nested
1939 // array( array( <code>, <params> ), array( <another_code>, <params> ) )
1943 }
1949 );
1950 }
1952 // If the key isn't present, throw an "unknown error"
1954 }
1956 /**
1957 * Internal code errors should be reported with this method
1958 * @param string $method Method or function name
1959 * @param string $message Error message
1960 * @throws MWException
1961 */
1964 }
1966 /**
1967 * Indicates if this module needs maxlag to be checked
1968 * @return bool
1969 */
1972 }
1974 /**
1975 * Indicates whether this module requires read rights
1976 * @return bool
1977 */
1980 }
1982 /**
1983 * Indicates whether this module requires write mode
1984 * @return bool
1985 */
1988 }
1990 /**
1991 * Indicates whether this module must be called with a POST request
1992 * @return bool
1993 */
1996 }
1998 /**
1999 * Returns whether this module requires a token to execute
2000 * It is used to show possible errors in action=paraminfo
2001 * see bug 25248
2002 * @return bool
2003 */
2006 }
2008 /**
2009 * Returns the token salt if there is one,
2010 * '' if the module doesn't require a salt,
2011 * else false if the module doesn't need a token
2012 * You have also to override needsToken()
2013 * Value is passed to User::getEditToken
2014 * @return bool|string|array
2015 */
2018 }
2020 /**
2021 * Gets the user for whom to get the watchlist
2022 *
2023 * @param $params array
2024 * @return User
2025 */
2031 }
2036 'bad_wltoken'
2037 );
2038 }
2042 }
2045 }
2047 }
2050 }
2052 /**
2053 * @return bool|string|array Returns a false if the module has no help URL,
2054 * else returns a (array of) string
2055 */
2058 }
2060 /**
2061 * Returns a list of all possible errors returned by the module
2062 *
2063 * Don't call this function directly: use getFinalPossibleErrors() to allow
2064 * hooks to modify parameters as needed.
2065 *
2066 * @return array in the format of array( key, param1, param2, ... )
2067 * or array( 'code' => ..., 'info' => ... )
2068 */
2077 ) {
2079 }
2080 }
2085 'original value returned by the previous query'
2086 );
2087 }
2088 }
2092 }
2096 }
2101 }
2106 ) {
2107 // Add token as possible missing parameter, if not already done
2109 }
2111 }
2114 }
2116 /**
2117 * Get final list of possible errors, after hooks have had a chance to
2118 * tweak it as needed.
2119 *
2120 * @return array
2121 * @since 1.22
2122 */
2128 }
2130 /**
2131 * Parses a list of errors into a standardised format
2132 * @param array $errors List of errors. Items can be in the for
2133 * array( key, param1, param2, ... ) or array( 'code' => ..., 'info' => ... )
2134 * @return array Parsed list of errors with items in the form array( 'code' => ..., 'info' => ... )
2135 */
2144 }
2145 }
2148 }
2150 /**
2151 * Profiling: total module execution time
2152 */
2155 /**
2156 * Start module profiling
2157 */
2161 }
2164 }
2166 /**
2167 * End module profiling
2168 */
2172 }
2175 __METHOD__,
2176 'Must be called after database profiling is done with profileDBOut()'
2177 );
2178 }
2183 }
2185 /**
2186 * When modules crash, sometimes it is needed to do a profileOut() regardless
2187 * of the profiling state the module was in. This method does such cleanup.
2188 */
2193 }
2195 }
2196 }
2198 /**
2199 * Total time the module was executed
2200 * @return float
2201 */
2205 }
2208 }
2210 /**
2211 * Profiling: database execution time
2212 */
2215 /**
2216 * Start module profiling
2217 */
2221 __METHOD__,
2222 'Must be called while profiling the entire module with profileIn()'
2223 );
2224 }
2227 }
2230 }
2232 /**
2233 * End database profiling
2234 */
2239 }
2242 }
2250 }
2252 /**
2253 * Total time the module used the database
2254 * @return float
2255 */
2259 }
2262 }
2264 /**
2265 * Gets a default slave database connection object
2266 * @return DatabaseBase
2267 */
2273 }
2276 }
2278 /**
2279 * Debugging function that prints a value and an optional backtrace
2280 * @param $value mixed Value to print
2281 * @param string $name Description of the printed value
2282 * @param bool $backtrace If true, print a backtrace
2283 */
2289 }
2291 }
2292 }