| blob | e451f2a1b88d600150f54bf9e39babf3f4a6c8dc |
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 ApiMain $mainModule
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 DatabaseBase|bool $db
174 *
175 * @return string
176 */
180 }
183 }
185 /**
186 * Get the main module
187 * @return ApiMain
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 string|bool
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 string $item
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 string|array $input
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|bool
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 string|array
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 * @param array $props
647 * @param array $tokenFunctions
648 */
654 );
655 }
656 }
658 /**
659 * Get final module description, after hooks have had a chance to tweak it as
660 * needed.
661 *
662 * @return array|bool False on no parameters
663 */
669 }
671 /**
672 * This method mangles parameter name based on the prefix supplied to the constructor.
673 * Override this method to change parameter name during runtime
674 * @param string $paramName Parameter name
675 * @return string Prefixed parameter name
676 */
679 }
681 /**
682 * Using getAllowedParams(), this function makes an array of the values
683 * provided by the user, with key being the name of the variable, and
684 * value - validated value from user or default. limits will not be
685 * parsed if $parseLimit is set to false; use this when the max
686 * limit is not definitive yet, e.g. when getting revisions.
687 * @param bool $parseLimit True by default
688 * @return array
689 */
691 // Cache parameters, for performance and to avoid bug 24564.
700 }
701 }
703 }
706 }
708 /**
709 * Get a value for the given parameter
710 * @param string $paramName Parameter name
711 * @param bool $parseLimit See extractRequestParams()
712 * @return mixed Parameter value
713 */
719 }
721 /**
722 * Die if none or more than one of a certain set of parameters is set and not false.
723 * @param array $params Array of parameter names
724 */
740 'missingparam'
741 );
742 }
743 }
745 /**
746 * Generates the possible errors requireOnlyOneParameter() can die with
747 *
748 * @param array $params
749 * @return array
750 */
759 ),
763 )
764 );
765 }
767 /**
768 * Die if more than one of a certain set of parameters is set and not false.
769 *
770 * @param array $params
771 */
783 'invalidparammix'
784 );
785 }
786 }
788 /**
789 * Generates the possible error requireMaxOneParameter() can die with
790 *
791 * @param array $params
792 * @return array
793 */
802 )
803 );
804 }
806 /**
807 * Die if none of a certain set of parameters is set and not false.
808 *
809 * @since 1.23
810 * @param array $params User provided set of parameters
811 * @param string ... List of parameter names to check
812 */
820 $required
821 );
826 }
827 }
829 /**
830 * Generates the possible errors requireAtLeastOneParameter() can die with
831 *
832 * @since 1.23
833 * @param array $params Array of parameter key names
834 * @return array
835 */
844 ),
845 );
846 }
848 /**
849 * @param array $params
850 * @param bool|string $load Whether load the object's state from the database:
851 * - false: don't load (if the pageid is given, it will still be loaded)
852 * - 'fromdb': load from a slave database
853 * - 'fromdbmaster': load from the master database
854 * @return WikiPage
855 */
864 }
867 }
871 }
875 }
879 }
880 }
883 }
885 /**
886 * @return array
887 */
894 )
895 );
896 }
898 /**
899 * Callback function used in requireOnlyOneParameter to check whether required parameters are set
900 *
901 * @param object $x Parameter to check is not null/false
902 * @return bool
903 */
906 }
908 /**
909 * Return true if we're to watch the page, false if not, null if no change.
910 * @param string $watchlist Valid values: 'watch', 'unwatch', 'preferences', 'nochange'
911 * @param Title $titleObj The page under consideration
912 * @param string $userOption The user option to consider when $watchlist=preferences.
913 * If not set will use watchdefault always and watchcreations if $titleObj doesn't exist.
914 * @return bool
915 */
928 # If the user is already watching, don't bother checking
931 }
932 # If no user option was passed, use watchdefault and watchcreations
936 }
938 # Watch the article based on the user preference
946 }
947 }
949 /**
950 * Set a watch (or unwatch) based the based on a watchlist parameter.
951 * @param string $watch Valid values: 'watch', 'unwatch', 'preferences', 'nochange'
952 * @param Title $titleObj The article's title to change
953 * @param string $userOption The user option to consider when $watch=preferences
954 */
959 }
962 }
964 /**
965 * Using the settings determine the value for the given parameter
966 *
967 * @param string $paramName Parameter name
968 * @param array|mixed $paramSettings Default value or an array of settings
969 * using PARAM_* constants.
970 * @param bool $parseLimit Parse limit?
971 * @return mixed Parameter value
972 */
974 // Some classes may decide to change parameter names
1004 // When type is not given, and no choices, the type is the same as $default
1010 }
1011 }
1012 }
1016 // Having a default value of anything other than 'false' is not allowed
1018 __METHOD__,
1020 "Boolean parameters must default to false."
1021 );
1022 }
1027 // Having a default value is not allowed
1029 __METHOD__,
1032 }
1035 }
1038 // This will get the value without trying to normalize it
1039 // (because trying to normalize a large binary file
1040 // accidentally uploaded as a field fails spectacularly)
1048 );
1049 }
1050 }
1056 }
1057 }
1065 );
1066 }
1068 // More validation only when choices were not given
1069 // choices were validated in parseMultiValue()
1078 }
1091 }
1092 }
1097 }
1098 }
1102 // Don't do any validation whatsoever
1104 }
1107 ) {
1109 __METHOD__,
1111 );
1112 }
1115 }
1130 );
1131 }
1136 }
1142 }
1145 }
1151 }
1154 }
1160 }
1161 }
1163 // Throw out duplicates if requested
1166 }
1168 // Set a warning if a deprecated parameter has been passed
1171 }
1174 }
1177 }
1179 /**
1180 * Return an array of values that were given in a 'a|b|c' notation,
1181 * after it optionally validates them against the list allowed values.
1182 *
1183 * @param string $valueName The name of the parameter (for error
1184 * reporting)
1185 * @param mixed $value The value being parsed
1186 * @param bool $allowMultiple Can $value contain more than one value
1187 * separated by '|'?
1188 * @param mixed $allowedValues An array of values to check against. If
1189 * null, all values are accepted.
1190 * @return mixed (allowMultiple ? an_array_of_values : a_single_value)
1191 */
1195 }
1197 // This is a bit awkward, but we want to avoid calling canApiHighLimits()
1198 // because it unstubs $wgUser
1201 ? self::LIMIT_SML2
1207 }
1210 // Bug 33482 - Allow entries with | in them for non-multiple values
1213 }
1221 );
1222 }
1225 // Check for unknown values
1236 );
1237 }
1238 }
1239 // Now throw them out
1241 }
1244 }
1246 /**
1247 * Validate the value against the minimum and user/bot maximum limits.
1248 * Prints usage info on failure.
1249 * @param string $paramName Parameter name
1250 * @param int $value Parameter value
1251 * @param int|null $min Minimum value
1252 * @param int|null $max Maximum value for users
1253 * @param int $botMax Maximum value for sysops/bots
1254 * @param bool $enforceLimits Whether to enforce (die) if value is outside limits
1255 */
1256 function validateLimit( $paramName, &$value, $min, $max, $botMax = null, $enforceLimits = false ) {
1262 }
1264 // Minimum is always validated, whereas maximum is checked only if not
1265 // running in internal call mode
1268 }
1270 // Optimization: do not check user's bot status unless really needed -- skips db query
1271 // assumes $botMax >= $max
1279 }
1281 $msg = $this->encodeParamName( $paramName ) . " may not be over $max (set to $value) for users";
1284 }
1285 }
1286 }
1288 /**
1289 * Validate and normalize of parameters of type 'timestamp'
1290 * @param string $value Parameter value
1291 * @param string $encParamName Parameter name
1292 * @return string Validated and normalized parameter
1293 */
1300 );
1301 }
1304 }
1306 /**
1307 * Validate and normalize of parameters of type 'user'
1308 * @param string $value Parameter value
1309 * @param string $encParamName Parameter name
1310 * @return string Validated and normalized parameter
1311 */
1318 );
1319 }
1322 }
1324 /**
1325 * Adds a warning to the output, else dies
1326 *
1327 * @param string $msg Message to show as a warning, or error message if dying
1328 * @param bool $enforceLimits Whether this is an enforce (die)
1329 */
1333 }
1336 }
1338 /**
1339 * Truncate an array to a certain length.
1340 * @param array $arr Array to truncate
1341 * @param int $limit Maximum length
1342 * @return bool True if the array was truncated, false otherwise
1343 */
1349 }
1352 }
1354 /**
1355 * Throw a UsageException, which will (if uncaught) call the main module's
1356 * error handler and die with an error message.
1357 *
1358 * @param string $description One-line human-readable description of the
1359 * error condition, e.g., "The API requires a valid action parameter"
1360 * @param string $errorCode Brief, arbitrary, stable string to allow easy
1361 * automated identification of the error, e.g., 'unknown_action'
1362 * @param int $httpRespCode HTTP response code
1363 * @param array $extradata Data to add to the "<error>" element; array in ApiResult format
1364 * @throws UsageException
1365 */
1372 $extradata
1373 );
1374 }
1376 /**
1377 * Get error (as code, string) from a Status object.
1378 *
1379 * @since 1.23
1380 * @param Status $status
1381 * @return array Array of code and error string
1382 */
1386 }
1390 // No errors? Assume the warnings should be treated as errors
1392 }
1394 // Still no errors? Punt
1396 }
1398 // Cannot use dieUsageMsg() because extensions might return custom
1399 // error messages.
1406 }
1408 // Translate message to code, for backwards compatability
1410 }
1413 }
1415 /**
1416 * Throw a UsageException based on the errors in the Status object.
1417 *
1418 * @since 1.22
1419 * @param Status $status
1420 * @throws MWException
1421 */
1426 }
1428 // @codingStandardsIgnoreStart Allow long lines. Cannot split these.
1429 /**
1430 * Array that maps message keys to error messages. $1 and friends are replaced.
1431 */
1433 // This one MUST be present, or dieUsageMsg() will recurse infinitely
1437 // Messages from Title::getUserPermissionsErrors()
1441 ),
1445 ),
1449 ),
1453 ),
1457 ),
1460 'info' => "The page you're trying to edit is protected because it's included in a cascade-protected page"
1461 ),
1465 ),
1469 ),
1477 ),
1481 ),
1485 ),
1489 ),
1493 ),
1497 ),
1501 ),
1505 ),
1508 'info' => "Your IP address has been blocked automatically, because it was used by a blocked user"
1509 ),
1511 // Miscellaneous interface messages
1515 ),
1519 ),
1523 ),
1527 ),
1534 ),
1538 ),
1540 ),
1544 ),
1548 ),
1552 ),
1556 ),
1560 ),
1564 ),
1568 ),
1569 // 'badarticleerror' => shouldn't happen
1570 // 'badtitletext' => shouldn't happen
1575 ),
1579 ),
1585 ),
1588 '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."
1589 ),
1593 ),
1596 '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"
1597 ),
1601 ),
1605 ),
1609 ),
1613 ),
1617 ),
1620 'info' => "The user has not specified a valid email address, or has chosen not to receive email from other users"
1621 ),
1625 ),
1629 ),
1633 ),
1637 ),
1641 ),
1645 ),
1652 ),
1656 ),
1658 // API-specific messages
1662 ),
1665 '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"
1666 ),
1670 ),
1674 'nosuchrevid' => array( 'code' => 'nosuchrevid', 'info' => "There is no revision with ID \$1" ),
1677 'invalidexpiry' => array( 'code' => 'invalidexpiry', 'info' => "Invalid expiry time \"\$1\"" ),
1678 'pastexpiry' => array( 'code' => 'pastexpiry', 'info' => "Expiry time \"\$1\" is in the past" ),
1682 ),
1686 ),
1689 ),
1693 ),
1697 ),
1701 ),
1705 ),
1709 ),
1712 'info' => "Couldn't undelete: the requested revisions may not exist, or may have been undeleted already"
1713 ),
1717 ),
1721 ),
1725 ),
1729 ),
1733 ),
1737 ),
1741 ),
1745 ),
1749 ),
1754 ),
1758 ),
1762 ),
1766 ),
1770 ),
1774 ),
1778 ),
1781 'info' => 'The target file exists on a shared repository and you do not have permission to override it'
1782 ),
1785 'info' => 'The target file exists on a shared repository. Use the ignorewarnings parameter to override it.'
1786 ),
1790 ),
1794 ),
1798 ),
1802 ),
1806 ),
1810 ),
1813 'info' => 'A file with name "$1" already exists in the shared file repository, and cannot be overwritten.'
1814 ),
1818 ),
1820 // ApiEditPage messages
1824 ),
1828 ),
1832 ),
1836 ),
1837 'noedit-anon' => array( 'code' => 'noedit-anon', 'info' => "Anonymous users can't edit pages" ),
1842 ),
1846 ),
1848 'hashcheckfailed' => array( 'code' => 'badmd5', 'info' => "The supplied MD5 hash was incorrect" ),
1852 ),
1856 ),
1860 ),
1864 ),
1866 // Messages from WikiPage::doEit()
1870 ),
1874 ),
1879 ),
1881 // uploadMsgs
1886 'info' => 'Uploads are not enabled. Make sure $wgEnableUploads is set to true in LocalSettings.php and the PHP ini setting file_uploads is true'
1887 ),
1890 'info' => 'Uploads by URL is not enabled. Make sure $wgAllowCopyUploads is set to true in LocalSettings.php.'
1891 ),
1895 ),
1899 ),
1904 ),
1905 'filename-toolong' => array( 'code' => 'filename-toolong', 'info' => 'The filename is too long' ),
1909 ),
1913 ),
1915 'mustbeloggedin' => array( 'code' => 'mustbeloggedin', 'info' => 'You must be logged in to $1.' )
1916 );
1917 // @codingStandardsIgnoreEnd
1919 /**
1920 * Helper function for readonly errors
1921 */
1926 }
1928 /**
1929 * Output the error message related to a certain array
1930 * @param array|string $error Element of a getUserPermissionsErrors()-style array
1931 */
1933 # most of the time we send a 1 element, so we might as well send it as
1934 # a string and make this an array here.
1937 }
1940 }
1942 /**
1943 * Will only set a warning instead of failing if the global $wgDebugAPI
1944 * is set to true. Otherwise behaves exactly as dieUsageMsg().
1945 * @param array|string $error Element of a getUserPermissionsErrors()-style array
1946 * @since 1.21
1947 */
1952 }
1956 }
1960 }
1962 /**
1963 * Die with the $prefix.'badcontinue' error. This call is common enough to
1964 * make it into the base method.
1965 * @param bool $condition Will only die if this value is true
1966 * @since 1.21
1967 */
1973 }
1974 }
1976 /**
1977 * Return the error message related to a certain array
1978 * @param array $error Element of a getUserPermissionsErrors()-style array
1979 * @return array('code' => code, 'info' => info)
1980 */
1985 // Check whether the error array was nested
1986 // array( array( <code>, <params> ), array( <another_code>, <params> ) )
1990 }
1996 );
1997 }
1999 // If the key isn't present, throw an "unknown error"
2001 }
2003 /**
2004 * Internal code errors should be reported with this method
2005 * @param string $method Method or function name
2006 * @param string $message Error message
2007 * @throws MWException
2008 */
2011 }
2013 /**
2014 * Indicates if this module needs maxlag to be checked
2015 * @return bool
2016 */
2019 }
2021 /**
2022 * Indicates whether this module requires read rights
2023 * @return bool
2024 */
2027 }
2029 /**
2030 * Indicates whether this module requires write mode
2031 * @return bool
2032 */
2035 }
2037 /**
2038 * Indicates whether this module must be called with a POST request
2039 * @return bool
2040 */
2043 }
2045 /**
2046 * Returns whether this module requires a token to execute
2047 * It is used to show possible errors in action=paraminfo
2048 * see bug 25248
2049 * @return bool
2050 */
2053 }
2055 /**
2056 * Returns the token salt if there is one,
2057 * '' if the module doesn't require a salt,
2058 * else false if the module doesn't need a token
2059 * You have also to override needsToken()
2060 * Value is passed to User::getEditToken
2061 * @return bool|string|array
2062 */
2065 }
2067 /**
2068 * Gets the user for whom to get the watchlist
2069 *
2070 * @param array $params
2071 * @return User
2072 */
2078 }
2083 'bad_wltoken'
2084 );
2085 }
2089 }
2092 }
2094 }
2097 }
2099 /**
2100 * @return bool|string|array Returns a false if the module has no help URL,
2101 * else returns a (array of) string
2102 */
2105 }
2107 /**
2108 * Returns a list of all possible errors returned by the module
2109 *
2110 * Don't call this function directly: use getFinalPossibleErrors() to allow
2111 * hooks to modify parameters as needed.
2112 *
2113 * @return array Array in the format of array( key, param1, param2, ... )
2114 * or array( 'code' => ..., 'info' => ... )
2115 */
2124 ) {
2126 }
2127 }
2132 'original value returned by the previous query'
2133 );
2134 }
2135 }
2139 }
2143 }
2148 }
2153 ) {
2154 // Add token as possible missing parameter, if not already done
2156 }
2158 }
2161 }
2163 /**
2164 * Get final list of possible errors, after hooks have had a chance to
2165 * tweak it as needed.
2166 *
2167 * @return array
2168 * @since 1.22
2169 */
2175 }
2177 /**
2178 * Parses a list of errors into a standardised format
2179 * @param array $errors List of errors. Items can be in the for
2180 * array( key, param1, param2, ... ) or array( 'code' => ..., 'info' => ... )
2181 * @return array Parsed list of errors with items in the form array( 'code' => ..., 'info' => ... )
2182 */
2191 }
2192 }
2195 }
2197 /**
2198 * Profiling: total module execution time
2199 */
2202 /**
2203 * Start module profiling
2204 */
2208 }
2211 }
2213 /**
2214 * End module profiling
2215 */
2219 }
2222 __METHOD__,
2223 'Must be called after database profiling is done with profileDBOut()'
2224 );
2225 }
2230 }
2232 /**
2233 * When modules crash, sometimes it is needed to do a profileOut() regardless
2234 * of the profiling state the module was in. This method does such cleanup.
2235 */
2240 }
2242 }
2243 }
2245 /**
2246 * Total time the module was executed
2247 * @return float
2248 */
2252 }
2255 }
2257 /**
2258 * Profiling: database execution time
2259 */
2262 /**
2263 * Start module profiling
2264 */
2268 __METHOD__,
2269 'Must be called while profiling the entire module with profileIn()'
2270 );
2271 }
2274 }
2277 }
2279 /**
2280 * End database profiling
2281 */
2286 }
2289 }
2297 }
2299 /**
2300 * Total time the module used the database
2301 * @return float
2302 */
2306 }
2309 }
2311 /**
2312 * Gets a default slave database connection object
2313 * @return DatabaseBase
2314 */
2320 }
2323 }
2325 /**
2326 * Debugging function that prints a value and an optional backtrace
2327 * @param mixed $value Value to print
2328 * @param string $name Description of the printed value
2329 * @param bool $backtrace If true, print a backtrace
2330 */
2336 }
2338 }
2339 }