PageUpdaterFactory.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Storage;
 
use MediaWiki\ChangeTags\ChangeTagsStore;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Content\IContentHandlerFactory;
use MediaWiki\Content\Transform\ContentTransformer;
use MediaWiki\DomainEvent\DomainEventDispatcher;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\JobQueue\JobQueueGroup;
use MediaWiki\Language\Language;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\WikiPageFactory;
use MediaWiki\Parser\ParserCache;
use MediaWiki\Revision\RevisionRenderer;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Revision\SlotRoleRegistry;
use MediaWiki\Title\TitleFormatter;
use MediaWiki\User\UserGroupManager;
use MediaWiki\User\UserIdentity;
use Psr\Log\LoggerInterface;
use Wikimedia\ObjectCache\WANObjectCache;
use Wikimedia\Rdbms\ILBFactory;
 
class PageUpdaterFactory {
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::ArticleCountMethod,
        MainConfigNames::RCWatchCategoryMembership,
        MainConfigNames::UseAutomaticEditSummaries,
        MainConfigNames::ManualRevertSearchRadius,
        MainConfigNames::UseRCPatrol,
        MainConfigNames::ParsoidCacheConfig,
        MainConfigNames::PageCreationLog,
    ];
 
    private $revisionStore;
 
    private $revisionRenderer;
 
    private $slotRoleRegistry;
 
    private $parserCache;
 
    private $jobQueueGroup;
 
    private $contLang;
 
    private $loadbalancerFactory;
 
    private $contentHandlerFactory;
 
    private $eventDispatcher;
 
    private $hookContainer;
 
    private $editResultCache;
 
    private $logger;
 
    private $options;
 
    private $userGroupManager;
 
    private $titleFormatter;
 
    private $contentTransformer;
 
    private $pageEditStash;
 
    private $mainWANObjectCache;
 
    private $wikiPageFactory;
 
    private $softwareTags;
 
    private ChangeTagsStore $changeTagsStore;
 
    public function __construct(
        RevisionStore $revisionStore,
        RevisionRenderer $revisionRenderer,
        SlotRoleRegistry $slotRoleRegistry,
        ParserCache $parserCache,
        JobQueueGroup $jobQueueGroup,
        Language $contLang,
        ILBFactory $loadbalancerFactory,
        IContentHandlerFactory $contentHandlerFactory,
        DomainEventDispatcher $eventDispatcher,
        HookContainer $hookContainer,
        EditResultCache $editResultCache,
        LoggerInterface $logger,
        ServiceOptions $options,
        UserGroupManager $userGroupManager,
        TitleFormatter $titleFormatter,
        ContentTransformer $contentTransformer,
        PageEditStash $pageEditStash,
        WANObjectCache $mainWANObjectCache,
        WikiPageFactory $wikiPageFactory,
        ChangeTagsStore $changeTagsStore,
        array $softwareTags
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
 
        $this->revisionStore = $revisionStore;
        $this->revisionRenderer = $revisionRenderer;
        $this->slotRoleRegistry = $slotRoleRegistry;
        $this->parserCache = $parserCache;
        $this->jobQueueGroup = $jobQueueGroup;
        $this->contLang = $contLang;
        $this->loadbalancerFactory = $loadbalancerFactory;
        $this->contentHandlerFactory = $contentHandlerFactory;
        $this->eventDispatcher = $eventDispatcher;
        $this->hookContainer = $hookContainer;
        $this->editResultCache = $editResultCache;
        $this->logger = $logger;
        $this->options = $options;
        $this->userGroupManager = $userGroupManager;
        $this->titleFormatter = $titleFormatter;
        $this->contentTransformer = $contentTransformer;
        $this->pageEditStash = $pageEditStash;
        $this->mainWANObjectCache = $mainWANObjectCache;
        $this->softwareTags = $softwareTags;
        $this->wikiPageFactory = $wikiPageFactory;
        $this->changeTagsStore = $changeTagsStore;
    }
 
    public function newPageUpdater(
        PageIdentity $page,
        UserIdentity $user
    ): PageUpdater {
        return $this->newPageUpdaterForDerivedPageDataUpdater(
            $page,
            $user,
            $this->newDerivedPageDataUpdater( $page )
        );
    }
 
    public function newPageUpdaterForDerivedPageDataUpdater(
        PageIdentity $page,
        UserIdentity $user,
        DerivedPageDataUpdater $derivedPageDataUpdater
    ): PageUpdater {
        $pageUpdater = new PageUpdater(
            $user,
            $page,
            $derivedPageDataUpdater,
            $this->loadbalancerFactory,
            $this->revisionStore,
            $this->slotRoleRegistry,
            $this->contentHandlerFactory,
            $this->hookContainer,
            $this->userGroupManager,
            $this->titleFormatter,
            new ServiceOptions(
                PageUpdater::CONSTRUCTOR_OPTIONS,
                $this->options
            ),
            $this->softwareTags,
            $this->logger,
            $this->wikiPageFactory
        );
 
        $pageUpdater->setUsePageCreationLog(
            $this->options->get( MainConfigNames::PageCreationLog ) );
 
        $pageUpdater->setUseAutomaticEditSummaries(
            $this->options->get( MainConfigNames::UseAutomaticEditSummaries )
        );
 
        return $pageUpdater;
    }
 
    public function newDerivedPageDataUpdater( PageIdentity $page ): DerivedPageDataUpdater {
        $derivedDataUpdater = new DerivedPageDataUpdater(
            $this->options,
            $page,
            $this->revisionStore,
            $this->revisionRenderer,
            $this->slotRoleRegistry,
            $this->parserCache,
            $this->jobQueueGroup,
            $this->contLang,
            $this->loadbalancerFactory,
            $this->contentHandlerFactory,
            $this->hookContainer,
            $this->eventDispatcher,
            $this->editResultCache,
            $this->contentTransformer,
            $this->pageEditStash,
            $this->mainWANObjectCache,
            $this->wikiPageFactory,
            $this->changeTagsStore,
        );
 
        $derivedDataUpdater->setLogger( $this->logger );
        $derivedDataUpdater->setArticleCountMethod(
            $this->options->get( MainConfigNames::ArticleCountMethod ) );
 
        return $derivedDataUpdater;
    }
 
}