Hooks.php
No OneTemporary
Actions

Size

8 KB

Referenced Files

None

Subscribers

None

Hooks.php
View Options

	<?php

	namespace MediaWiki\Extension\SpamBlacklist;

	use LogicException;
	use MediaWiki\Api\ApiMessage;
	use MediaWiki\Content\Content;
	use MediaWiki\Content\IContentHandlerFactory;
	use MediaWiki\Content\Renderer\ContentRenderer;
	use MediaWiki\Context\IContextSource;
	use MediaWiki\EditPage\EditPage;
	use MediaWiki\ExternalLinks\LinkFilter;
	use MediaWiki\Hook\EditFilterHook;
	use MediaWiki\Hook\EditFilterMergedContentHook;
	use MediaWiki\Hook\UploadVerifyUploadHook;
	use MediaWiki\Html\Html;
	use MediaWiki\Message\Message;
	use MediaWiki\Parser\ParserOptions;
	use MediaWiki\Parser\ParserOutput;
	use MediaWiki\Permissions\PermissionManager;
	use MediaWiki\Revision\RevisionRecord;
	use MediaWiki\Status\Status;
	use MediaWiki\Storage\EditResult;
	use MediaWiki\Storage\Hook\PageSaveCompleteHook;
	use MediaWiki\Storage\Hook\ParserOutputStashForEditHook;
	use MediaWiki\Storage\PageEditStash;
	use MediaWiki\User\Hook\UserCanSendEmailHook;
	use MediaWiki\User\User;
	use MediaWiki\User\UserIdentity;
	use UploadBase;
	use Wikimedia\Assert\PreconditionException;
	use Wikimedia\Message\MessageSpecifier;
	use WikiPage;

	/**
	* Hooks for the spam blacklist extension
	*/
	class Hooks implements
	EditFilterHook,
	EditFilterMergedContentHook,
	UploadVerifyUploadHook,
	PageSaveCompleteHook,
	ParserOutputStashForEditHook,
	UserCanSendEmailHook
	{

	/** @var PermissionManager */
	private $permissionManager;

	/** @var PageEditStash */
	private $pageEditStash;

	/** @var ContentRenderer */
	private $contentRenderer;

	/** @var IContentHandlerFactory */
	private $contentHandlerFactory;

	/**
	* @param PermissionManager $permissionManager
	* @param PageEditStash $pageEditStash
	* @param ContentRenderer $contentRenderer
	* @param IContentHandlerFactory $contentHandlerFactory
	*/
	public function __construct(
	PermissionManager $permissionManager,
	PageEditStash $pageEditStash,
	ContentRenderer $contentRenderer,
	IContentHandlerFactory $contentHandlerFactory
	) {
	$this->permissionManager = $permissionManager;
	$this->pageEditStash = $pageEditStash;
	$this->contentRenderer = $contentRenderer;
	$this->contentHandlerFactory = $contentHandlerFactory;
	}

	/**
	* Hook function for EditFilterMergedContent
	*
	* @param IContextSource $context
	* @param Content $content
	* @param Status $status
	* @param string $summary
	* @param User $user
	* @param bool $minoredit
	*
	* @return bool
	*/
	public function onEditFilterMergedContent(
	IContextSource $context,
	Content $content,
	Status $status,
	$summary,
	User $user,
	$minoredit
	) {
	if ( $this->permissionManager->userHasRight( $user, 'sboverride' ) ) {
	return true;
	}

	$title = $context->getTitle();
	try {
	// Try getting the update directly
	$updater = $context->getWikiPage()->getCurrentUpdate();
	$pout = $updater->getParserOutputForMetaData();
	} catch ( PreconditionException \| LogicException $exception ) {
	$stashedEdit = $this->pageEditStash->checkCache(
	$title,
	$content,
	$user
	);
	if ( $stashedEdit ) {
	// Try getting the value from edit stash
	/** @var ParserOutput $output */
	$pout = $stashedEdit->output;
	} else {
	// Last resort, parse the page.
	$pout = $this->contentRenderer->getParserOutput(
	$content,
	$title,
	null,
	null,
	false
	);
	}
	}
	$links = LinkFilter::getIndexedUrlsNonReversed( array_keys( $pout->getExternalLinks() ) );
	// HACK: treat the edit summary as a link if it contains anything
	// that looks like it could be a URL or e-mail address.
	if ( preg_match( '/\S(\.[^\s\d]{2,}\|[\/@]\S)/', $summary ) ) {
	$links[] = $summary;
	}

	$spamObj = BaseBlacklist::getSpamBlacklist();
	$matches = $spamObj->filter( $links, $title, $user );

	if ( $matches !== false ) {
	$error = new ApiMessage(
	wfMessage( 'spam-blacklisted-link', Message::listParam( $matches ) ),
	'spamblacklist',
	[
	'spamblacklist' => [ 'matches' => $matches ],
	]
	);
	$status->fatal( $error );
	return false;
	}

	return true;
	}

	/**
	* @param WikiPage $page
	* @param Content $content
	* @param ParserOutput $output
	* @param string $summary
	* @param User $user
	*/
	public function onParserOutputStashForEdit(
	$page,
	$content,
	$output,
	$summary,
	$user
	) {
	$links = LinkFilter::getIndexedUrlsNonReversed( array_keys( $output->getExternalLinks() ) );
	$spamObj = BaseBlacklist::getSpamBlacklist();
	$spamObj->warmCachesForFilter( $page->getTitle(), $links, $user );
	}

	/**
	* Verify that the user can send emails
	*
	* @param User $user
	* @param array &$hookErr
	* @return bool
	*/
	public function onUserCanSendEmail( $user, &$hookErr ) {
	if ( $this->permissionManager->userHasRight( $user, 'sboverride' ) ) {
	return true;
	}
	$blacklist = BaseBlacklist::getEmailBlacklist();
	if ( $blacklist->checkUser( $user ) ) {
	return true;
	}

	$hookErr = [ 'spam-blacklisted-email', 'spam-blacklisted-email-text', null ];

	// No other hook handler should run
	return false;
	}

	/**
	* Hook function for EditFilter
	* Confirm that a local blacklist page being saved is valid,
	* and toss back a warning to the user if it isn't.
	*
	* @param EditPage $editPage
	* @param string $text
	* @param string $section
	* @param string &$hookError
	* @param string $summary
	*/
	public function onEditFilter( $editPage, $text, $section, &$hookError, $summary ) {
	$title = $editPage->getTitle();
	$thisPageName = $title->getPrefixedDBkey();

	if ( !BaseBlacklist::isLocalSource( $title ) ) {
	wfDebugLog( 'SpamBlacklist',
	"Spam blacklist validator: [[$thisPageName]] not a local blacklist\n"
	);
	return;
	}

	$type = BaseBlacklist::getTypeFromTitle( $title );
	if ( $type === false ) {
	return;
	}

	$lines = explode( "\n", $text );

	$badLines = SpamRegexBatch::getBadLines( $lines, BaseBlacklist::getInstance( $type ) );
	if ( $badLines ) {
	wfDebugLog( 'SpamBlacklist',
	"Spam blacklist validator: [[$thisPageName]] given invalid input lines: " .
	implode( ', ', $badLines ) . "\n"
	);

	$badList = "*<code>" .
	implode( "</code>\n*<code>",
	array_map( 'wfEscapeWikiText', $badLines ) ) .
	"</code>\n";
	$hookError =
	Html::errorBox(
	wfMessage( 'spam-invalid-lines' )->numParams( $badLines )->parse() . "<br />" .
	$badList
	) .
	"\n<br clear='all' />\n";
	} else {
	wfDebugLog( 'SpamBlacklist',
	"Spam blacklist validator: [[$thisPageName]] ok or empty blacklist\n"
	);
	}
	}

	/**
	* Hook function for PageSaveComplete
	* Clear local spam blacklist caches on page save.
	*
	* @param WikiPage $wikiPage
	* @param UserIdentity $userIdentity
	* @param string $summary
	* @param int $flags
	* @param RevisionRecord $revisionRecord
	* @param EditResult $editResult
	*/
	public function onPageSaveComplete(
	$wikiPage,
	$userIdentity,
	$summary,
	$flags,
	$revisionRecord,
	$editResult
	) {
	if ( !BaseBlacklist::isLocalSource( $wikiPage->getTitle() ) ) {
	return;
	}

	// This sucks because every Blacklist needs to be cleared
	foreach ( BaseBlacklist::getBlacklistTypes() as $type => $class ) {
	$blacklist = BaseBlacklist::getInstance( $type );
	$blacklist->clearCache();
	}
	}

	/**
	* @param UploadBase $upload
	* @param User $user
	* @param array\|null $props
	* @param string $comment
	* @param string $pageText
	* @param array\|MessageSpecifier &$error
	*/
	public function onUploadVerifyUpload(
	UploadBase $upload,
	User $user,
	?array $props,
	$comment,
	$pageText,
	&$error
	) {
	if ( $this->permissionManager->userHasRight( $user, 'sboverride' ) ) {
	return;
	}

	$title = $upload->getTitle();

	// get the link from the not-yet-saved page content.
	$content = $this->contentHandlerFactory->getContentHandler( $title->getContentModel() )
	->unserializeContent( $pageText );
	$parserOptions = ParserOptions::newFromAnon();
	$output = $this->contentRenderer->getParserOutput( $content, $title, null, $parserOptions );
	$links = LinkFilter::getIndexedUrlsNonReversed( array_keys( $output->getExternalLinks() ) );

	// HACK: treat comment as a link if it contains anything
	// that looks like it could be a URL or e-mail address.
	if ( preg_match( '/\S(\.[^\s\d]{2,}\|[\/@]\S)/', $comment ) ) {
	$links[] = $comment;
	}
	if ( !$links ) {
	return;
	}

	$spamObj = BaseBlacklist::getSpamBlacklist();
	$matches = $spamObj->filter( $links, $title, $user );

	if ( $matches !== false ) {
	$error = new ApiMessage(
	wfMessage( 'spam-blacklisted-link', Message::listParam( $matches ) ),
	'spamblacklist',
	[
	'spamblacklist' => [ 'matches' => $matches ],
	]
	);
	}
	}
	}

File Metadata

Mime Type: text/x-php
Expires: Aug 15 2026, 16:54 (12 w, 3 d ago)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 4e/9e/2f9e8cf34af920688f2fb902cbbd
Default Alt Text: Hooks.php (8 KB)

Hooks.phpNo OneTemporaryActions

Hooks.phpView Options

File Metadata

Event Timeline

Hooks.php
No OneTemporary
Actions

Hooks.php
View Options