PageRenderTime 61ms CodeModel.GetById 25ms RepoModel.GetById 1ms app.codeStats 0ms

/classes/botclasses.php

https://github.com/Dispositif/addbot
PHP | 1147 lines | 675 code | 67 blank | 405 comment | 97 complexity | c4a5b854d3769442cce203e1bed0fbb1 MD5 | raw file
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * botclasses.php - Bot classes for interacting with mediawiki.
    4. 

  4.  *
    5. 

  5.  *  (c) 2008-2012 Chris G - http://en.wikipedia.org/wiki/User:Chris_G
    6. 

  6.  *  (c) 2009-2010 Fale - http://en.wikipedia.org/wiki/User:Fale
    7. 

  7.  *  (c) 2010      Kaldari - http://en.wikipedia.org/wiki/User:Kaldari
    8. 

  8.  *  (c) 2011      Gutza - http://en.wikipedia.org/wiki/User:Gutza
    9. 

  9.  *  (c) 2012      Sean - http://en.wikipedia.org/wiki/User:SColombo
    10. 

  10.  *  (c) 2012      Brain - http://en.wikipedia.org/wiki/User:Brian_McNeil
    11. 

  11.  *  (c) 2012-2013 Addshore - http://en.wikipedia.org/wiki/User:Addshore
    12. 

  12.  *
    13. 

  13.  *  This program is free software; you can redistribute it and/or modify
    14. 

  14.  *  it under the terms of the GNU General Public License as published by
    15. 

  15.  *  the Free Software Foundation; either version 2 of the License, or
    16. 

  16.  *  (at your option) any later version.
    17. 

  17.  *
    18. 

  18.  *  This program is distributed in the hope that it will be useful,
    19. 

  19.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    20. 

  20.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    21. 

  21.  *  GNU General Public License for more details.
    22. 

  22.  *
    23. 

  23.  *  You should have received a copy of the GNU General Public License
    24. 

  24.  *  along with this program; if not, write to the Free Software
    25. 

  25.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    26. 

  26.  *
    27. 

  27.  *  Developers (add yourself here if you worked on the code):
    28. 

  28.  *      Cobi     - [[User:Cobi]]         - Wrote the http class and some of the wikipedia class
    29. 

  29.  *      Chris    - [[User:Chris_G]]      - Wrote the most of the wikipedia class
    30. 

  30.  *      Fale     - [[User:Fale]]         - Polish, wrote the extended and some of the wikipedia class
    31. 

  31.  *      Kaldari  - [[User:Kaldari]]      - Submitted a patch for the imagematches function
    32. 

  32.  *      Gutza    - [[User:Gutza]]        - Submitted a patch for http->setHTTPcreds(), and http->quiet
    33. 

  33.  *      Sean     - [[User:SColombo]]     - Wrote the lyricwiki class (now moved to lyricswiki.php)
    34. 

  34.  *      Brain    - [[User:Brian_McNeil]] - Wrote wikipedia->getfileuploader() and wikipedia->getfilelocation
    35. 

  35.  * 		Addshore - [[User:Addshore]]     - Functions for Addbot (lastedit,lasteditonpage,firstedit,update nobots)
    36. 

  36.  **/
    37. 

  37. 

  38. /**
    39. 

  39.  * This class is designed to provide a simplified interface to cURL which maintains cookies.
    40. 

  40.  * @author Cobi
    41. 

  41.  **/
    42. 

  42. class http {
    43. 

  43.     private $ch;
    44. 

  44.     private $uid;
    45. 

  45.     public $cookie_jar;
    46. 

  46.     public $postfollowredirs;
    47. 

  47.     public $getfollowredirs;
    48. 

  48.     public $quiet=true;
    49. 

  49. 

  50.     function data_encode ($data, $keyprefix = "", $keypostfix = "") {
    51. 

  51.         assert( is_array($data) );
    52. 

  52.         $vars=null;
    53. 

  53.         foreach($data as $key=>$value) {
    54. 

  54.             if(is_array($value))
    55. 

  55.                 $vars .= $this->data_encode($value, $keyprefix.$key.$keypostfix.urlencode("["), urlencode("]"));
    56. 

  56.             else
    57. 

  57.                 $vars .= $keyprefix.$key.$keypostfix."=".urlencode($value)."&";
    58. 

  58.         }
    59. 

  59.         return $vars;
    60. 

  60.     }
    61. 

  61. 

  62.     function __construct () {
    63. 

  63.         $this->ch = curl_init();
    64. 

  64.         $this->uid = dechex(rand(0,99999999));
    65. 

  65.         curl_setopt($this->ch,CURLOPT_COOKIEJAR,'/tmp/cluewikibot.cookies.'.$this->uid.'.dat');
    66. 

  66.         curl_setopt($this->ch,CURLOPT_COOKIEFILE,'/tmp/cluewikibot.cookies.'.$this->uid.'.dat');
    67. 

  67.         curl_setopt($this->ch,CURLOPT_MAXCONNECTS,100);
    68. 

  68.         curl_setopt($this->ch,CURLOPT_CLOSEPOLICY,CURLCLOSEPOLICY_LEAST_RECENTLY_USED);
    69. 

  69.         $this->postfollowredirs = 0;
    70. 

  70.         $this->getfollowredirs = 1;
    71. 

  71.         $this->cookie_jar = array();
    72. 

  72.     }
    73. 

  73. 

  74.     function post ($url,$data) {
    75. 

  75.         //echo 'POST: '.$url."\n";
    76. 

  76.         $time = microtime(1);
    77. 

  77.         curl_setopt($this->ch,CURLOPT_URL,$url);
    78. 

  78.         curl_setopt($this->ch,CURLOPT_USERAGENT,'php wikibot classes');
    79. 

  79.         /* Crappy hack to add extra cookies, should be cleaned up */
    80. 

  80.         $cookies = null;
    81. 

  81.         foreach ($this->cookie_jar as $name => $value) {
    82. 

  82.             if (empty($cookies))
    83. 

  83.                 $cookies = "$name=$value";
    84. 

  84.             else
    85. 

  85.                 $cookies .= "; $name=$value";
    86. 

  86.         }
    87. 

  87.         if ($cookies != null)
    88. 

  88.             curl_setopt($this->ch,CURLOPT_COOKIE,$cookies);
    89. 

  89.         curl_setopt($this->ch,CURLOPT_FOLLOWLOCATION,$this->postfollowredirs);
    90. 

  90.         curl_setopt($this->ch,CURLOPT_MAXREDIRS,10);
    91. 

  91.         curl_setopt($this->ch, CURLOPT_HTTPHEADER, array('Expect:'));
    92. 

  92.         curl_setopt($this->ch,CURLOPT_RETURNTRANSFER,1);
    93. 

  93.         curl_setopt($this->ch,CURLOPT_TIMEOUT,30);
    94. 

  94.         curl_setopt($this->ch,CURLOPT_CONNECTTIMEOUT,10);
    95. 

  95.         curl_setopt($this->ch,CURLOPT_POST,1);
    96. 

  96. //      curl_setopt($this->ch,CURLOPT_FAILONERROR,1);
    97. 

  97. //    curl_setopt($this->ch,CURLOPT_POSTFIELDS, substr($this->data_encode($data), 0, -1) );
    98. 

  98.         curl_setopt($this->ch,CURLOPT_POSTFIELDS, $data);
    99. 

  99.         $data = curl_exec($this->ch);
    100. 

  100. //    echo "Error: ".curl_error($this->ch);
    101. 

  101. //    var_dump($data);
    102. 

  102. //    global $logfd;
    103. 

  103. //    if (!is_resource($logfd)) {
    104. 

  104. //        $logfd = fopen('php://stderr','w');
    105. 

  105.     if (!$this->quiet)
    106. 

  106.             echo 'POST: '.$url.' ('.(microtime(1) - $time).' s) ('.strlen($data)." b)\n";
    107. 

  107. //     }
    108. 

  108.         return $data;
    109. 

  109.     }
    110. 

  110. 

  111.     function get ($url) {
    112. 

  112.         //echo 'GET: '.$url."\n";
    113. 

  113.         $time = microtime(1);
    114. 

  114.         curl_setopt($this->ch,CURLOPT_URL,$url);
    115. 

  115.         curl_setopt($this->ch,CURLOPT_USERAGENT,'php wikibot classes');
    116. 

  116.         /* Crappy hack to add extra cookies, should be cleaned up */
    117. 

  117.         $cookies = null;
    118. 

  118.         foreach ($this->cookie_jar as $name => $value) {
    119. 

  119.             if (empty($cookies))
    120. 

  120.                 $cookies = "$name=$value";
    121. 

  121.             else
    122. 

  122.                 $cookies .= "; $name=$value";
    123. 

  123.         }
    124. 

  124.         if ($cookies != null)
    125. 

  125.             curl_setopt($this->ch,CURLOPT_COOKIE,$cookies);
    126. 

  126.         curl_setopt($this->ch,CURLOPT_FOLLOWLOCATION,$this->getfollowredirs);
    127. 

  127.         curl_setopt($this->ch,CURLOPT_MAXREDIRS,10);
    128. 

  128.         curl_setopt($this->ch,CURLOPT_HEADER,0);
    129. 

  129.         curl_setopt($this->ch,CURLOPT_RETURNTRANSFER,1);
    130. 

  130.         curl_setopt($this->ch,CURLOPT_TIMEOUT,30);
    131. 

  131.         curl_setopt($this->ch,CURLOPT_CONNECTTIMEOUT,10);
    132. 

  132.         curl_setopt($this->ch,CURLOPT_HTTPGET,1);
    133. 

  133.         //curl_setopt($this->ch,CURLOPT_FAILONERROR,1);
    134. 

  134.         $data = curl_exec($this->ch);
    135. 

  135.         //echo "Error: ".curl_error($this->ch);
    136. 

  136.         //var_dump($data);
    137. 

  137.         //global $logfd;
    138. 

  138.         //if (!is_resource($logfd)) {
    139. 

  139.         //    $logfd = fopen('php://stderr','w');
    140. 

  140.         if (!$this->quiet)
    141. 

  141.             echo 'GET: '.$url.' ('.(microtime(1) - $time).' s) ('.strlen($data)." b)\n";
    142. 

  142.         //}
    143. 

  143.         return $data;
    144. 

  144.     }
    145. 

  145. 

  146.     function setHTTPcreds($uname,$pwd) {
    147. 

  147.         curl_setopt($this->ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
    148. 

  148.         curl_setopt($this->ch, CURLOPT_USERPWD, $uname.":".$pwd);
    149. 

  149.     }
    150. 

  150. 

  151.     function __destruct () {
    152. 

  152.         curl_close($this->ch);
    153. 

  153.         @unlink('/tmp/cluewikibot.cookies.'.$this->uid.'.dat');
    154. 

  154.     }
    155. 

  155. }
    156. 

  156. 

  157. /**
    158. 

  158.  * This class is interacts with wikipedia using api.php
    159. 

  159.  * @author Chris G and Cobi
    160. 

  160.  **/
    161. 

  161. class wikipedia {
    162. 

  162.     private $http;
    163. 

  163.     private $token;
    164. 

  164.     private $ecTimestamp;
    165. 

  165.     public $url;
    166. 

  166. 

  167.     /**
    168. 

  168.      * This is our constructor.
    169. 

  169.      * @return void
    170. 

  170.      **/
    171. 

  171.     function __construct ($url='http://en.wikipedia.org/w/api.php',$hu=null,$hp=null) {
    172. 

  172.         $this->http = new http;
    173. 

  173.         $this->token = null;
    174. 

  174.         $this->url = $url;
    175. 

  175.         $this->ecTimestamp = null;
    176. 

  176.         if ($hu!==null)
    177. 

  177.             $this->http->setHTTPcreds($hu,$hp);
    178. 

  178.     }
    179. 

  179. 

  180.     function __set($var,$val) {
    181. 

  181.     switch($var) {
    182. 

  182.           case 'quiet':
    183. 

  183.             $this->http->quiet=$val;
    184. 

  184.                  break;
    185. 

  185.            default:
    186. 

  186.                  echo "WARNING: Unknown variable ($var)!\n";
    187. 

  187.      }
    188. 

  188.     }
    189. 

  189. 

  190.     /**
    191. 

  191.      * Sends a query to the api.
    192. 

  192.      * @param $query The query string.
    193. 

  193.      * @param $post POST data if its a post request (optional).
    194. 

  194.      * @return The api result.
    195. 

  195.      **/
    196. 

  196.     function query ($query,$post=null) {
    197. 

  197.         if ($post==null)
    198. 

  198.             $ret = $this->http->get($this->url.$query);
    199. 

  199.         else
    200. 

  200.             $ret = $this->http->post($this->url.$query,$post);
    201. 

  201.         return unserialize($ret);
    202. 

  202.     }
    203. 

  203. 

  204.     /**
    205. 

  205.      * Gets the content of a page. Returns false on error.
    206. 

  206.      * @param $page The wikipedia page to fetch.
    207. 

  207.      * @param $revid The revision id to fetch (optional)
    208. 

  208.      * @return The wikitext for the page.
    209. 

  209.      **/
    210. 

  210.     function getpage ($page,$revid=null,$detectEditConflict=false) {
    211. 

  211.         $append = '';
    212. 

  212.         if ($revid!=null)
    213. 

  213.             $append = '&rvstartid='.$revid;
    214. 

  214.         $x = $this->query('?action=query&format=php&prop=revisions&titles='.urlencode($page).'&rvlimit=1&rvprop=content|timestamp'.$append);
    215. 

  215.         foreach ($x['query']['pages'] as $ret) {
    216. 

  216.             if (isset($ret['revisions'][0]['*'])) {
    217. 

  217.                 if ($detectEditConflict)
    218. 

  218.                     $this->ecTimestamp = $ret['revisions'][0]['timestamp'];
    219. 

  219.                 return $ret['revisions'][0]['*'];
    220. 

  220.             } else
    221. 

  221.                 return false;
    222. 

  222.         }
    223. 

  223.     }
    224. 

  224. 

  225.     /**
    226. 

  226.      * Gets the page id for a page.
    227. 

  227.      * @param $page The wikipedia page to get the id for.
    228. 

  228.      * @return The page id of the page.
    229. 

  229.      **/
    230. 

  230.     function getpageid ($page) {
    231. 

  231.         $x = $this->query('?action=query&format=php&prop=revisions&titles='.urlencode($page).'&rvlimit=1&rvprop=content');
    232. 

  232.         foreach ($x['query']['pages'] as $ret) {
    233. 

  233.             return $ret['pageid'];
    234. 

  234.         }
    235. 

  235.     }
    236. 

  236. 

  237.     /**
    238. 

  238.      * Gets the number of contributions a user has.
    239. 

  239.      * @param $user The username for which to get the edit count.
    240. 

  240.      * @return The number of contributions the user has.
    241. 

  241.      **/
    242. 

  242.     function contribcount ($user) {
    243. 

  243.         $x = $this->query('?action=query&list=allusers&format=php&auprop=editcount&aulimit=1&aufrom='.urlencode($user));
    244. 

  244.         return $x['query']['allusers'][0]['editcount'];
    245. 

  245.     }
    246. 

  246. 

  247.     /**
    248. 

  248.      * Returns an array with all the members of $category
    249. 

  249.      * @param $category The category to use.
    250. 

  250.      * @param $subcat (bool) Go into sub categories?
    251. 

  251.      * @return array
    252. 

  252.      **/
    253. 

  253.     function categorymembers ($category,$subcat=false) {
    254. 

  254.         $continue = '';
    255. 

  255.         $pages = array();
    256. 

  256.         while (true) {
    257. 

  257.             $res = $this->query('?action=query&list=categorymembers&cmtitle='.urlencode($category).'&format=php&cmlimit=500'.$continue);
    258. 

  258.             if (isset($x['error'])) {
    259. 

  259.                 return false;
    260. 

  260.             }
    261. 

  261.             foreach ($res['query']['categorymembers'] as $x) {
    262. 

  262.                 $pages[] = $x['title'];
    263. 

  263.             }
    264. 

  264.             if (empty($res['query-continue']['categorymembers']['cmcontinue'])) {
    265. 

  265.                 if ($subcat) {
    266. 

  266.                     foreach ($pages as $p) {
    267. 

  267.                         if (substr($p,0,9)=='Category:') {
    268. 

  268.                             $pages2 = $this->categorymembers($p,true);
    269. 

  269.                             $pages = array_merge($pages,$pages2);
    270. 

  270.                         }
    271. 

  271.                     }
    272. 

  272.                 }
    273. 

  273.                 return $pages;
    274. 

  274.             } else {
    275. 

  275.                 $continue = '&cmcontinue='.urlencode($res['query-continue']['categorymembers']['cmcontinue']);
    276. 

  276.             }
    277. 

  277.         }
    278. 

  278.     }
    279. 

  279. 	
    280. 

  280. 	/**
    281. 

  281.      * Returns an array with all the ctegories of a page
    282. 

  282.      * @param $page The page to check
    283. 

  283.      * @param $hidden (bool) Do you want to only show hiddencats or only show normalcats? (can be null)
    284. 

  284.      * @return array
    285. 

  285.      **/
    286. 

  286.     function categories($page,$hidden=null) {
    287. 

  287. 		if($hidden === true){ $h = "&clshow=hidden";}
    288. 

  288. 		elseif($hidden === false){$h = "&clshow=!hidden";}
    289. 

  289. 		else{$h = "";}
    290. 

  290.         $continue = '';
    291. 

  291.         $pages = array();
    292. 

  292.         while (true) {
    293. 

  293.             $res = $this->query('?action=query&prop=categories&clprop=hidden&titles='.urlencode($page).$h.'&format=php&cllimit=1000'.$continue);
    294. 

  294.             if (isset($x['error'])) {
    295. 

  295.                 return false;
    296. 

  296.             }
    297. 

  297.             foreach ($res['query']['pages'] as $p) {
    298. 

  298. 				foreach ($p['categories'] as $x) {
    299. 

  299. 					$pages[] = $x['title'];
    300. 

  300. 				}
    301. 

  301.             }
    302. 

  302.             if (empty($res['query-continue']['categories']['clcontinue'])) {
    303. 

  303.                 return $pages;
    304. 

  304.             } else {
    305. 

  305.                 $continue = '&clcontinue='.urlencode($res['query-continue']['categories']['clcontinue']);
    306. 

  306.             }
    307. 

  307.         }
    308. 

  308.     }
    309. 

  309. 

  310.     /**
    311. 

  311.      * Returns a list of pages that link to $page.
    312. 

  312.      * @param $page
    313. 

  313.      * @param $extra (defaults to null)
    314. 

  314.      * @return array
    315. 

  315.      **/
    316. 

  316.     function whatlinkshere ($page,$extra=null) {
    317. 

  317.         $continue = '';
    318. 

  318.         $pages = array();
    319. 

  319.         while (true) {
    320. 

  320.             $res = $this->query('?action=query&list=backlinks&bltitle='.urlencode($page).'&bllimit=1000&format=php'.$continue.$extra);
    321. 

  321.             if (isset($res['error'])) {
    322. 

  322.                 return false;
    323. 

  323.             }
    324. 

  324.             foreach ($res['query']['backlinks'] as $x) {
    325. 

  325.                 $pages[] = $x['title'];
    326. 

  326.             }
    327. 

  327.             if (empty($res['query-continue']['backlinks']['blcontinue'])) {
    328. 

  328.                 return $pages;
    329. 

  329.             } else {
    330. 

  330.                 $continue = '&blcontinue='.urlencode($res['query-continue']['backlinks']['blcontinue']);
    331. 

  331.             }
    332. 

  332.         }
    333. 

  333.     }
    334. 

  334. 

  335.     /**
    336. 

  336.     * Returns a list of pages that include the image.
    337. 

  337.     * @param $image
    338. 

  338.     * @param $extra (defaults to null)
    339. 

  339.     * @return array
    340. 

  340.     **/
    341. 

  341.     function whereisincluded ($image,$extre=null) {
    342. 

  342.         $continue = '';
    343. 

  343.         $pages = array();
    344. 

  344.         while (true) {
    345. 

  345.             $res = $this->query('?action=query&list=imageusage&iutitle='.urlencode($image).'&iulimit=500&format=php'.$continue.$extra);
    346. 

  346.             if (isset($res['error']))
    347. 

  347.                 return false;
    348. 

  348.             foreach ($res['query']['imageusage'] as $x) {
    349. 

  349.                 $pages[] = $x['title'];
    350. 

  350.             }
    351. 

  351.             if (empty($res['query-continue']['imageusage']['iucontinue']))
    352. 

  352.                 return $pages;
    353. 

  353.             else
    354. 

  354.                 $continue = '&iucontinue='.urlencode($res['query-continue']['imageusage']['iucontinue']);
    355. 

  355.         }
    356. 

  356.     }
    357. 

  357.     
    358. 

  358.     /**
    359. 

  359.     * Returns a list of pages that use the $template.
    360. 

  360.     * @param $template the template we are intereste into
    361. 

  361.     * @param $extra (defaults to null)
    362. 

  362.     * @return array
    363. 

  363.     **/
    364. 

  364.     function whatusethetemplate ($template,$extra=null) {
    365. 

  365.         $continue = '';
    366. 

  366.         $pages = array();
    367. 

  367.         while (true) {
    368. 

  368.             $res = $this->query('?action=query&list=embeddedin&eititle=Template:'.urlencode($template).'&eilimit=500&format=php'.$continue.$extra);
    369. 

  369.             if (isset($res['error'])) {
    370. 

  370.                 return false;
    371. 

  371.             }
    372. 

  372.             foreach ($res['query']['embeddedin'] as $x) {
    373. 

  373.                 $pages[] = $x['title'];
    374. 

  374.             }
    375. 

  375.             if (empty($res['query-continue']['embeddedin']['eicontinue'])) {
    376. 

  376.                 return $pages;
    377. 

  377.             } else {
    378. 

  378.                 $continue = '&eicontinue='.urlencode($res['query-continue']['embeddedin']['eicontinue']);
    379. 

  379.             }
    380. 

  380.          }
    381. 

  381.      }
    382. 

  382.     
    383. 

  383.     /**
    384. 

  384.      * Returns an array with all the subpages of $page
    385. 

  385.      * @param $page
    386. 

  386.      * @return array
    387. 

  387.      **/
    388. 

  388.     function subpages ($page) {
    389. 

  389.         /* Calculate all the namespace codes */
    390. 

  390.         $ret = $this->query('?action=query&meta=siteinfo&siprop=namespaces&format=php');
    391. 

  391.         foreach ($ret['query']['namespaces'] as $x) {
    392. 

  392.             $namespaces[$x['*']] = $x['id'];
    393. 

  393.         }
    394. 

  394.         $temp = explode(':',$page,2);
    395. 

  395.         $namespace = $namespaces[$temp[0]];
    396. 

  396.         $title = $temp[1];
    397. 

  397.         $continue = '';
    398. 

  398.         $subpages = array();
    399. 

  399.         while (true) {
    400. 

  400.             $res = $this->query('?action=query&format=php&list=allpages&apprefix='.urlencode($title).'&aplimit=500&apnamespace='.$namespace.$continue);
    401. 

  401.             if (isset($x[error])) {
    402. 

  402.                 return false;
    403. 

  403.             }
    404. 

  404.             foreach ($res['query']['allpages'] as $p) {
    405. 

  405.                 $subpages[] = $p['title'];
    406. 

  406.             }
    407. 

  407.             if (empty($res['query-continue']['allpages']['apfrom'])) {
    408. 

  408.                 return $subpages;
    409. 

  409.             } else {
    410. 

  410.                 $continue = '&apfrom='.urlencode($res['query-continue']['allpages']['apfrom']);
    411. 

  411.             }
    412. 

  412.         }
    413. 

  413.     }
    414. 

  414. 

  415.     /**
    416. 

  416.      * This function takes a username and password and logs you into wikipedia.
    417. 

  417.      * @param $user Username to login as.
    418. 

  418.      * @param $pass Password that corrisponds to the username.
    419. 

  419.      * @return array
    420. 

  420.      **/
    421. 

  421.     function login ($user,$pass) {
    422. 

  422.         $post = array('lgname' => $user, 'lgpassword' => $pass);
    423. 

  423.         $ret = $this->query('?action=login&format=php',$post);
    424. 

  424.         /* This is now required - see https://bugzilla.wikimedia.org/show_bug.cgi?id=23076 */
    425. 

  425.         if ($ret['login']['result'] == 'NeedToken') {
    426. 

  426.             $post['lgtoken'] = $ret['login']['token'];
    427. 

  427.             $ret = $this->query( '?action=login&format=php', $post );
    428. 

  428.         }
    429. 

  429.         if ($ret['login']['result'] != 'Success') {
    430. 

  430.             echo "Login error: \n";
    431. 

  431.             print_r($ret);
    432. 

  432.             die();
    433. 

  433.         } else {
    434. 

  434.             return $ret;
    435. 

  435.         }
    436. 

  436.     }
    437. 

  437. 

  438.     /* crappy hack to allow users to use cookies from old sessions */
    439. 

  439.     function setLogin($data) {
    440. 

  440.         $this->http->cookie_jar = array(
    441. 

  441.         $data['cookieprefix'].'UserName' => $data['lgusername'],
    442. 

  442.         $data['cookieprefix'].'UserID' => $data['lguserid'],
    443. 

  443.         $data['cookieprefix'].'Token' => $data['lgtoken'],
    444. 

  444.         $data['cookieprefix'].'_session' => $data['sessionid'],
    445. 

  445.         );
    446. 

  446.     }
    447. 

  447. 

  448.     /**
    449. 

  449.      * Check if we're allowed to edit $page.
    450. 

  450.      * See http://en.wikipedia.org/wiki/Template:Bots
    451. 

  451.      * for more info.
    452. 

  452.      * @param $page The page we want to edit.
    453. 

  453.      * @param $user The bot's username.
    454. 

  454.      * @return bool
    455. 

  455.      **/
    456. 

  456.     function nobots ($page,$user=null,$text=null) {
    457. 

  457.         if ($text == null) {
    458. 

  458.             $text = $this->getpage($page);
    459. 

  459.         }
    460. 

  460. 		if (preg_match('/\{\{(nobots|bots\|allow=none|bots\|deny=all|bots\|optout=all|bots\|deny=.*?'.preg_quote($user,'/').'.*?)\}\}/iS',$text))
    461. 

  461. 			return false;
    462. 

  462. 		if (preg_match('/\{\{(bots\|allow=all|bots\|allow=.*?'.preg_quote($user,'/').'.*?)\}\}/iS', $text))
    463. 

  463. 			return true;
    464. 

  464. 		if (preg_match('/\{\{(bots\|allow=.*?)\}\}/iS', $text))
    465. 

  465. 			return false;
    466. 

  466. 		return true;
    467. 

  467.     }
    468. 

  468. 

  469.     /**
    470. 

  470.      * This function returns the edit token for the current user.
    471. 

  471.      * @return edit token.
    472. 

  472.      **/
    473. 

  473.     function getedittoken () {
    474. 

  474.         $x = $this->query('?action=query&prop=info&intoken=edit&titles=Main%20Page&format=php');
    475. 

  475.         foreach ($x['query']['pages'] as $ret) {
    476. 

  476.             return $ret['edittoken'];
    477. 

  477.         }
    478. 

  478.     }
    479. 

  479. 

  480.     /**
    481. 

  481.      * Purges the cache of $page.
    482. 

  482.      * @param $page The page to purge.
    483. 

  483.      * @return Api result.
    484. 

  484.      **/
    485. 

  485.     function purgeCache($page) {
    486. 

  486.         return $this->query('?action=purge&titles='.urlencode($page).'&format=php');
    487. 

  487.     }
    488. 

  488. 

  489.     /**
    490. 

  490.      * Checks if $user has email enabled.
    491. 

  491.      * Uses index.php.
    492. 

  492.      * @param $user The user to check.
    493. 

  493.      * @return bool.
    494. 

  494.      **/
    495. 

  495.     function checkEmail($user) {
    496. 

  496.         $x = $this->query('?action=query&meta=allmessages&ammessages=noemailtext|notargettext&amlang=en&format=php');
    497. 

  497.         $messages[0] = $x['query']['allmessages'][0]['*'];
    498. 

  498.         $messages[1] = $x['query']['allmessages'][1]['*'];
    499. 

  499.         $page = $this->http->get(str_replace('api.php','index.php',$this->url).'?title=Special:EmailUser&target='.urlencode($user));
    500. 

  500.         if (preg_match('/('.preg_quote($messages[0],'/').'|'.preg_quote($messages[1],'/').')/i',$page)) {
    501. 

  501.             return false;
    502. 

  502.         } else {
    503. 

  503.             return true;
    504. 

  504.         }
    505. 

  505.     }
    506. 

  506. 

  507.     /**
    508. 

  508.      * Returns all the pages $page is transcluded on.
    509. 

  509.      * @param $page The page to get the transclusions from.
    510. 

  510.      * @param $sleep The time to sleep between requets (set to null to disable).
    511. 

  511.      * @return array.
    512. 

  512.      **/
    513. 

  513.     function getTransclusions($page,$sleep=null,$extra=null) {
    514. 

  514.         $continue = '';
    515. 

  515.         $pages = array();
    516. 

  516.         while (true) {
    517. 

  517.             $ret = $this->query('?action=query&list=embeddedin&eititle='.urlencode($page).$continue.$extra.'&eilimit=500&format=php');
    518. 

  518.             if ($sleep != null) {
    519. 

  519.                 sleep($sleep);
    520. 

  520.             }
    521. 

  521.             foreach ($ret['query']['embeddedin'] as $x) {
    522. 

  522.                 $pages[] = $x['title'];
    523. 

  523.             }
    524. 

  524.             if (isset($ret['query-continue']['embeddedin']['eicontinue'])) {
    525. 

  525.                 $continue = '&eicontinue='.$ret['query-continue']['embeddedin']['eicontinue'];
    526. 

  526.             } else {
    527. 

  527.                 return $pages;
    528. 

  528.             }
    529. 

  529.         }
    530. 

  530.     }
    531. 

  531. 

  532.     /**
    533. 

  533.      * Edits a page.
    534. 

  534.      * @param $page Page name to edit.
    535. 

  535.      * @param $data Data to post to page.
    536. 

  536.      * @param $summary Edit summary to use.
    537. 

  537.      * @param $minor Whether or not to mark edit as minor.  (Default false)
    538. 

  538.      * @param $bot Whether or not to mark edit as a bot edit.  (Default true)
    539. 

  539.      * @return api result
    540. 

  540.      **/
    541. 

  541.     function edit ($page,$data,$summary = '',$minor = false,$bot = true,$section = null,$detectEC=false,$maxlag='') {
    542. 

  542.         if ($this->token==null) {
    543. 

  543.             $this->token = $this->getedittoken();
    544. 

  544.         }
    545. 

  545.         $params = array(
    546. 

  546.             'title' => $page,
    547. 

  547.             'text' => $data,
    548. 

  548.             'token' => $this->token,
    549. 

  549.             'summary' => $summary,
    550. 

  550.             ($minor?'minor':'notminor') => '1',
    551. 

  551.             ($bot?'bot':'notbot') => '1'
    552. 

  552.         );
    553. 

  553.         if ($section != null) {
    554. 

  554.             $params['section'] = $section;
    555. 

  555.         }
    556. 

  556.         if ($this->ecTimestamp != null && $detectEC == true) {
    557. 

  557.             $params['basetimestamp'] = $this->ecTimestamp;
    558. 

  558.             $this->ecTimestamp = null;
    559. 

  559.         }
    560. 

  560.         if ($maxlag!='') {
    561. 

  561.             $maxlag='&maxlag='.$maxlag;
    562. 

  562.         }
    563. 

  563. 		$sleep=10;
    564. 

  564. 		do{
    565. 

  565.         $return = $this->query('?action=edit&format=php'.$maxlag,$params);
    566. 

  566. 		//if we didnt get a maxlag error we are done
    567. 

  567. 		if($return['error']['code'] != "maxlag"){return $return;}
    568. 

  568. 		if($sleep < 60) {$sleep = $sleep + 1;}
    569. 

  569. 		echo "\nSleeping for $sleep due to Maxlag! ".$return['error']['info']." seconds\n";
    570. 

  570. 		sleep($sleep);
    571. 

  571. 		} while(true);
    572. 

  572.     }
    573. 

  573. 

  574.     /**
    575. 

  575.     * Add a text at the bottom of a page
    576. 

  576.     * @param $page The page we're working with.
    577. 

  577.     * @param $text The text that you want to add.
    578. 

  578.     * @param $summary Edit summary to use.
    579. 

  579.     * @param $minor Whether or not to mark edit as minor.  (Default false)
    580. 

  580.     * @param $bot Whether or not to mark edit as a bot edit.  (Default true)
    581. 

  581.     * @return api result
    582. 

  582.     **/
    583. 

  583.     function addtext( $page, $text, $summary = '', $minor = false, $bot = true )
    584. 

  584.     {
    585. 

  585.         $data = $this->getpage( $page );
    586. 

  586.         $data.= "\n" . $text;
    587. 

  587.         return $this->edit( $page, $data, $summary, $minor, $bot );
    588. 

  588.     }
    589. 

  589.     
    590. 

  590.     /**
    591. 

  591.      * Moves a page.
    592. 

  592.      * @param $old Name of page to move.
    593. 

  593.      * @param $new New page title.
    594. 

  594.      * @param $reason Move summary to use.
    595. 

  595.      * @param $movetalk Move the page's talkpage as well.
    596. 

  596.      * @return api result
    597. 

  597.      **/
    598. 

  598.     function move ($old,$new,$reason,$options=null) {
    599. 

  599.         if ($this->token==null) {
    600. 

  600.             $this->token = $this->getedittoken();
    601. 

  601.         }
    602. 

  602.         $params = array(
    603. 

  603.             'from' => $old,
    604. 

  604.             'to' => $new,
    605. 

  605.             'token' => $this->token,
    606. 

  606.             'reason' => $reason
    607. 

  607.         );
    608. 

  608.         if ($options != null) {
    609. 

  609.             $option = explode('|',$options);
    610. 

  610.             foreach ($option as $o) {
    611. 

  611.                 $params[$o] = true;
    612. 

  612.             }
    613. 

  613.         }
    614. 

  614.         return $this->query('?action=move&format=php',$params);
    615. 

  615.     }
    616. 

  616. 

  617.     /**
    618. 

  618.      * Rollback an edit.
    619. 

  619.      * @param $title Title of page to rollback.
    620. 

  620.      * @param $user Username of last edit to the page to rollback.
    621. 

  621.      * @param $reason Edit summary to use for rollback.
    622. 

  622.      * @param $bot mark the rollback as bot.
    623. 

  623.      * @return api result
    624. 

  624.      **/
    625. 

  625.     function rollback ($title,$user,$reason=null,$bot=false) {
    626. 

  626.         $ret = $this->query('?action=query&prop=revisions&rvtoken=rollback&titles='.urlencode($title).'&format=php');
    627. 

  627.         foreach ($ret['query']['pages'] as $x) {
    628. 

  628.             $token = $x['revisions'][0]['rollbacktoken'];
    629. 

  629.             break;
    630. 

  630.         }
    631. 

  631.         $params = array(
    632. 

  632.             'title' => $title,
    633. 

  633.             'user' => $user,
    634. 

  634.             'token' => $token
    635. 

  635.         );
    636. 

  636.         if ($bot) {
    637. 

  637.             $params['markbot'] = true;
    638. 

  638.         }
    639. 

  639.         if ($reason != null) { $params['summary'] = $reason; }
    640. 

  640.             return $this->query('?action=rollback&format=php',$params);
    641. 

  641.         }
    642. 

  642. 

  643.     /**
    644. 

  644.      * Blocks a user.
    645. 

  645.      * @param $user The user to block.
    646. 

  646.      * @param $reason The block reason.
    647. 

  647.      * @param $expiry The block expiry.
    648. 

  648.      * @param $options a piped string containing the block options.
    649. 

  649.      * @return api result
    650. 

  650.      **/
    651. 

  651.     function block ($user,$reason='vand',$expiry='infinite',$options=null,$retry=true) {
    652. 

  652.         if ($this->token==null) {
    653. 

  653.             $this->token = $this->getedittoken();
    654. 

  654.         }
    655. 

  655.         $params = array(
    656. 

  656.             'expiry' => $expiry,
    657. 

  657.             'user' => $user,
    658. 

  658.             'reason' => $reason,
    659. 

  659.             'token' => $this->token
    660. 

  660.         );
    661. 

  661.         if ($options != null) {
    662. 

  662.             $option = explode('|',$options);
    663. 

  663.             foreach ($option as $o) {
    664. 

  664.                 $params[$o] = true;
    665. 

  665.             }
    666. 

  666.         }
    667. 

  667.         $ret = $this->query('?action=block&format=php',$params);
    668. 

  668.         /* Retry on a failed token. */
    669. 

  669.         if ($retry and $ret['error']['code']=='badtoken') {
    670. 

  670.             $this->token = $this->getedittoken();
    671. 

  671.             return $this->block($user,$reason,$expiry,$options,false);
    672. 

  672.         }
    673. 

  673.         return $ret;
    674. 

  674.     }
    675. 

  675. 

  676.     /**
    677. 

  677.      * Unblocks a user.
    678. 

  678.      * @param $user The user to unblock.
    679. 

  679.      * @param $reason The unblock reason.
    680. 

  680.      * @return api result
    681. 

  681.      **/
    682. 

  682.     function unblock ($user,$reason) {
    683. 

  683.         if ($this->token==null) {
    684. 

  684.             $this->token = $this->getedittoken();
    685. 

  685.         }
    686. 

  686.         $params = array(
    687. 

  687.             'user' => $user,
    688. 

  688.             'reason' => $reason,
    689. 

  689.             'token' => $this->token
    690. 

  690.         );
    691. 

  691.         return $this->query('?action=unblock&format=php',$params);
    692. 

  692.     }
    693. 

  693. 

  694.     /**
    695. 

  695.      * Emails a user.
    696. 

  696.      * @param $target The user to email.
    697. 

  697.      * @param $subject The email subject.
    698. 

  698.      * @param $text The body of the email.
    699. 

  699.      * @param $ccme Send a copy of the email to the user logged in.
    700. 

  700.      * @return api result
    701. 

  701.      **/
    702. 

  702.     function email ($target,$subject,$text,$ccme=false) {
    703. 

  703.         if ($this->token==null) {
    704. 

  704.             $this->token = $this->getedittoken();
    705. 

  705.         }
    706. 

  706.         $params = array(
    707. 

  707.             'target' => $target,
    708. 

  708.             'subject' => $subject,
    709. 

  709.             'text' => $text,
    710. 

  710.             'token' => $this->token
    711. 

  711.         );
    712. 

  712.         if ($ccme) {
    713. 

  713.             $params['ccme'] = true;
    714. 

  714.         }
    715. 

  715.         return $this->query('?action=emailuser&format=php',$params);
    716. 

  716.     }
    717. 

  717. 

  718.     /**
    719. 

  719.      * Deletes a page.
    720. 

  720.      * @param $title The page to delete.
    721. 

  721.      * @param $reason The delete reason.
    722. 

  722.      * @return api result
    723. 

  723.      **/
    724. 

  724.     function delete ($title,$reason) {
    725. 

  725.         if ($this->token==null) {
    726. 

  726.             $this->token = $this->getedittoken();
    727. 

  727.         }
    728. 

  728.         $params = array(
    729. 

  729.             'title' => $title,
    730. 

  730.             'reason' => $reason,
    731. 

  731.             'token' => $this->token
    732. 

  732.         );
    733. 

  733.         return $this->query('?action=delete&format=php',$params);
    734. 

  734.     }
    735. 

  735. 

  736.     /**
    737. 

  737.      * Undeletes a page.
    738. 

  738.      * @param $title The page to undelete.
    739. 

  739.      * @param $reason The undelete reason.
    740. 

  740.      * @return api result
    741. 

  741.      **/
    742. 

  742.     function undelete ($title,$reason) {
    743. 

  743.         if ($this->token==null) {
    744. 

  744.             $this->token = $this->getedittoken();
    745. 

  745.         }
    746. 

  746.         $params = array(
    747. 

  747.             'title' => $title,
    748. 

  748.             'reason' => $reason,
    749. 

  749.             'token' => $this->token
    750. 

  750.         );
    751. 

  751.         return $this->query('?action=undelete&format=php',$params);
    752. 

  752.     }
    753. 

  753. 

  754.     /**
    755. 

  755.      * (Un)Protects a page.
    756. 

  756.      * @param $title The page to (un)protect.
    757. 

  757.      * @param $protections The protection levels (e.g. 'edit=autoconfirmed|move=sysop')
    758. 

  758.      * @param $expiry When the protection should expire (e.g. '1 day|infinite')
    759. 

  759.      * @param $reason The (un)protect reason.
    760. 

  760.      * @param $cascade Enable cascading protection? (defaults to false)
    761. 

  761.      * @return api result
    762. 

  762.      **/
    763. 

  763.     function protect ($title,$protections,$expiry,$reason,$cascade=false) {
    764. 

  764.         if ($this->token==null) {
    765. 

  765.             $this->token = $this->getedittoken();
    766. 

  766.         }
    767. 

  767.         $params = array(
    768. 

  768.             'title' => $title,
    769. 

  769.             'protections' => $protections,
    770. 

  770.             'expiry' => $expiry,
    771. 

  771.             'reason' => $reason,
    772. 

  772.             'token' => $this->token
    773. 

  773.         );
    774. 

  774.         if ($cascade) {
    775. 

  775.             $params['cascade'] = true;
    776. 

  776.         }
    777. 

  777.         return $this->query('?action=protect&format=php',$params);
    778. 

  778.     }
    779. 

  779. 

  780.     /**
    781. 

  781.      * Uploads an image.
    782. 

  782.      * @param $page The destination file name.
    783. 

  783.      * @param $file The local file path.
    784. 

  784.      * @param $desc The upload discrption (defaults to '').
    785. 

  785.      **/
    786. 

  786.      function upload ($page,$file,$desc='') {
    787. 

  787.         if ($this->token == null) {
    788. 

  788.                 $this->token = $this->getedittoken();
    789. 

  789.         }
    790. 

  790.         $params = array(
    791. 

  791.                 'filename'        => $page,
    792. 

  792.                 'comment'         => $desc,
    793. 

  793.                 'text'            => $desc,
    794. 

  794.                 'token'           => $this->token,
    795. 

  795.                 'ignorewarnings'  => '1',
    796. 

  796.                 'file'            => '@'.$file
    797. 

  797.         );
    798. 

  798.         return $this->query('?action=upload&format=php',$params);
    799. 

  799.      }
    800. 

  800.     
    801. 

  801.     /*
    802. 

  802.     $page - page
    803. 

  803.     $revs - rev ids to delete (seperated with ,)
    804. 

  804.     $comment - delete comment
    805. 

  805.     */
    806. 

  806.     function revdel ($page,$revs,$comment) {
    807. 

  807.         
    808. 

  808.         if ($this->token==null) {
    809. 

  809.             $this->token = $this->getedittoken();
    810. 

  810.         }
    811. 

  811.         
    812. 

  812.         $post = array(
    813. 

  813.             'wpEditToken'       => $this->token,
    814. 

  814.             'ids' => $revs,
    815. 

  815.             'target' => $page,
    816. 

  816.             'type' => 'revision',
    817. 

  817.             'wpHidePrimary' => 1,
    818. 

  818.             'wpHideComment' => 1,
    819. 

  819.             'wpHideUser' => 0,
    820. 

  820.             'wpRevDeleteReasonList' => 'other',
    821. 

  821.             'wpReason' => $comment,
    822. 

  822.             'wpSubmit' => 'Apply to selected revision(s)'
    823. 

  823.         );
    824. 

  824.         return $this->http->post(str_replace('api.php','index.php',$this->url).'?title=Special:RevisionDelete&action=submit',$post);
    825. 

  825.     }
    826. 

  826. 

  827.     /**
    828. 

  828.      * Creates a new account.
    829. 

  829.      * Uses index.php as there is no api to create accounts yet :(
    830. 

  830.      * @param $username The username the new account will have.
    831. 

  831.      * @param $password The password the new account will have.
    832. 

  832.      * @param $email The email the new account will have.
    833. 

  833.      **/
    834. 

  834.     function createaccount ($username,$password,$email=null) {
    835. 

  835.         $post = array(
    836. 

  836.             'wpName' => $username,
    837. 

  837.             'wpPassword' => $password,
    838. 

  838.             'wpRetype' => $password,
    839. 

  839.             'wpEmail' => $email,
    840. 

  840.             'wpRemember' => 0,
    841. 

  841.             'wpIgnoreAntiSpoof' => 0,
    842. 

  842.             'wpCreateaccount' => 'Create account',
    843. 

  843.         );
    844. 

  844.         return $this->http->post(str_replace('api.php','index.php',$this->url).'?title=Special:UserLogin&action=submitlogin&type=signup',$post);
    845. 

  845.     }
    846. 

  846. 

  847.     /**
    848. 

  848.      * Changes a users rights.
    849. 

  849.      * @param $user   The user we're working with.
    850. 

  850.      * @param $add    A pipe-separated list of groups you want to add.
    851. 

  851.      * @param $remove A pipe-separated list of groups you want to remove.
    852. 

  852.      * @param $reason The reason for the change (defaults to '').
    853. 

  853.      **/
    854. 

  854.     function userrights ($user,$add,$remove,$reason='') {
    855. 

  855.         // get the userrights token
    856. 

  856.         $token = $this->query('?action=query&list=users&ususers='.urlencode($user).'&ustoken=userrights&format=php');
    857. 

  857.         $token = $token['query']['users'][0]['userrightstoken'];
    858. 

  858.         $params = array(
    859. 

  859.             'user' => $user,
    860. 

  860.             'token' => $token,
    861. 

  861.             'add' => $add,
    862. 

  862.             'remove' => $remove,
    863. 

  863.             'reason' => $reason
    864. 

  864.         );
    865. 

  865.         return $this->query('?action=userrights&format=php',$params);
    866. 

  866.     }
    867. 

  867.     
    868. 

  868.     /**
    869. 

  869.      * Gets the number of images matching a particular sha1 hash.
    870. 

  870.      * @param $hash The sha1 hash for an image.
    871. 

  871.      * @return The number of images with the same sha1 hash.
    872. 

  872.      **/
    873. 

  873.     function imagematches ($hash) {
    874. 

  874.         $x = $this->query('?action=query&list=allimages&format=php&aisha1='.$hash);
    875. 

  875.         return count($x['query']['allimages']);
    876. 

  876.     }
    877. 

  877. 

  878.     /**  BMcN 2012-09-16
    879. 

  879.      * Retrieve a media file's actual location.
    880. 

  880.      * @param $page The "File:" page on the wiki which the URL of is desired.
    881. 

  881.      * @return The URL pointing directly to the media file (Eg http://upload.mediawiki.org/wikipedia/en/1/1/Example.jpg)
    882. 

  882.      **/
    883. 

  883.     function getfilelocation ($page) {
    884. 

  884.         $x = $this->query('?action=query&format=php&prop=imageinfo&titles='.urlencode($page).'&iilimit=1&iiprop=url');
    885. 

  885.         foreach ($x['query']['pages'] as $ret ) {
    886. 

  886.             if (isset($ret['imageinfo'][0]['url'])) {
    887. 

  887.                 return $ret['imageinfo'][0]['url'];
    888. 

  888.             } else
    889. 

  889.                 return false;
    890. 

  890.         }
    891. 

  891.     }
    892. 

  892.  
    893. 

  893.     /**  BMcN 2012-09-16
    894. 

  894.      * Retrieve a media file's uploader.
    895. 

  895.      * @param $page The "File:" page
    896. 

  896.      * @return The user who uploaded the topmost version of the file.
    897. 

  897.      **/
    898. 

  898.     function getfileuploader ($page) {
    899. 

  899.         $x = $this->query('?action=query&format=php&prop=imageinfo&titles='.urlencode($page).'&iilimit=1&iiprop=user');
    900. 

  900.         foreach ($x['query']['pages'] as $ret ) {
    901. 

  901.             if (isset($ret['imageinfo'][0]['user'])) {
    902. 

  902.                 return $ret['imageinfo'][0]['user'];
    903. 

  903.             } else
    904. 

  904.                 return false;
    905. 

  905.         }
    906. 

  906.     }
    907. 

  907. 	
    908. 

  908. 	/**
    909. 

  909.      * Gets the date of the last edit the user has made
    910. 

  910.      * @param $user The username for which to get the last edit
    911. 

  911.      * @return The timestamp of the last edit e.g. 2012-02-28T13:10:12Z
    912. 

  912. 	 * @author Addshore
    913. 

  913.      **/
    914. 

  914.     function lastedit ($user) {
    915. 

  915.         $x = $this->query('?action=query&list=usercontribs&uclimit=1&format=php&acuser='.urlencode($user));
    916. 

  916.         return $x['query']['usercontribs'][0]['timestamp'];
    917. 

  917.     }
    918. 

  918. 	
    919. 

  919. 	/**
    920. 

  920.      * Gets the time stamp of the last edit a user made on an article
    921. 

  921.      * @param $user The username for which to get the last edit
    922. 

  922. 	 * @param $page The page we want to check
    923. 

  923.      * @return The timestamp of the last edit e.g. 2012-02-28T13:10:12Z
    924. 

  924. 	 * @author Addshore
    925. 

  925.      **/
    926. 

  926. 	function lasteditonpage ($user,$page) {
    927. 

  927. 		$x = $this->query('?action=query&prop=revisions&format=php&titles='.urlencode($page).'&rvlimit=1&rvuser='.urlencode($user));
    928. 

  928. 		return $x['query']['pages'][0]['revisions'][0]['timestamp'];
    929. 

  929. 	}
    930. 

  930. 	
    931. 

  931. 	/**
    932. 

  932.      * Gets the date of the last edit the user has made
    933. 

  933.      * @param $user The username for which to get the first edit
    934. 

  934.      * @return The timestamp of the last edit e.g. 2012-02-28T13:10:12Z
    935. 

  935. 	 * @author Addshore
    936. 

  936.      **/
    937. 

  937.     function firstedit ($user) {
    938. 

  938.         $x = $this->query('?action=query&list=usercontribs&uclimit=1&format=php&acuser='.urlencode($user));
    939. 

  939.         return $x['query-continue'][0]['ucstart'];
    940. 

  940.     }
    941. 

  941. 	
    942. 

  942. 	/**
    943. 

  943.      * Gets the date of the last edit the user has made
    944. 

  944.      * @param $page The name of the page to be checks
    945. 

  945.      * @return Array of each protection status ([0]/[1]/[2])([type],[level],[expiry])
    946. 

  946. 	 * @author Addshore
    947. 

  947.      **/
    948. 

  948. 	function protectionstatus ($page){
    949. 

  949. 	//http://en.wikipedia.org/w/api.php?action=query&titles=Cyprus&prop=info&inprop=protection
    950. 

  950. 	    $x = $this->query('?action=query&format=php&prop=info&inprop=protection&titles='.urlencode($page));
    951. 

  951. 		foreach ($x['query']['pages'] as $page)
    952. 

  952. 		{
    953. 

  953. 			return $page['protection'];
    954. 

  954. 		}
    955. 

  955. 	
    956. 

  956. 	}
    957. 

  957. 	
    958. 

  958. 	/**
    959. 

  959.      * Gets the date of the last edit the user has made
    960. 

  960.      * @param $page The name of the page to be checked
    961. 

  961.      * @return Array of entities the page can be found in on wikidata
    962. 

  962. 	 * @author Addshore
    963. 

  963.      **/
    964. 

  964. 	function wikidatasitelinks ($page,$lang = "en"){
    965. 

  965. 		$x = $this->http->get("http://wikidata.org/w/api.php?action=wbgetentities&sites=".urlencode($lang)."wiki&props=sitelinks&format=php&titles=".urlencode($page));
    966. 

  966. 		$x = unserialize($x);
    967. 

  967. 		if($x['success'] == 1)
    968. 

  968. 		{
    969. 

  969. 			return $x['entities'];
    970. 

  970. 		}
    971. 

  971. 	}
    972. 

  972. 	
    973. 

  973. }
    974. 

  974. 

  975. /**
    976. 

  976.  * This class extends the wiki class to provide an high level API for the most commons actions.
    977. 

  977.  * @author Fale
    978. 

  978.  **/
    979. 

  979. class extended extends wikipedia
    980. 

  980. {
    981. 

  981.     /**
    982. 

  982.      * Add a category to a page
    983. 

  983.      * @param $page The page we're working with.
    984. 

  984.      * @param $category The category that you want to add.
    985. 

  985.      * @param $summary Edit summary to use.
    986. 

  986.      * @param $minor Whether or not to mark edit as minor.  (Default false)
    987. 

  987.      * @param $bot Whether or not to mark edit as a bot edit.  (Default true)
    988. 

  988.      * @return api result
    989. 

  989.      **/
    990. 

  990.     function addcategory( $page, $category, $summary = '', $minor = false, $bot = true )
    991. 

  991.     {
    992. 

  992.         $data = $this->getpage( $page );
    993. 

  993.         $data.= "\n[[Category:" . $category . "]]";
    994. 

  994.         return $this->edit( $page, $data, $summary, $minor, $bot );
    995. 

  995.     }
    996. 

  996. 

  997.     /**
    998. 

  998.      * Find a string
    999. 

  999.      * @param $page The page we're working with.
    1000. 

  1000.      * @param $string The string that you want to find.
    1001. 

  1001.      * @return bool value (1 found and 0 not-found)
    1002. 

  1002.      **/
    1003. 

  1003.     function findstring( $page, $string )
    1004. 

  1004.     {
    1005. 

  1005.         $data = $this->getpage( $page );
    1006. 

  1006.         if( strstr( $data, $string ) )
    1007. 

  1007.             return 1;
    1008. 

  1008.         else
    1009. 

  1009.             return 0;
    1010. 

  1010.     }
    1011. 

  1011. 

  1012.     /**
    1013. 

  1013.      * Replace a string
    1014. 

  1014.      * @param $page The page we're working with.
    1015. 

  1015.      * @param $string The string that you want to replace.
    1016. 

  1016.      * @param $newstring The string that will replace the present string.
    1017. 

  1017.      * @return the new text of page
    1018. 

  1018.      **/
    1019. 

  1019.     function replacestring( $page, $string, $newstring )
    1020. 

  1020.     {
    1021. 

  1021.         $data = $this->getpage( $page );
    1022. 

  1022.         return str_replace( $string, $newstring, $data );
    1023. 

  1023.     }
    1024. 

  1024.     
    1025. 

  1025.     /**
    1026. 

  1026.      * Get a template from a page
    1027. 

  1027.      * @param $page The page we're working with
    1028. 

  1028.      * @param $template The name of the template we are looking for
    1029. 

  1029.      * @return the searched (NULL if the template has not been found)
    1030. 

  1030.      **/
    1031. 

  1031.     function gettemplate( $page, $template ) {
    1032. 

  1032.        $data = $this->getpage( $page );
    1033. 

  1033.        $template = preg_quote( $template, " " );
    1034. 

  1034.        $r = "/{{" . $template . "(?:[^{}]*(?:{{[^}]*}})?)+(?:[^}]*}})?/i";
    1035. 

  1035.        preg_match_all( $r, $data, $matches );
    1036. 

  1036.        if( isset( $matches[0][0] ) )
    1037. 

  1037.            return $matches[0][0];
    1038. 

  1038.        else
    1039. 

  1039.            return NULL;
    1040. 

  1040.      }    
    1041. 

  1041. }
    1042. 

  1042. 

  1043. /**
    1044. 

  1044.  * This class extends the wiki class to provide an high level API for the most commons actions.
    1045. 

  1045.  * @author Sean
    1046. 

  1046.  */
    1047. 

  1047. class lyricwiki extends extended
    1048. 

  1048. {
    1049. 

  1049. 	/**
    1050. 

  1050. 	 * Constructor. Note that the parameters are in different order (primarily because it
    1051. 

  1051. 	 * is very unlikely the user will want to change the URL of LyricWiki, and fairly likely
    1052. 

  1052. 	 * that they may want to set a username/password).
    1053. 

  1053. 	 *
    1054. 

  1054. 	 * If not logging in, the caller can safely call this with no parameters.
    1055. 

  1055. 	 */
    1056. 

  1056. 	function __construct ($hu=null, $hp=null, $url='http://lyrics.wikia.com/api.php') {
    1057. 

  1057. 		parent::__construct($url,$hu,$hp);
    1058. 

  1058. 	}
    1059. 

  1059. 

  1060. 	/**
    1061. 

  1061. 	 * Returns basic info about a song as well as a fair-use snippet of
    1062. 

  1062. 	 * lyrics and a link to the LyricWiki page where the full lyrics can
    1063. 

  1063. 	 * be viewed (full lyrics are no longer available via the API because
    1064. 

  1064. 	 * of licensing issues - publishers won't allow that for free).
    1065. 

  1065. 	 *
    1066. 

  1066. 	 * @return associative array containing the song data. (TODO: Document what happens on No Match)
    1067. 

  1067. 	 */
    1068. 

  1068. 	function getSong($artist, $song){
    1069. 

  1069. 		return $this->query('?action=lyrics&func=getSong&fmt=php&artist='.urlencode($artist).'&song='.urlencode($song));
    1070. 

  1070. 	} // end getSong()
    1071. 

  1071. 

  1072. 	/**
    1073. 

  1073. 	 * Returns basic info about an artist as well as their
    1074. 

  1074. 	 * entire discography.
    1075. 

  1075. 	 *
    1076. 

  1076. 	 * @param - artist - a string containing the name of the artist (spaces or underscores are fine)
    1077. 

  1077. 	 * @return an associative array containing the artist data (TODO: Document what happens on No Match)
    1078. 

  1078. 	 */
    1079. 

  1079. 	function getArtist($artist){
    1080. 

  1080. 		return $this->query('?action=lyrics&func=getArtist&fmt=php&artist='.urlencode($artist));
    1081. 

  1081. 	} // end getArtist()
    1082. 

  1082. 	
    1083. 

  1083. 	/**
    1084. 

  1084. 	 * Returns hometown information (country, state/province, hometown) for
    1085. 

  1085. 	 * the given artist if it can be found.
    1086. 

  1086. 	 *
    1087. 

  1087. 	 *
    1088. 

  1088. 	 * @param - artist - a string containing the name of the artist (spaces or underscores are fine)
    1089. 

  1089. 	 * @return an associative array whose keys are 'country', 'state', and 'hometown'. If the
    1090. 

  1090. 	 * artist's hometown could not be found, then the values corresponding to those keys will
    1091. 

  1091. 	 * be empty strings.
    1092. 

  1092. 	 */
    1093. 

  1093. 	function getHometown($artist){
    1094. 

  1094. 		return $this->query('?action=lyrics&func=getHometown&fmt=php&artist='.urlencode($artist));
    1095. 

  1095. 	} // end getHometown()
    1096. 

  1096. 	
    1097. 

  1097. 	/**
    1098. 

  1098. 	 * Gets information about the Song Of The Day (SOTD).
    1099. 

  1099. 	 *
    1100. 

  1100. 	 * @return an associative array representing the current Song of the Day. The
    1101. 

  1101. 	 * fields returned include {artist, song, lyrics (just a snippet), url of song,
    1102. 

  1102. 	 * page_namespace, page_id, isOnTakedownList, nominatedBy, reason}
    1103. 

  1103. 	 */
    1104. 

  1104. 	function getSotd(){
    1105. 

  1105. 		return $this->query('?action=lyrics&func=getSotd&fmt=php');
    1106. 

  1106. 	} // end getSotd()
    1107. 

  1107. 

  1108. 	/**
    1109. 

  1109.          * Returns information about the currently most-popular songs.
    1110. 

  1110. 	 *
    1111. 

  1111. 	 * @return an array containing associative arrays of the data for each top song.
    1112. 

  1112. 	 */
    1113. 

  1113. 	function getTopSongs(){
    1114. 

  1114. 		return $this->query('?action=lyrics&func=getTopSongs&fmt=php');
    1115. 

  1115. 	} // end getTopSongs()
    1116. 

  1116. 

  1117. 	/**
    1118. 

  1118. 	 * Allows easy submission of lyrics for a new song to LyricWiki.
    1119. 

  1119. 	 *
    1120. 

  1120. 	 * @param artist - the artist of the song
    1121. 

  1121. 	 * @param song - the name of the song (following page naming conventions: http://lyrics.wikia.com/LW:PN ).
    1122. 

  1122. 	 * @param lyrics - the full lyrics to submit
    1123. 

  1123. 	 * @param language - optional string for the language (the language name should be in English - eg: "Swedish" not "Svenska").
    1124. 

  1124. 	 * @param onAlbums - an array which contains strings which are album titles.
    1125. 

  1125. 	 * @param overwriteIfExists - true means that this page data (the lyrics and onAlbums) will overwrite
    1126. 

  1126. 	 *                     the page if it already exists. false means that nothing will be changed if the
    1127. 

  1127. 	 *                     page already exists.
    1128. 

  1128. 	 */
    1129. 

  1129. 	function postSong($artist, $song, $lyrics, $language="", $onAlbums=array(), $overwriteIfExists=false){
    1130. 

  1130. 		$params = array(
    1131. 

  1131.             		'artist' => $artist,
    1132. 

  1132.             		'song' => $song,
    1133. 

  1133.            		 'lyrics' => $lyrics,
    1134. 

  1134. 			'overwriteIfExists' => ($overwriteIfExists ? "1" : "0"),
    1135. 

  1135.         	);
    1136. 

  1136. 		if(!empty($language)){
    1137. 

  1137. 			$params['language'] = $language;
    1138. 

  1138. 		}
    1139. 

  1139. 		if(count($onAlbums) > 0){
    1140. 

  1140. 			$params['onAlbums'] = implode("|", $onAlbums);
    1141. 

  1141. 		}
    1142. 

  1142.         	return $this->query('?action=lyrics&func=postSong&fmt=php',$params);
    1143. 

  1143. 	} // end postSong()
    1144. 

  1144. 

  1145. } // end class lyricwiki
    1146. 

  1146. 

  1147.  
    1148.