PageUpdaterFactory.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use JobQueueGroup;
use Language;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Content\IContentHandlerFactory;
use MediaWiki\Content\Transform\ContentTransformer;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Parser\Parsoid\ParsoidOutputAccess;
use MediaWiki\Permissions\PermissionManager;
use MediaWiki\Revision\RevisionRenderer;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRoleRegistry;
use MediaWiki\User\TalkPageNotificationManager;
use MediaWiki\User\UserEditTracker;
use MediaWiki\User\UserGroupManager;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserNameUtils;
use MessageCache;
use ParserCache;
use Psr\Log\LoggerInterface;
use TitleFormatter;
use WANObjectCache;
use Wikimedia\Rdbms\ILBFactory;
use WikiPage;
 
class PageUpdaterFactory {
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::ArticleCountMethod,
        MainConfigNames::RCWatchCategoryMembership,
        MainConfigNames::PageCreationLog,
        MainConfigNames::UseAutomaticEditSummaries,
        MainConfigNames::ManualRevertSearchRadius,
        MainConfigNames::UseRCPatrol,
        MainConfigNames::ParsoidCacheConfig,
    ];
 
    private $revisionStore;
 
    private $revisionRenderer;
 
    private $slotRoleRegistry;
 
    private $parserCache;
 
    private $jobQueueGroup;
 
    private $messageCache;
 
    private $contLang;
 
    private $loadbalancerFactory;
 
    private $contentHandlerFactory;
 
    private $hookContainer;
 
    private $editResultCache;
 
    private $userNameUtils;
 
    private $logger;
 
    private $options;
 
    private $userEditTracker;
 
    private $userGroupManager;
 
    private $titleFormatter;
 
    private $contentTransformer;
 
    private $pageEditStash;
 
    private $talkPageNotificationManager;
 
    private $mainWANObjectCache;
 
    private $permissionManager;
 
    private $wikiPageFactory;
 
    private $softwareTags;
 
    private $parsoidOutputAccess;
 
    public function __construct(
        RevisionStore $revisionStore,
        RevisionRenderer $revisionRenderer,
        SlotRoleRegistry $slotRoleRegistry,
        ParserCache $parserCache,
        ParsoidOutputAccess $parsoidOutputAccess,
        JobQueueGroup $jobQueueGroup,
        MessageCache $messageCache,
        Language $contLang,
        ILBFactory $loadbalancerFactory,
        IContentHandlerFactory $contentHandlerFactory,
        HookContainer $hookContainer,
        EditResultCache $editResultCache,
        UserNameUtils $userNameUtils,
        LoggerInterface $logger,
        ServiceOptions $options,
        UserEditTracker $userEditTracker,
        UserGroupManager $userGroupManager,
        TitleFormatter $titleFormatter,
        ContentTransformer $contentTransformer,
        PageEditStash $pageEditStash,
        TalkPageNotificationManager $talkPageNotificationManager,
        WANObjectCache $mainWANObjectCache,
        PermissionManager $permissionManager,
        WikiPageFactory $wikiPageFactory,
        array $softwareTags
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
 
        $this->revisionStore = $revisionStore;
        $this->revisionRenderer = $revisionRenderer;
        $this->slotRoleRegistry = $slotRoleRegistry;
        $this->parserCache = $parserCache;
        $this->parsoidOutputAccess = $parsoidOutputAccess;
        $this->jobQueueGroup = $jobQueueGroup;
        $this->messageCache = $messageCache;
        $this->contLang = $contLang;
        $this->loadbalancerFactory = $loadbalancerFactory;
        $this->contentHandlerFactory = $contentHandlerFactory;
        $this->hookContainer = $hookContainer;
        $this->editResultCache = $editResultCache;
        $this->userNameUtils = $userNameUtils;
        $this->logger = $logger;
        $this->options = $options;
        $this->userEditTracker = $userEditTracker;
        $this->userGroupManager = $userGroupManager;
        $this->titleFormatter = $titleFormatter;
        $this->contentTransformer = $contentTransformer;
        $this->pageEditStash = $pageEditStash;
        $this->talkPageNotificationManager = $talkPageNotificationManager;
        $this->mainWANObjectCache = $mainWANObjectCache;
        $this->permissionManager = $permissionManager;
        $this->softwareTags = $softwareTags;
        $this->wikiPageFactory = $wikiPageFactory;
    }
 
    public function newPageUpdater(
        PageIdentity $page,
        UserIdentity $user
    ): PageUpdater {
        $page = $this->wikiPageFactory->newFromTitle( $page );
 
        return $this->newPageUpdaterForDerivedPageDataUpdater(
            $page,
            $user,
            $this->newDerivedPageDataUpdater( $page )
        );
    }
 
    public function newPageUpdaterForDerivedPageDataUpdater(
        WikiPage $page,
        UserIdentity $user,
        DerivedPageDataUpdater $derivedPageDataUpdater
    ): PageUpdater {
        $pageUpdater = new PageUpdater(
            $user,
            $page, // NOTE: eventually, PageUpdater should not know about WikiPage
            $derivedPageDataUpdater,
            $this->loadbalancerFactory->getMainLB(),
            $this->revisionStore,
            $this->slotRoleRegistry,
            $this->contentHandlerFactory,
            $this->hookContainer,
            $this->userEditTracker,
            $this->userGroupManager,
            $this->titleFormatter,
            new ServiceOptions(
                PageUpdater::CONSTRUCTOR_OPTIONS,
                $this->options
            ),
            $this->softwareTags,
            $this->logger
        );
 
        $pageUpdater->setUsePageCreationLog(
            $this->options->get( MainConfigNames::PageCreationLog ) );
        $pageUpdater->setUseAutomaticEditSummaries(
            $this->options->get( MainConfigNames::UseAutomaticEditSummaries )
        );
 
        return $pageUpdater;
    }
 
    public function newDerivedPageDataUpdater( WikiPage $page ): DerivedPageDataUpdater {
        $derivedDataUpdater = new DerivedPageDataUpdater(
            $this->options,
            $page, // NOTE: eventually, PageUpdater should not know about WikiPage
            $this->revisionStore,
            $this->revisionRenderer,
            $this->slotRoleRegistry,
            $this->parserCache,
            $this->parsoidOutputAccess,
            $this->jobQueueGroup,
            $this->messageCache,
            $this->contLang,
            $this->loadbalancerFactory,
            $this->contentHandlerFactory,
            $this->hookContainer,
            $this->editResultCache,
            $this->userNameUtils,
            $this->contentTransformer,
            $this->pageEditStash,
            $this->talkPageNotificationManager,
            $this->mainWANObjectCache,
            $this->permissionManager
        );
 
        $derivedDataUpdater->setLogger( $this->logger );
        $derivedDataUpdater->setArticleCountMethod(
            $this->options->get( MainConfigNames::ArticleCountMethod ) );
        $derivedDataUpdater->setRcWatchCategoryMembership(
            $this->options->get( MainConfigNames::RCWatchCategoryMembership )
        );
 
        return $derivedDataUpdater;
    }
 
}