BotRiconferme\WikiController

Complexity

Total Complexity

17

Size/Duplication

Total Lines	200
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	editPage()	0	12	2
A	__construct()	0	2	1
A	getPageContent()	0	18	2
A	getTimeWithArticle()	0	9	2
A	login()	0	29	5
A	protectPage()	0	14	1
A	getToken()	0	15	2
A	hasOpposition()	0	15	1
A	getPageCreationTS()	0	14	1

<?php declare( strict_types=1 );

namespace BotRiconferme;

use BotRiconferme\Exception\EditException;
use BotRiconferme\Exception\LoginException;
use BotRiconferme\Exception\APIRequestException;
use BotRiconferme\Exception\MissingPageException;
use BotRiconferme\Request\RequestBase;

/**
 * Class for wiki interaction, contains some requests shorthands
 */
class WikiController {
	/** @var bool */
	private static $loggedIn = false;
	/** @var Logger */
	private $logger;
	/** @var string[] */
	private $tokens;

	public function __construct() {
		$this->logger = new Logger;
	}

	/**
	 * Gets the content of a wiki page
	 *
	 * @param string $title
	 * @return string
	 * @throws MissingPageException
	 */
	public function getPageContent( string $title ) : string {
		$this->logger->debug( "Retrieving page $title" );
		$params = [
			'action' => 'query',
			'titles' => $title,
			'prop' => 'revisions',
			'rvslots' => 'main',
			'rvprop' => 'content'
		];

		$req = RequestBase::newFromParams( $params );
		$data = $req->execute();
		$page = reset( $data->query->pages );
		if ( isset( $page->missing ) ) {
			throw new MissingPageException( $title );
		}

		return $page->revisions[0]->slots->main->{ '*' };
	}

	/**
	 * Basically a wrapper for action=edit
	 *
	 * @param array $params
	 * @throws EditException
	 */
	public function editPage( array $params ) {
		$this->login();

		$params = [
			'action' => 'edit',
			'token' => $this->getToken( 'csrf' ),
			'bot' => Config::getInstance()->get( 'bot-edits' )
		] + $params;

		$res = RequestBase::newFromParams( $params, true )->execute();
		if ( $res->edit->result !== 'Success' ) {
			throw new EditException( $res->edit->info );
		}
	}

	/**
	 * Get a localized version of article + day + time
	 *
	 * @param int $timestamp
	 * @return string
	 * @fixme Not the right place for this
	 */
	public static function getTimeWithArticle( int $timestamp ) : string {
		$oldLoc = setlocale( LC_TIME, 'it_IT', 'Italian_Italy', 'Italian' );
		$endTime = strftime( '%e %B alle %R', $timestamp );
		// Remove the left space if day has a single digit
		$endTime = ltrim( $endTime );
		$artic = in_array( date( 'j', $timestamp ), [ 8, 11 ] ) ? "l'" : "il ";
		setlocale( LC_TIME, $oldLoc );

		return $artic . $endTime;
	}

	/**
	 * @param string $page
	 * @return bool
	 * @fixme Not the right place for this
	 */
	public static function hasOpposition( string $page ) : bool {
		$params = [
			'action' => 'query',
			'prop' => 'revisions',
			'titles' => $page,
			'rvprop' => 'content',
			'rvslots' => 'main',
			'rvsection' => 4
		];
		$res = RequestBase::newFromParams( $params )->execute();
		$page = reset( $res->query->pages );
		$content = $page->revisions[0]->slots->main->{ '*' };
		// Let's hope that this is good enough...
		$votes = substr_count( $content, "\n\# *(?![#*])" );
		return $votes >= 15;
	}

	/**
	 * Login wrapper. Checks if we're already logged in and clears tokens cache
	 * @throws LoginException
	 */
	public function login() {
		if ( self::$loggedIn ) {
			$this->logger->debug( 'Already logged in' );
			return;
		}

		$this->logger->info( 'Logging in' );

		$params = [
			'action' => 'login',
			'lgname' => Config::getInstance()->get( 'username' ),
			'lgpassword' => Config::getInstance()->get( 'password' ),
			'lgtoken' => $this->getToken( 'login' )
		];

		try {
			$res = RequestBase::newFromParams( $params, true )->execute();
		} catch ( APIRequestException $e ) {
			throw new LoginException( $e->getMessage() );
		}

		if ( !isset( $res->login->result ) || $res->login->result !== 'Success' ) {
			throw new LoginException( 'Unknown error' );
		}

		self::$loggedIn = true;
		// Clear tokens cache
		$this->tokens = [];
		$this->logger->info( 'Login succeeded' );
	}

	/**
	 * Get a token, cached.
	 *
	 * @param string $type
	 * @return string
	 */
	public function getToken( string $type ) : string {
		if ( !isset( $this->tokens[ $type ] ) ) {
			$params = [
				'action' => 'query',
				'meta'   => 'tokens',
				'type'   => $type
			];

			$req = RequestBase::newFromParams( $params );
			$res = $req->execute();

			$this->tokens[ $type ] = $res->query->tokens->{ "{$type}token" };
		}

		return $this->tokens[ $type ];
	}

	/**
	 * Get the timestamp of the creation of the given page
	 *
	 * @param string $title
	 * @return int
	 */
	public function getPageCreationTS( string $title ) : int {
		$params = [
			'action' => 'query',
			'prop' => 'revisions',
			'titles' => $title,
			'rvprop' => 'timestamp',
			'rvslots' => 'main',
			'rvlimit' => 1,
			'rvdir' => 'newer'
		];

		$res = ( RequestBase::newFromParams( $params ) )->execute();
		$data = $res->query->pages;
		return strtotime( reset( $data )->revisions[0]->timestamp );
	}

	/**
	 * Sysop-level inifinite protection for a given page
	 *
	 * @param string $title
	 * @param string $reason
	 */
	public function protectPage( string $title, string $reason ) {
		$this->logger->info( "Protecting page $title" );
		$this->login();

		$params = [
			'action' => 'protect',
			'title' => $title,
			'protections' => 'edit=sysop|move=sysop',
			'expiry' => 'infinite',
			'reason' => $reason,
			'token' => $this->getToken( 'csrf' )
		];

		RequestBase::newFromParams( $params, true )->execute();
	}
}