Code Coverage |
||||||||||
Lines |
Functions and Methods |
Classes and Traits |
||||||||
Total | |
0.00% |
0 / 188 |
n/a |
0 / 0 |
CRAP | n/a |
0 / 0 |
1 | <?php |
2 | |
3 | namespace FileImporter; |
4 | |
5 | use ExtensionRegistry; |
6 | use FileImporter\Remote\MediaWiki\AnyMediaWikiFileUrlChecker; |
7 | use FileImporter\Remote\MediaWiki\ApiDetailRetriever; |
8 | use FileImporter\Remote\MediaWiki\HttpApiLookup; |
9 | use FileImporter\Remote\MediaWiki\InterwikiTablePrefixLookup; |
10 | use FileImporter\Remote\MediaWiki\RemoteApiActionExecutor; |
11 | use FileImporter\Remote\MediaWiki\RemoteApiImportTitleChecker; |
12 | use FileImporter\Remote\MediaWiki\RemoteSourceFileEditDeleteAction; |
13 | use FileImporter\Remote\MediaWiki\SiteTableSiteLookup; |
14 | use FileImporter\Remote\MediaWiki\SiteTableSourceUrlChecker; |
15 | use FileImporter\Remote\MediaWiki\SuggestManualTemplateAction; |
16 | use FileImporter\Remote\NullPrefixLookup; |
17 | use FileImporter\Services\CategoryExtractor; |
18 | use FileImporter\Services\DuplicateFileRevisionChecker; |
19 | use FileImporter\Services\FileTextRevisionValidator; |
20 | use FileImporter\Services\Http\HttpRequestExecutor; |
21 | use FileImporter\Services\Importer; |
22 | use FileImporter\Services\ImportPlanFactory; |
23 | use FileImporter\Services\NullRevisionCreator; |
24 | use FileImporter\Services\SourceSite; |
25 | use FileImporter\Services\SourceSiteLocator; |
26 | use FileImporter\Services\SuccessCache; |
27 | use FileImporter\Services\UploadBase\UploadBaseFactory; |
28 | use FileImporter\Services\WikidataTemplateLookup; |
29 | use FileImporter\Services\WikimediaSourceUrlNormalizer; |
30 | use FileImporter\Services\WikiRevisionFactory; |
31 | use ImportableUploadRevisionImporter; |
32 | use MediaWiki\Context\RequestContext; |
33 | use MediaWiki\Logger\LoggerFactory; |
34 | use MediaWiki\MainConfigNames; |
35 | use MediaWiki\MediaWikiServices; |
36 | use UploadBase; |
37 | |
38 | // TODO: Alphabetize. |
39 | return [ |
40 | |
41 | 'FileImporterSourceSiteLocator' => static function ( MediaWikiServices $services ): SourceSiteLocator { |
42 | $sourceSiteServices = $services->getMainConfig()->get( 'FileImporterSourceSiteServices' ); |
43 | $sourceSites = []; |
44 | |
45 | foreach ( $sourceSiteServices as $serviceName ) { |
46 | $sourceSites[] = $services->getService( $serviceName ); |
47 | } |
48 | |
49 | if ( $sourceSites === [] ) { |
50 | $sourceSites[] = $services->getService( 'FileImporter-Site-DefaultMediaWiki' ); |
51 | } |
52 | |
53 | return new SourceSiteLocator( $sourceSites ); |
54 | }, |
55 | |
56 | 'FileImporterHttpRequestExecutor' => static function ( MediaWikiServices $services ): HttpRequestExecutor { |
57 | $config = $services->getMainConfig(); |
58 | $maxFileSize = UploadBase::getMaxUploadSize( 'import' ); |
59 | $service = new HttpRequestExecutor( |
60 | $services->getHttpRequestFactory(), |
61 | [ |
62 | 'originalRequest' => RequestContext::getMain()->getRequest(), |
63 | 'proxy' => $config->get( MainConfigNames::CopyUploadProxy ), |
64 | 'timeout' => $config->get( MainConfigNames::CopyUploadTimeout ), |
65 | ], |
66 | $maxFileSize |
67 | ); |
68 | $service->setLogger( LoggerFactory::getInstance( 'FileImporter' ) ); |
69 | return $service; |
70 | }, |
71 | |
72 | 'FileImporterCategoryExtractor' => static function ( MediaWikiServices $services ): CategoryExtractor { |
73 | return new CategoryExtractor( |
74 | $services->getParserFactory(), |
75 | $services->getDBLoadBalancerFactory(), |
76 | $services->getLinkBatchFactory() |
77 | ); |
78 | }, |
79 | |
80 | 'FileImporterDuplicateFileRevisionChecker' => static function ( |
81 | MediaWikiServices $services |
82 | ): DuplicateFileRevisionChecker { |
83 | $localRepo = $services->getRepoGroup()->getLocalRepo(); |
84 | return new DuplicateFileRevisionChecker( $localRepo ); |
85 | }, |
86 | |
87 | 'FileImporterImporter' => static function ( MediaWikiServices $services ): Importer { |
88 | /** @var WikiRevisionFactory $wikiRevisionFactory */ |
89 | $wikiRevisionFactory = $services->getService( 'FileImporterWikiRevisionFactory' ); |
90 | /** @var NullRevisionCreator $nullRevisionCreator */ |
91 | $nullRevisionCreator = $services->getService( 'FileImporterNullRevisionCreator' ); |
92 | /** @var HttpRequestExecutor $httpRequestExecutor */ |
93 | $httpRequestExecutor = $services->getService( 'FileImporterHttpRequestExecutor' ); |
94 | /** @var UploadBaseFactory $uploadBaseFactory */ |
95 | $uploadBaseFactory = $services->getService( 'FileImporterUploadBaseFactory' ); |
96 | |
97 | $uploadRevisionImporter = $services->getUploadRevisionImporter(); |
98 | // FIXME: Should be part of the UploadRevisionImporter interface or the import() method |
99 | if ( $uploadRevisionImporter instanceof ImportableUploadRevisionImporter ) { |
100 | $uploadRevisionImporter->setNullRevisionCreation( false ); |
101 | } |
102 | |
103 | return new Importer( |
104 | $services->getWikiPageFactory(), |
105 | $wikiRevisionFactory, |
106 | $nullRevisionCreator, |
107 | $services->getUserIdentityLookup(), |
108 | $httpRequestExecutor, |
109 | $uploadBaseFactory, |
110 | $services->getOldRevisionImporter(), |
111 | $uploadRevisionImporter, |
112 | new FileTextRevisionValidator(), |
113 | $services->getRestrictionStore(), |
114 | LoggerFactory::getInstance( 'FileImporter' ), |
115 | $services->getStatsdDataFactory() |
116 | ); |
117 | }, |
118 | |
119 | 'FileImporterWikiRevisionFactory' => static function ( MediaWikiServices $services ): WikiRevisionFactory { |
120 | return new WikiRevisionFactory( |
121 | $services->getContentHandlerFactory() |
122 | ); |
123 | }, |
124 | |
125 | 'FileImporterNullRevisionCreator' => static function ( MediaWikiServices $services ): NullRevisionCreator { |
126 | return new NullRevisionCreator( |
127 | $services->getRevisionStore(), |
128 | $services->getDBLoadBalancerFactory() |
129 | ); |
130 | }, |
131 | |
132 | 'FileImporterImportPlanFactory' => static function ( MediaWikiServices $services ): ImportPlanFactory { |
133 | /** @var SourceSiteLocator $sourceSiteLocator */ |
134 | $sourceSiteLocator = $services->getService( 'FileImporterSourceSiteLocator' ); |
135 | /** @var DuplicateFileRevisionChecker $duplicateFileChecker */ |
136 | $duplicateFileChecker = $services->getService( 'FileImporterDuplicateFileRevisionChecker' ); |
137 | /** @var UploadBaseFactory $uploadBaseFactory */ |
138 | $uploadBaseFactory = $services->getService( 'FileImporterUploadBaseFactory' ); |
139 | |
140 | return new ImportPlanFactory( |
141 | $sourceSiteLocator, |
142 | $duplicateFileChecker, |
143 | $uploadBaseFactory |
144 | ); |
145 | }, |
146 | |
147 | 'FileImporterUploadBaseFactory' => static function ( MediaWikiServices $services ): UploadBaseFactory { |
148 | return new UploadBaseFactory( LoggerFactory::getInstance( 'FileImporter' ) ); |
149 | }, |
150 | |
151 | // Sites |
152 | |
153 | /** |
154 | * This configuration example can be used for development and is very plain and lenient! |
155 | * It will allow importing files form ANY mediawiki site. |
156 | */ |
157 | 'FileImporter-Site-DefaultMediaWiki' => static function ( MediaWikiServices $services ): SourceSite { |
158 | /** @var HttpApiLookup $httpApiLookup */ |
159 | $httpApiLookup = $services->getService( 'FileImporterMediaWikiHttpApiLookup' ); |
160 | /** @var HttpRequestExecutor $httpRequestExecutor */ |
161 | $httpRequestExecutor = $services->getService( 'FileImporterHttpRequestExecutor' ); |
162 | $logger = LoggerFactory::getInstance( 'FileImporter' ); |
163 | $maxFileSize = UploadBase::getMaxUploadSize( 'import' ); |
164 | |
165 | /** @var RemoteApiActionExecutor $remoteApiActionExecutor */ |
166 | $remoteApiActionExecutor = $services->getService( |
167 | 'FileImporterMediaWikiRemoteApiActionExecutor' |
168 | ); |
169 | |
170 | /** @var WikidataTemplateLookup $templateLookup */ |
171 | $templateLookup = $services->getService( 'FileImporterTemplateLookup' ); |
172 | |
173 | $postImportHandler = new SuggestManualTemplateAction( $templateLookup ); |
174 | $config = $services->getMainConfig(); |
175 | if ( ExtensionRegistry::getInstance()->isLoaded( 'CentralAuth' ) && |
176 | ( $config->get( 'FileImporterSourceWikiTemplating' ) || |
177 | $config->get( 'FileImporterSourceWikiDeletion' ) ) |
178 | ) { |
179 | $postImportHandler = new RemoteSourceFileEditDeleteAction( |
180 | $postImportHandler, |
181 | $templateLookup, |
182 | $remoteApiActionExecutor, |
183 | $logger, |
184 | $services->getStatsdDataFactory() |
185 | ); |
186 | } |
187 | |
188 | return new SourceSite( |
189 | new AnyMediaWikiFileUrlChecker(), |
190 | new ApiDetailRetriever( |
191 | $httpApiLookup, |
192 | $httpRequestExecutor, |
193 | $maxFileSize, |
194 | $logger |
195 | ), |
196 | new RemoteApiImportTitleChecker( |
197 | $httpApiLookup, |
198 | $httpRequestExecutor, |
199 | $logger |
200 | ), |
201 | new WikimediaSourceUrlNormalizer(), |
202 | new NullPrefixLookup(), |
203 | $postImportHandler |
204 | ); |
205 | }, |
206 | |
207 | /** |
208 | * This configuration example is setup to handle the wikimedia style setup. |
209 | * This only allows importing files from sites in the sites table. |
210 | */ |
211 | 'FileImporter-WikimediaSitesTableSite' => static function ( MediaWikiServices $services ): SourceSite { |
212 | /** @var SiteTableSiteLookup $siteTableLookup */ |
213 | $siteTableLookup = $services->getService( 'FileImporterMediaWikiSiteTableSiteLookup' ); |
214 | /** @var HttpApiLookup $httpApiLookup */ |
215 | $httpApiLookup = $services->getService( 'FileImporterMediaWikiHttpApiLookup' ); |
216 | /** @var HttpRequestExecutor $httpRequestExecutor */ |
217 | $httpRequestExecutor = $services->getService( 'FileImporterHttpRequestExecutor' ); |
218 | $logger = LoggerFactory::getInstance( 'FileImporter' ); |
219 | $maxFileSize = UploadBase::getMaxUploadSize( 'import' ); |
220 | |
221 | /** @var RemoteApiActionExecutor $remoteApiActionExecutor */ |
222 | $remoteApiActionExecutor = $services->getService( |
223 | 'FileImporterMediaWikiRemoteApiActionExecutor' |
224 | ); |
225 | |
226 | /** @var WikidataTemplateLookup $templateLookup */ |
227 | $templateLookup = $services->getService( 'FileImporterTemplateLookup' ); |
228 | |
229 | $postImportHandler = new SuggestManualTemplateAction( $templateLookup ); |
230 | $config = $services->getMainConfig(); |
231 | if ( ExtensionRegistry::getInstance()->isLoaded( 'CentralAuth' ) && |
232 | ( $config->get( 'FileImporterSourceWikiTemplating' ) || |
233 | $config->get( 'FileImporterSourceWikiDeletion' ) ) |
234 | ) { |
235 | $postImportHandler = new RemoteSourceFileEditDeleteAction( |
236 | $postImportHandler, |
237 | $templateLookup, |
238 | $remoteApiActionExecutor, |
239 | $logger, |
240 | $services->getStatsdDataFactory() |
241 | ); |
242 | } |
243 | |
244 | return new SourceSite( |
245 | new SiteTableSourceUrlChecker( |
246 | $siteTableLookup, |
247 | $logger |
248 | ), |
249 | new ApiDetailRetriever( |
250 | $httpApiLookup, |
251 | $httpRequestExecutor, |
252 | $maxFileSize, |
253 | $logger |
254 | ), |
255 | new RemoteApiImportTitleChecker( |
256 | $httpApiLookup, |
257 | $httpRequestExecutor, |
258 | $logger |
259 | ), |
260 | new WikimediaSourceUrlNormalizer(), |
261 | new InterwikiTablePrefixLookup( |
262 | $services->getInterwikiLookup(), |
263 | $httpApiLookup, |
264 | $httpRequestExecutor, |
265 | $services->getMainConfig()->get( 'FileImporterInterWikiMap' ), |
266 | $logger |
267 | ), |
268 | $postImportHandler |
269 | ); |
270 | }, |
271 | |
272 | 'FileImporterTemplateLookup' => static function ( MediaWikiServices $services ): WikidataTemplateLookup { |
273 | return new WikidataTemplateLookup( |
274 | $services->getMainConfig(), |
275 | $services->getService( 'FileImporterMediaWikiSiteTableSiteLookup' ), |
276 | $services->getService( 'FileImporterHttpRequestExecutor' ), |
277 | LoggerFactory::getInstance( 'FileImporter' ) |
278 | ); |
279 | }, |
280 | |
281 | 'FileImporterSuccessCache' => static function ( MediaWikiServices $services ): SuccessCache { |
282 | return new SuccessCache( |
283 | $services->getMainObjectStash(), |
284 | LoggerFactory::getInstance( 'FileImporter' ) |
285 | ); |
286 | }, |
287 | |
288 | ]; |