dépôts / lhc / web / wiklou.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge "Add CollationFa"
[lhc/web/wiklou.git] / includes / EditPage.php
1 <?php
2 /**
3 * User interface for page editing.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 */
22
23 use MediaWiki\Logger\LoggerFactory;
24 use MediaWiki\MediaWikiServices;
25 use Wikimedia\ScopedCallback;
26
27 /**
28 * The edit page/HTML interface (split from Article)
29 * The actual database and text munging is still in Article,
30 * but it should get easier to call those from alternate
31 * interfaces.
32 *
33 * EditPage cares about two distinct titles:
34 * $this->mContextTitle is the page that forms submit to, links point to,
35 * redirects go to, etc. $this->mTitle (as well as $mArticle) is the
36 * page in the database that is actually being edited. These are
37 * usually the same, but they are now allowed to be different.
38 *
39 * Surgeon General's Warning: prolonged exposure to this class is known to cause
40 * headaches, which may be fatal.
41 */
42 class EditPage {
43 /**
44 * Status: Article successfully updated
45 */
46 const AS_SUCCESS_UPDATE = 200;
47
48 /**
49 * Status: Article successfully created
50 */
51 const AS_SUCCESS_NEW_ARTICLE = 201;
52
53 /**
54 * Status: Article update aborted by a hook function
55 */
56 const AS_HOOK_ERROR = 210;
57
58 /**
59 * Status: A hook function returned an error
60 */
61 const AS_HOOK_ERROR_EXPECTED = 212;
62
63 /**
64 * Status: User is blocked from editing this page
65 */
66 const AS_BLOCKED_PAGE_FOR_USER = 215;
67
68 /**
69 * Status: Content too big (> $wgMaxArticleSize)
70 */
71 const AS_CONTENT_TOO_BIG = 216;
72
73 /**
74 * Status: this anonymous user is not allowed to edit this page
75 */
76 const AS_READ_ONLY_PAGE_ANON = 218;
77
78 /**
79 * Status: this logged in user is not allowed to edit this page
80 */
81 const AS_READ_ONLY_PAGE_LOGGED = 219;
82
83 /**
84 * Status: wiki is in readonly mode (wfReadOnly() == true)
85 */
86 const AS_READ_ONLY_PAGE = 220;
87
88 /**
89 * Status: rate limiter for action 'edit' was tripped
90 */
91 const AS_RATE_LIMITED = 221;
92
93 /**
94 * Status: article was deleted while editing and param wpRecreate == false or form
95 * was not posted
96 */
97 const AS_ARTICLE_WAS_DELETED = 222;
98
99 /**
100 * Status: user tried to create this page, but is not allowed to do that
101 * ( Title->userCan('create') == false )
102 */
103 const AS_NO_CREATE_PERMISSION = 223;
104
105 /**
106 * Status: user tried to create a blank page and wpIgnoreBlankArticle == false
107 */
108 const AS_BLANK_ARTICLE = 224;
109
110 /**
111 * Status: (non-resolvable) edit conflict
112 */
113 const AS_CONFLICT_DETECTED = 225;
114
115 /**
116 * Status: no edit summary given and the user has forceeditsummary set and the user is not
117 * editing in his own userspace or talkspace and wpIgnoreBlankSummary == false
118 */
119 const AS_SUMMARY_NEEDED = 226;
120
121 /**
122 * Status: user tried to create a new section without content
123 */
124 const AS_TEXTBOX_EMPTY = 228;
125
126 /**
127 * Status: article is too big (> $wgMaxArticleSize), after merging in the new section
128 */
129 const AS_MAX_ARTICLE_SIZE_EXCEEDED = 229;
130
131 /**
132 * Status: WikiPage::doEdit() was unsuccessful
133 */
134 const AS_END = 231;
135
136 /**
137 * Status: summary contained spam according to one of the regexes in $wgSummarySpamRegex
138 */
139 const AS_SPAM_ERROR = 232;
140
141 /**
142 * Status: anonymous user is not allowed to upload (User::isAllowed('upload') == false)
143 */
144 const AS_IMAGE_REDIRECT_ANON = 233;
145
146 /**
147 * Status: logged in user is not allowed to upload (User::isAllowed('upload') == false)
148 */
149 const AS_IMAGE_REDIRECT_LOGGED = 234;
150
151 /**
152 * Status: user tried to modify the content model, but is not allowed to do that
153 * ( User::isAllowed('editcontentmodel') == false )
154 */
155 const AS_NO_CHANGE_CONTENT_MODEL = 235;
156
157 /**
158 * Status: user tried to create self-redirect (redirect to the same article) and
159 * wpIgnoreSelfRedirect == false
160 */
161 const AS_SELF_REDIRECT = 236;
162
163 /**
164 * Status: an error relating to change tagging. Look at the message key for
165 * more details
166 */
167 const AS_CHANGE_TAG_ERROR = 237;
168
169 /**
170 * Status: can't parse content
171 */
172 const AS_PARSE_ERROR = 240;
173
174 /**
175 * Status: when changing the content model is disallowed due to
176 * $wgContentHandlerUseDB being false
177 */
178 const AS_CANNOT_USE_CUSTOM_MODEL = 241;
179
180 /**
181 * HTML id and name for the beginning of the edit form.
182 */
183 const EDITFORM_ID = 'editform';
184
185 /**
186 * Prefix of key for cookie used to pass post-edit state.
187 * The revision id edited is added after this
188 */
189 const POST_EDIT_COOKIE_KEY_PREFIX = 'PostEditRevision';
190
191 /**
192 * Duration of PostEdit cookie, in seconds.
193 * The cookie will be removed instantly if the JavaScript runs.
194 *
195 * Otherwise, though, we don't want the cookies to accumulate.
196 * RFC 2109 ( https://www.ietf.org/rfc/rfc2109.txt ) specifies a possible
197 * limit of only 20 cookies per domain. This still applies at least to some
198 * versions of IE without full updates:
199 * https://blogs.msdn.com/b/ieinternals/archive/2009/08/20/wininet-ie-cookie-internals-faq.aspx
200 *
201 * A value of 20 minutes should be enough to take into account slow loads and minor
202 * clock skew while still avoiding cookie accumulation when JavaScript is turned off.
203 */
204 const POST_EDIT_COOKIE_DURATION = 1200;
205
206 /** @var Article */
207 public $mArticle;
208 /** @var WikiPage */
209 private $page;
210
211 /** @var Title */
212 public $mTitle;
213
214 /** @var null|Title */
215 private $mContextTitle = null;
216
217 /** @var string */
218 public $action = 'submit';
219
220 /** @var bool */
221 public $isConflict = false;
222
223 /** @var bool */
224 public $isCssJsSubpage = false;
225
226 /** @var bool */
227 public $isCssSubpage = false;
228
229 /** @var bool */
230 public $isJsSubpage = false;
231
232 /** @var bool */
233 public $isWrongCaseCssJsPage = false;
234
235 /** @var bool New page or new section */
236 public $isNew = false;
237
238 /** @var bool */
239 public $deletedSinceEdit;
240
241 /** @var string */
242 public $formtype;
243
244 /** @var bool */
245 public $firsttime;
246
247 /** @var bool|stdClass */
248 public $lastDelete;
249
250 /** @var bool */
251 public $mTokenOk = false;
252
253 /** @var bool */
254 public $mTokenOkExceptSuffix = false;
255
256 /** @var bool */
257 public $mTriedSave = false;
258
259 /** @var bool */
260 public $incompleteForm = false;
261
262 /** @var bool */
263 public $tooBig = false;
264
265 /** @var bool */
266 public $missingComment = false;
267
268 /** @var bool */
269 public $missingSummary = false;
270
271 /** @var bool */
272 public $allowBlankSummary = false;
273
274 /** @var bool */
275 protected $blankArticle = false;
276
277 /** @var bool */
278 protected $allowBlankArticle = false;
279
280 /** @var bool */
281 protected $selfRedirect = false;
282
283 /** @var bool */
284 protected $allowSelfRedirect = false;
285
286 /** @var string */
287 public $autoSumm = '';
288
289 /** @var string */
290 public $hookError = '';
291
292 /** @var ParserOutput */
293 public $mParserOutput;
294
295 /** @var bool Has a summary been preset using GET parameter &summary= ? */
296 public $hasPresetSummary = false;
297
298 /** @var bool */
299 public $mBaseRevision = false;
300
301 /** @var bool */
302 public $mShowSummaryField = true;
303
304 # Form values
305
306 /** @var bool */
307 public $save = false;
308
309 /** @var bool */
310 public $preview = false;
311
312 /** @var bool */
313 public $diff = false;
314
315 /** @var bool */
316 public $minoredit = false;
317
318 /** @var bool */
319 public $watchthis = false;
320
321 /** @var bool */
322 public $recreate = false;
323
324 /** @var string */
325 public $textbox1 = '';
326
327 /** @var string */
328 public $textbox2 = '';
329
330 /** @var string */
331 public $summary = '';
332
333 /** @var bool */
334 public $nosummary = false;
335
336 /** @var string */
337 public $edittime = '';
338
339 /** @var integer */
340 private $editRevId = null;
341
342 /** @var string */
343 public $section = '';
344
345 /** @var string */
346 public $sectiontitle = '';
347
348 /** @var string */
349 public $starttime = '';
350
351 /** @var int */
352 public $oldid = 0;
353
354 /** @var int */
355 public $parentRevId = 0;
356
357 /** @var string */
358 public $editintro = '';
359
360 /** @var null */
361 public $scrolltop = null;
362
363 /** @var bool */
364 public $bot = true;
365
366 /** @var null|string */
367 public $contentModel = null;
368
369 /** @var null|string */
370 public $contentFormat = null;
371
372 /** @var null|array */
373 private $changeTags = null;
374
375 # Placeholders for text injection by hooks (must be HTML)
376 # extensions should take care to _append_ to the present value
377
378 /** @var string Before even the preview */
379 public $editFormPageTop = '';
380 public $editFormTextTop = '';
381 public $editFormTextBeforeContent = '';
382 public $editFormTextAfterWarn = '';
383 public $editFormTextAfterTools = '';
384 public $editFormTextBottom = '';
385 public $editFormTextAfterContent = '';
386 public $previewTextAfterContent = '';
387 public $mPreloadContent = null;
388
389 /* $didSave should be set to true whenever an article was successfully altered. */
390 public $didSave = false;
391 public $undidRev = 0;
392
393 public $suppressIntro = false;
394
395 /** @var bool */
396 protected $edit;
397
398 /** @var bool|int */
399 protected $contentLength = false;
400
401 /**
402 * @var bool Set in ApiEditPage, based on ContentHandler::allowsDirectApiEditing
403 */
404 private $enableApiEditOverride = false;
405
406 /**
407 * @var IContextSource
408 */
409 protected $context;
410
411 /**
412 * @var bool Whether an old revision is edited
413 */
414 private $isOldRev = false;
415
416 /**
417 * @param Article $article
418 */
419 public function __construct( Article $article ) {
420 $this->mArticle = $article;
421 $this->page = $article->getPage(); // model object
422 $this->mTitle = $article->getTitle();
423 $this->context = $article->getContext();
424
425 $this->contentModel = $this->mTitle->getContentModel();
426
427 $handler = ContentHandler::getForModelID( $this->contentModel );
428 $this->contentFormat = $handler->getDefaultFormat();
429 }
430
431 /**
432 * @return Article
433 */
434 public function getArticle() {
435 return $this->mArticle;
436 }
437
438 /**
439 * @since 1.28
440 * @return IContextSource
441 */
442 public function getContext() {
443 return $this->context;
444 }
445
446 /**
447 * @since 1.19
448 * @return Title
449 */
450 public function getTitle() {
451 return $this->mTitle;
452 }
453
454 /**
455 * Set the context Title object
456 *
457 * @param Title|null $title Title object or null
458 */
459 public function setContextTitle( $title ) {
460 $this->mContextTitle = $title;
461 }
462
463 /**
464 * Get the context title object.
465 * If not set, $wgTitle will be returned. This behavior might change in
466 * the future to return $this->mTitle instead.
467 *
468 * @return Title
469 */
470 public function getContextTitle() {
471 if ( is_null( $this->mContextTitle ) ) {
472 global $wgTitle;
473 return $wgTitle;
474 } else {
475 return $this->mContextTitle;
476 }
477 }
478
479 /**
480 * Returns if the given content model is editable.
481 *
482 * @param string $modelId The ID of the content model to test. Use CONTENT_MODEL_XXX constants.
483 * @return bool
484 * @throws MWException If $modelId has no known handler
485 */
486 public function isSupportedContentModel( $modelId ) {
487 return $this->enableApiEditOverride === true ||
488 ContentHandler::getForModelID( $modelId )->supportsDirectEditing();
489 }
490
491 /**
492 * Allow editing of content that supports API direct editing, but not general
493 * direct editing. Set to false by default.
494 *
495 * @param bool $enableOverride
496 */
497 public function setApiEditOverride( $enableOverride ) {
498 $this->enableApiEditOverride = $enableOverride;
499 }
500
501 function submit() {
502 $this->edit();
503 }
504
505 /**
506 * This is the function that gets called for "action=edit". It
507 * sets up various member variables, then passes execution to
508 * another function, usually showEditForm()
509 *
510 * The edit form is self-submitting, so that when things like
511 * preview and edit conflicts occur, we get the same form back
512 * with the extra stuff added. Only when the final submission
513 * is made and all is well do we actually save and redirect to
514 * the newly-edited page.
515 */
516 function edit() {
517 global $wgOut, $wgRequest, $wgUser;
518 // Allow extensions to modify/prevent this form or submission
519 if ( !Hooks::run( 'AlternateEdit', [ $this ] ) ) {
520 return;
521 }
522
523 wfDebug( __METHOD__ . ": enter\n" );
524
525 // If they used redlink=1 and the page exists, redirect to the main article
526 if ( $wgRequest->getBool( 'redlink' ) && $this->mTitle->exists() ) {
527 $wgOut->redirect( $this->mTitle->getFullURL() );
528 return;
529 }
530
531 $this->importFormData( $wgRequest );
532 $this->firsttime = false;
533
534 if ( wfReadOnly() && $this->save ) {
535 // Force preview
536 $this->save = false;
537 $this->preview = true;
538 }
539
540 if ( $this->save ) {
541 $this->formtype = 'save';
542 } elseif ( $this->preview ) {
543 $this->formtype = 'preview';
544 } elseif ( $this->diff ) {
545 $this->formtype = 'diff';
546 } else { # First time through
547 $this->firsttime = true;
548 if ( $this->previewOnOpen() ) {
549 $this->formtype = 'preview';
550 } else {
551 $this->formtype = 'initial';
552 }
553 }
554
555 $permErrors = $this->getEditPermissionErrors( $this->save ? 'secure' : 'full' );
556 if ( $permErrors ) {
557 wfDebug( __METHOD__ . ": User can't edit\n" );
558 // Auto-block user's IP if the account was "hard" blocked
559 if ( !wfReadOnly() ) {
560 $user = $wgUser;
561 DeferredUpdates::addCallableUpdate( function () use ( $user ) {
562 $user->spreadAnyEditBlock();
563 } );
564 }
565 $this->displayPermissionsError( $permErrors );
566
567 return;
568 }
569
570 $revision = $this->mArticle->getRevisionFetched();
571 // Disallow editing revisions with content models different from the current one
572 // Undo edits being an exception in order to allow reverting content model changes.
573 if ( $revision
574 && $revision->getContentModel() !== $this->contentModel
575 ) {
576 $prevRev = null;
577 if ( $this->undidRev ) {
578 $undidRevObj = Revision::newFromId( $this->undidRev );
579 $prevRev = $undidRevObj ? $undidRevObj->getPrevious() : null;
580 }
581 if ( !$this->undidRev
582 || !$prevRev
583 || $prevRev->getContentModel() !== $this->contentModel
584 ) {
585 $this->displayViewSourcePage(
586 $this->getContentObject(),
587 $this->context->msg(
588 'contentmodelediterror',
589 $revision->getContentModel(),
590 $this->contentModel
591 )->plain()
592 );
593 return;
594 }
595 }
596
597 $this->isConflict = false;
598 // css / js subpages of user pages get a special treatment
599 $this->isCssJsSubpage = $this->mTitle->isCssJsSubpage();
600 $this->isCssSubpage = $this->mTitle->isCssSubpage();
601 $this->isJsSubpage = $this->mTitle->isJsSubpage();
602 // @todo FIXME: Silly assignment.
603 $this->isWrongCaseCssJsPage = $this->isWrongCaseCssJsPage();
604
605 # Show applicable editing introductions
606 if ( $this->formtype == 'initial' || $this->firsttime ) {
607 $this->showIntro();
608 }
609
610 # Attempt submission here. This will check for edit conflicts,
611 # and redundantly check for locked database, blocked IPs, etc.
612 # that edit() already checked just in case someone tries to sneak
613 # in the back door with a hand-edited submission URL.
614
615 if ( 'save' == $this->formtype ) {
616 $resultDetails = null;
617 $status = $this->attemptSave( $resultDetails );
618 if ( !$this->handleStatus( $status, $resultDetails ) ) {
619 return;
620 }
621 }
622
623 # First time through: get contents, set time for conflict
624 # checking, etc.
625 if ( 'initial' == $this->formtype || $this->firsttime ) {
626 if ( $this->initialiseForm() === false ) {
627 $this->noSuchSectionPage();
628 return;
629 }
630
631 if ( !$this->mTitle->getArticleID() ) {
632 Hooks::run( 'EditFormPreloadText', [ &$this->textbox1, &$this->mTitle ] );
633 } else {
634 Hooks::run( 'EditFormInitialText', [ $this ] );
635 }
636
637 }
638
639 $this->showEditForm();
640 }
641
642 /**
643 * @param string $rigor Same format as Title::getUserPermissionErrors()
644 * @return array
645 */
646 protected function getEditPermissionErrors( $rigor = 'secure' ) {
647 global $wgUser;
648
649 $permErrors = $this->mTitle->getUserPermissionsErrors( 'edit', $wgUser, $rigor );
650 # Can this title be created?
651 if ( !$this->mTitle->exists() ) {
652 $permErrors = array_merge(
653 $permErrors,
654 wfArrayDiff2(
655 $this->mTitle->getUserPermissionsErrors( 'create', $wgUser, $rigor ),
656 $permErrors
657 )
658 );
659 }
660 # Ignore some permissions errors when a user is just previewing/viewing diffs
661 $remove = [];
662 foreach ( $permErrors as $error ) {
663 if ( ( $this->preview || $this->diff )
664 && ( $error[0] == 'blockedtext' || $error[0] == 'autoblockedtext' )
665 ) {
666 $remove[] = $error;
667 }
668 }
669 $permErrors = wfArrayDiff2( $permErrors, $remove );
670
671 return $permErrors;
672 }
673
674 /**
675 * Display a permissions error page, like OutputPage::showPermissionsErrorPage(),
676 * but with the following differences:
677 * - If redlink=1, the user will be redirected to the page
678 * - If there is content to display or the error occurs while either saving,
679 * previewing or showing the difference, it will be a
680 * "View source for ..." page displaying the source code after the error message.
681 *
682 * @since 1.19
683 * @param array $permErrors Array of permissions errors, as returned by
684 * Title::getUserPermissionsErrors().
685 * @throws PermissionsError
686 */
687 protected function displayPermissionsError( array $permErrors ) {
688 global $wgRequest, $wgOut;
689
690 if ( $wgRequest->getBool( 'redlink' ) ) {
691 // The edit page was reached via a red link.
692 // Redirect to the article page and let them click the edit tab if
693 // they really want a permission error.
694 $wgOut->redirect( $this->mTitle->getFullURL() );
695 return;
696 }
697
698 $content = $this->getContentObject();
699
700 # Use the normal message if there's nothing to display
701 if ( $this->firsttime && ( !$content || $content->isEmpty() ) ) {
702 $action = $this->mTitle->exists() ? 'edit' :
703 ( $this->mTitle->isTalkPage() ? 'createtalk' : 'createpage' );
704 throw new PermissionsError( $action, $permErrors );
705 }
706
707 $this->displayViewSourcePage(
708 $content,
709 $wgOut->formatPermissionsErrorMessage( $permErrors, 'edit' )
710 );
711 }
712
713 /**
714 * Display a read-only View Source page
715 * @param Content $content content object
716 * @param string $errorMessage additional wikitext error message to display
717 */
718 protected function displayViewSourcePage( Content $content, $errorMessage = '' ) {
719 global $wgOut;
720
721 Hooks::run( 'EditPage::showReadOnlyForm:initial', [ $this, &$wgOut ] );
722
723 $wgOut->setRobotPolicy( 'noindex,nofollow' );
724 $wgOut->setPageTitle( $this->context->msg(
725 'viewsource-title',
726 $this->getContextTitle()->getPrefixedText()
727 ) );
728 $wgOut->addBacklinkSubtitle( $this->getContextTitle() );
729 $wgOut->addHTML( $this->editFormPageTop );
730 $wgOut->addHTML( $this->editFormTextTop );
731
732 if ( $errorMessage !== '' ) {
733 $wgOut->addWikiText( $errorMessage );
734 $wgOut->addHTML( "<hr />\n" );
735 }
736
737 # If the user made changes, preserve them when showing the markup
738 # (This happens when a user is blocked during edit, for instance)
739 if ( !$this->firsttime ) {
740 $text = $this->textbox1;
741 $wgOut->addWikiMsg( 'viewyourtext' );
742 } else {
743 try {
744 $text = $this->toEditText( $content );
745 } catch ( MWException $e ) {
746 # Serialize using the default format if the content model is not supported
747 # (e.g. for an old revision with a different model)
748 $text = $content->serialize();
749 }
750 $wgOut->addWikiMsg( 'viewsourcetext' );
751 }
752
753 $wgOut->addHTML( $this->editFormTextBeforeContent );
754 $this->showTextbox( $text, 'wpTextbox1', [ 'readonly' ] );
755 $wgOut->addHTML( $this->editFormTextAfterContent );
756
757 $wgOut->addHTML( $this->makeTemplatesOnThisPageList( $this->getTemplates() ) );
758
759 $wgOut->addModules( 'mediawiki.action.edit.collapsibleFooter' );
760
761 $wgOut->addHTML( $this->editFormTextBottom );
762 if ( $this->mTitle->exists() ) {
763 $wgOut->returnToMain( null, $this->mTitle );
764 }
765 }
766
767 /**
768 * Should we show a preview when the edit form is first shown?
769 *
770 * @return bool
771 */
772 protected function previewOnOpen() {
773 global $wgRequest, $wgUser, $wgPreviewOnOpenNamespaces;
774 if ( $wgRequest->getVal( 'preview' ) == 'yes' ) {
775 // Explicit override from request
776 return true;
777 } elseif ( $wgRequest->getVal( 'preview' ) == 'no' ) {
778 // Explicit override from request
779 return false;
780 } elseif ( $this->section == 'new' ) {
781 // Nothing *to* preview for new sections
782 return false;
783 } elseif ( ( $wgRequest->getVal( 'preload' ) !== null || $this->mTitle->exists() )
784 && $wgUser->getOption( 'previewonfirst' )
785 ) {
786 // Standard preference behavior
787 return true;
788 } elseif ( !$this->mTitle->exists()
789 && isset( $wgPreviewOnOpenNamespaces[$this->mTitle->getNamespace()] )
790 && $wgPreviewOnOpenNamespaces[$this->mTitle->getNamespace()]
791 ) {
792 // Categories are special
793 return true;
794 } else {
795 return false;
796 }
797 }
798
799 /**
800 * Checks whether the user entered a skin name in uppercase,
801 * e.g. "User:Example/Monobook.css" instead of "monobook.css"
802 *
803 * @return bool
804 */
805 protected function isWrongCaseCssJsPage() {
806 if ( $this->mTitle->isCssJsSubpage() ) {
807 $name = $this->mTitle->getSkinFromCssJsSubpage();
808 $skins = array_merge(
809 array_keys( Skin::getSkinNames() ),
810 [ 'common' ]
811 );
812 return !in_array( $name, $skins )
813 && in_array( strtolower( $name ), $skins );
814 } else {
815 return false;
816 }
817 }
818
819 /**
820 * Returns whether section editing is supported for the current page.
821 * Subclasses may override this to replace the default behavior, which is
822 * to check ContentHandler::supportsSections.
823 *
824 * @return bool True if this edit page supports sections, false otherwise.
825 */
826 protected function isSectionEditSupported() {
827 $contentHandler = ContentHandler::getForTitle( $this->mTitle );
828 return $contentHandler->supportsSections();
829 }
830
831 /**
832 * This function collects the form data and uses it to populate various member variables.
833 * @param WebRequest $request
834 * @throws ErrorPageError
835 */
836 function importFormData( &$request ) {
837 global $wgContLang, $wgUser;
838
839 # Section edit can come from either the form or a link
840 $this->section = $request->getVal( 'wpSection', $request->getVal( 'section' ) );
841
842 if ( $this->section !== null && $this->section !== '' && !$this->isSectionEditSupported() ) {
843 throw new ErrorPageError( 'sectioneditnotsupported-title', 'sectioneditnotsupported-text' );
844 }
845
846 $this->isNew = !$this->mTitle->exists() || $this->section == 'new';
847
848 if ( $request->wasPosted() ) {
849 # These fields need to be checked for encoding.
850 # Also remove trailing whitespace, but don't remove _initial_
851 # whitespace from the text boxes. This may be significant formatting.
852 $this->textbox1 = $this->safeUnicodeInput( $request, 'wpTextbox1' );
853 if ( !$request->getCheck( 'wpTextbox2' ) ) {
854 // Skip this if wpTextbox2 has input, it indicates that we came
855 // from a conflict page with raw page text, not a custom form
856 // modified by subclasses
857 $textbox1 = $this->importContentFormData( $request );
858 if ( $textbox1 !== null ) {
859 $this->textbox1 = $textbox1;
860 }
861 }
862
863 # Truncate for whole multibyte characters
864 $this->summary = $wgContLang->truncate( $request->getText( 'wpSummary' ), 255 );
865
866 # If the summary consists of a heading, e.g. '==Foobar==', extract the title from the
867 # header syntax, e.g. 'Foobar'. This is mainly an issue when we are using wpSummary for
868 # section titles.
869 $this->summary = preg_replace( '/^\s*=+\s*(.*?)\s*=+\s*$/', '$1', $this->summary );
870
871 # Treat sectiontitle the same way as summary.
872 # Note that wpSectionTitle is not yet a part of the actual edit form, as wpSummary is
873 # currently doing double duty as both edit summary and section title. Right now this
874 # is just to allow API edits to work around this limitation, but this should be
875 # incorporated into the actual edit form when EditPage is rewritten (Bugs 18654, 26312).
876 $this->sectiontitle = $wgContLang->truncate( $request->getText( 'wpSectionTitle' ), 255 );
877 $this->sectiontitle = preg_replace( '/^\s*=+\s*(.*?)\s*=+\s*$/', '$1', $this->sectiontitle );
878
879 $this->edittime = $request->getVal( 'wpEdittime' );
880 $this->editRevId = $request->getIntOrNull( 'editRevId' );
881 $this->starttime = $request->getVal( 'wpStarttime' );
882
883 $undidRev = $request->getInt( 'wpUndidRevision' );
884 if ( $undidRev ) {
885 $this->undidRev = $undidRev;
886 }
887
888 $this->scrolltop = $request->getIntOrNull( 'wpScrolltop' );
889
890 if ( $this->textbox1 === '' && $request->getVal( 'wpTextbox1' ) === null ) {
891 // wpTextbox1 field is missing, possibly due to being "too big"
892 // according to some filter rules such as Suhosin's setting for
893 // suhosin.request.max_value_length (d'oh)
894 $this->incompleteForm = true;
895 } else {
896 // If we receive the last parameter of the request, we can fairly
897 // claim the POST request has not been truncated.
898
899 // TODO: softened the check for cutover. Once we determine
900 // that it is safe, we should complete the transition by
901 // removing the "edittime" clause.
902 $this->incompleteForm = ( !$request->getVal( 'wpUltimateParam' )
903 && is_null( $this->edittime ) );
904 }
905 if ( $this->incompleteForm ) {
906 # If the form is incomplete, force to preview.
907 wfDebug( __METHOD__ . ": Form data appears to be incomplete\n" );
908 wfDebug( "POST DATA: " . var_export( $_POST, true ) . "\n" );
909 $this->preview = true;
910 } else {
911 $this->preview = $request->getCheck( 'wpPreview' );
912 $this->diff = $request->getCheck( 'wpDiff' );
913
914 // Remember whether a save was requested, so we can indicate
915 // if we forced preview due to session failure.
916 $this->mTriedSave = !$this->preview;
917
918 if ( $this->tokenOk( $request ) ) {
919 # Some browsers will not report any submit button
920 # if the user hits enter in the comment box.
921 # The unmarked state will be assumed to be a save,
922 # if the form seems otherwise complete.
923 wfDebug( __METHOD__ . ": Passed token check.\n" );
924 } elseif ( $this->diff ) {
925 # Failed token check, but only requested "Show Changes".
926 wfDebug( __METHOD__ . ": Failed token check; Show Changes requested.\n" );
927 } else {
928 # Page might be a hack attempt posted from
929 # an external site. Preview instead of saving.
930 wfDebug( __METHOD__ . ": Failed token check; forcing preview\n" );
931 $this->preview = true;
932 }
933 }
934 $this->save = !$this->preview && !$this->diff;
935 if ( !preg_match( '/^\d{14}$/', $this->edittime ) ) {
936 $this->edittime = null;
937 }
938
939 if ( !preg_match( '/^\d{14}$/', $this->starttime ) ) {
940 $this->starttime = null;
941 }
942
943 $this->recreate = $request->getCheck( 'wpRecreate' );
944
945 $this->minoredit = $request->getCheck( 'wpMinoredit' );
946 $this->watchthis = $request->getCheck( 'wpWatchthis' );
947
948 # Don't force edit summaries when a user is editing their own user or talk page
949 if ( ( $this->mTitle->mNamespace == NS_USER || $this->mTitle->mNamespace == NS_USER_TALK )
950 && $this->mTitle->getText() == $wgUser->getName()
951 ) {
952 $this->allowBlankSummary = true;
953 } else {
954 $this->allowBlankSummary = $request->getBool( 'wpIgnoreBlankSummary' )
955 || !$wgUser->getOption( 'forceeditsummary' );
956 }
957
958 $this->autoSumm = $request->getText( 'wpAutoSummary' );
959
960 $this->allowBlankArticle = $request->getBool( 'wpIgnoreBlankArticle' );
961 $this->allowSelfRedirect = $request->getBool( 'wpIgnoreSelfRedirect' );
962
963 $changeTags = $request->getVal( 'wpChangeTags' );
964 if ( is_null( $changeTags ) || $changeTags === '' ) {
965 $this->changeTags = [];
966 } else {
967 $this->changeTags = array_filter( array_map( 'trim', explode( ',',
968 $changeTags ) ) );
969 }
970 } else {
971 # Not a posted form? Start with nothing.
972 wfDebug( __METHOD__ . ": Not a posted form.\n" );
973 $this->textbox1 = '';
974 $this->summary = '';
975 $this->sectiontitle = '';
976 $this->edittime = '';
977 $this->editRevId = null;
978 $this->starttime = wfTimestampNow();
979 $this->edit = false;
980 $this->preview = false;
981 $this->save = false;
982 $this->diff = false;
983 $this->minoredit = false;
984 // Watch may be overridden by request parameters
985 $this->watchthis = $request->getBool( 'watchthis', false );
986 $this->recreate = false;
987
988 // When creating a new section, we can preload a section title by passing it as the
989 // preloadtitle parameter in the URL (Bug 13100)
990 if ( $this->section == 'new' && $request->getVal( 'preloadtitle' ) ) {
991 $this->sectiontitle = $request->getVal( 'preloadtitle' );
992 // Once wpSummary isn't being use for setting section titles, we should delete this.
993 $this->summary = $request->getVal( 'preloadtitle' );
994 } elseif ( $this->section != 'new' && $request->getVal( 'summary' ) ) {
995 $this->summary = $request->getText( 'summary' );
996 if ( $this->summary !== '' ) {
997 $this->hasPresetSummary = true;
998 }
999 }
1000
1001 if ( $request->getVal( 'minor' ) ) {
1002 $this->minoredit = true;
1003 }
1004 }
1005
1006 $this->oldid = $request->getInt( 'oldid' );
1007 $this->parentRevId = $request->getInt( 'parentRevId' );
1008
1009 $this->bot = $request->getBool( 'bot', true );
1010 $this->nosummary = $request->getBool( 'nosummary' );
1011
1012 // May be overridden by revision.
1013 $this->contentModel = $request->getText( 'model', $this->contentModel );
1014 // May be overridden by revision.
1015 $this->contentFormat = $request->getText( 'format', $this->contentFormat );
1016
1017 try {
1018 $handler = ContentHandler::getForModelID( $this->contentModel );
1019 } catch ( MWUnknownContentModelException $e ) {
1020 throw new ErrorPageError(
1021 'editpage-invalidcontentmodel-title',
1022 'editpage-invalidcontentmodel-text',
1023 [ $this->contentModel ]
1024 );
1025 }
1026
1027 if ( !$handler->isSupportedFormat( $this->contentFormat ) ) {
1028 throw new ErrorPageError(
1029 'editpage-notsupportedcontentformat-title',
1030 'editpage-notsupportedcontentformat-text',
1031 [ $this->contentFormat, ContentHandler::getLocalizedName( $this->contentModel ) ]
1032 );
1033 }
1034
1035 /**
1036 * @todo Check if the desired model is allowed in this namespace, and if
1037 * a transition from the page's current model to the new model is
1038 * allowed.
1039 */
1040
1041 $this->editintro = $request->getText( 'editintro',
1042 // Custom edit intro for new sections
1043 $this->section === 'new' ? 'MediaWiki:addsection-editintro' : '' );
1044
1045 // Allow extensions to modify form data
1046 Hooks::run( 'EditPage::importFormData', [ $this, $request ] );
1047 }
1048
1049 /**
1050 * Subpage overridable method for extracting the page content data from the
1051 * posted form to be placed in $this->textbox1, if using customized input
1052 * this method should be overridden and return the page text that will be used
1053 * for saving, preview parsing and so on...
1054 *
1055 * @param WebRequest $request
1056 * @return string|null
1057 */
1058 protected function importContentFormData( &$request ) {
1059 return; // Don't do anything, EditPage already extracted wpTextbox1
1060 }
1061
1062 /**
1063 * Initialise form fields in the object
1064 * Called on the first invocation, e.g. when a user clicks an edit link
1065 * @return bool If the requested section is valid
1066 */
1067 function initialiseForm() {
1068 global $wgUser;
1069 $this->edittime = $this->page->getTimestamp();
1070 $this->editRevId = $this->page->getLatest();
1071
1072 $content = $this->getContentObject( false ); # TODO: track content object?!
1073 if ( $content === false ) {
1074 return false;
1075 }
1076 $this->textbox1 = $this->toEditText( $content );
1077
1078 // activate checkboxes if user wants them to be always active
1079 # Sort out the "watch" checkbox
1080 if ( $wgUser->getOption( 'watchdefault' ) ) {
1081 # Watch all edits
1082 $this->watchthis = true;
1083 } elseif ( $wgUser->getOption( 'watchcreations' ) && !$this->mTitle->exists() ) {
1084 # Watch creations
1085 $this->watchthis = true;
1086 } elseif ( $wgUser->isWatched( $this->mTitle ) ) {
1087 # Already watched
1088 $this->watchthis = true;
1089 }
1090 if ( $wgUser->getOption( 'minordefault' ) && !$this->isNew ) {
1091 $this->minoredit = true;
1092 }
1093 if ( $this->textbox1 === false ) {
1094 return false;
1095 }
1096 return true;
1097 }
1098
1099 /**
1100 * @param Content|null $def_content The default value to return
1101 *
1102 * @return Content|null Content on success, $def_content for invalid sections
1103 *
1104 * @since 1.21
1105 */
1106 protected function getContentObject( $def_content = null ) {
1107 global $wgOut, $wgRequest, $wgUser, $wgContLang;
1108
1109 $content = false;
1110
1111 // For message page not locally set, use the i18n message.
1112 // For other non-existent articles, use preload text if any.
1113 if ( !$this->mTitle->exists() || $this->section == 'new' ) {
1114 if ( $this->mTitle->getNamespace() == NS_MEDIAWIKI && $this->section != 'new' ) {
1115 # If this is a system message, get the default text.
1116 $msg = $this->mTitle->getDefaultMessageText();
1117
1118 $content = $this->toEditContent( $msg );
1119 }
1120 if ( $content === false ) {
1121 # If requested, preload some text.
1122 $preload = $wgRequest->getVal( 'preload',
1123 // Custom preload text for new sections
1124 $this->section === 'new' ? 'MediaWiki:addsection-preload' : '' );
1125 $params = $wgRequest->getArray( 'preloadparams', [] );
1126
1127 $content = $this->getPreloadedContent( $preload, $params );
1128 }
1129 // For existing pages, get text based on "undo" or section parameters.
1130 } else {
1131 if ( $this->section != '' ) {
1132 // Get section edit text (returns $def_text for invalid sections)
1133 $orig = $this->getOriginalContent( $wgUser );
1134 $content = $orig ? $orig->getSection( $this->section ) : null;
1135
1136 if ( !$content ) {
1137 $content = $def_content;
1138 }
1139 } else {
1140 $undoafter = $wgRequest->getInt( 'undoafter' );
1141 $undo = $wgRequest->getInt( 'undo' );
1142
1143 if ( $undo > 0 && $undoafter > 0 ) {
1144 $undorev = Revision::newFromId( $undo );
1145 $oldrev = Revision::newFromId( $undoafter );
1146
1147 # Sanity check, make sure it's the right page,
1148 # the revisions exist and they were not deleted.
1149 # Otherwise, $content will be left as-is.
1150 if ( !is_null( $undorev ) && !is_null( $oldrev ) &&
1151 !$undorev->isDeleted( Revision::DELETED_TEXT ) &&
1152 !$oldrev->isDeleted( Revision::DELETED_TEXT )
1153 ) {
1154 $content = $this->page->getUndoContent( $undorev, $oldrev );
1155
1156 if ( $content === false ) {
1157 # Warn the user that something went wrong
1158 $undoMsg = 'failure';
1159 } else {
1160 $oldContent = $this->page->getContent( Revision::RAW );
1161 $popts = ParserOptions::newFromUserAndLang( $wgUser, $wgContLang );
1162 $newContent = $content->preSaveTransform( $this->mTitle, $wgUser, $popts );
1163 if ( $newContent->getModel() !== $oldContent->getModel() ) {
1164 // The undo may change content
1165 // model if its reverting the top
1166 // edit. This can result in
1167 // mismatched content model/format.
1168 $this->contentModel = $newContent->getModel();
1169 $this->contentFormat = $oldrev->getContentFormat();
1170 }
1171
1172 if ( $newContent->equals( $oldContent ) ) {
1173 # Tell the user that the undo results in no change,
1174 # i.e. the revisions were already undone.
1175 $undoMsg = 'nochange';
1176 $content = false;
1177 } else {
1178 # Inform the user of our success and set an automatic edit summary
1179 $undoMsg = 'success';
1180
1181 # If we just undid one rev, use an autosummary
1182 $firstrev = $oldrev->getNext();
1183 if ( $firstrev && $firstrev->getId() == $undo ) {
1184 $userText = $undorev->getUserText();
1185 if ( $userText === '' ) {
1186 $undoSummary = $this->context->msg(
1187 'undo-summary-username-hidden',
1188 $undo
1189 )->inContentLanguage()->text();
1190 } else {
1191 $undoSummary = $this->context->msg(
1192 'undo-summary',
1193 $undo,
1194 $userText
1195 )->inContentLanguage()->text();
1196 }
1197 if ( $this->summary === '' ) {
1198 $this->summary = $undoSummary;
1199 } else {
1200 $this->summary = $undoSummary . $this->context->msg( 'colon-separator' )
1201 ->inContentLanguage()->text() . $this->summary;
1202 }
1203 $this->undidRev = $undo;
1204 }
1205 $this->formtype = 'diff';
1206 }
1207 }
1208 } else {
1209 // Failed basic sanity checks.
1210 // Older revisions may have been removed since the link
1211 // was created, or we may simply have got bogus input.
1212 $undoMsg = 'norev';
1213 }
1214
1215 // Messages: undo-success, undo-failure, undo-norev, undo-nochange
1216 $class = ( $undoMsg == 'success' ? '' : 'error ' ) . "mw-undo-{$undoMsg}";
1217 $this->editFormPageTop .= $wgOut->parse( "<div class=\"{$class}\">" .
1218 $this->context->msg( 'undo-' . $undoMsg )->plain() . '</div>', true, /* interface */true );
1219 }
1220
1221 if ( $content === false ) {
1222 $content = $this->getOriginalContent( $wgUser );
1223 }
1224 }
1225 }
1226
1227 return $content;
1228 }
1229
1230 /**
1231 * Get the content of the wanted revision, without section extraction.
1232 *
1233 * The result of this function can be used to compare user's input with
1234 * section replaced in its context (using WikiPage::replaceSectionAtRev())
1235 * to the original text of the edit.
1236 *
1237 * This differs from Article::getContent() that when a missing revision is
1238 * encountered the result will be null and not the
1239 * 'missing-revision' message.
1240 *
1241 * @since 1.19
1242 * @param User $user The user to get the revision for
1243 * @return Content|null
1244 */
1245 private function getOriginalContent( User $user ) {
1246 if ( $this->section == 'new' ) {
1247 return $this->getCurrentContent();
1248 }
1249 $revision = $this->mArticle->getRevisionFetched();
1250 if ( $revision === null ) {
1251 if ( !$this->contentModel ) {
1252 $this->contentModel = $this->getTitle()->getContentModel();
1253 }
1254 $handler = ContentHandler::getForModelID( $this->contentModel );
1255
1256 return $handler->makeEmptyContent();
1257 }
1258 $content = $revision->getContent( Revision::FOR_THIS_USER, $user );
1259 return $content;
1260 }
1261
1262 /**
1263 * Get the edit's parent revision ID
1264 *
1265 * The "parent" revision is the ancestor that should be recorded in this
1266 * page's revision history. It is either the revision ID of the in-memory
1267 * article content, or in the case of a 3-way merge in order to rebase
1268 * across a recoverable edit conflict, the ID of the newer revision to
1269 * which we have rebased this page.
1270 *
1271 * @since 1.27
1272 * @return int Revision ID
1273 */
1274 public function getParentRevId() {
1275 if ( $this->parentRevId ) {
1276 return $this->parentRevId;
1277 } else {
1278 return $this->mArticle->getRevIdFetched();
1279 }
1280 }
1281
1282 /**
1283 * Get the current content of the page. This is basically similar to
1284 * WikiPage::getContent( Revision::RAW ) except that when the page doesn't exist an empty
1285 * content object is returned instead of null.
1286 *
1287 * @since 1.21
1288 * @return Content
1289 */
1290 protected function getCurrentContent() {
1291 $rev = $this->page->getRevision();
1292 $content = $rev ? $rev->getContent( Revision::RAW ) : null;
1293
1294 if ( $content === false || $content === null ) {
1295 if ( !$this->contentModel ) {
1296 $this->contentModel = $this->getTitle()->getContentModel();
1297 }
1298 $handler = ContentHandler::getForModelID( $this->contentModel );
1299
1300 return $handler->makeEmptyContent();
1301 } elseif ( !$this->undidRev ) {
1302 // Content models should always be the same since we error
1303 // out if they are different before this point (in ->edit()).
1304 // The exception being, during an undo, the current revision might
1305 // differ from the prior revision.
1306 $logger = LoggerFactory::getInstance( 'editpage' );
1307 if ( $this->contentModel !== $rev->getContentModel() ) {
1308 $logger->warning( "Overriding content model from current edit {prev} to {new}", [
1309 'prev' => $this->contentModel,
1310 'new' => $rev->getContentModel(),
1311 'title' => $this->getTitle()->getPrefixedDBkey(),
1312 'method' => __METHOD__
1313 ] );
1314 $this->contentModel = $rev->getContentModel();
1315 }
1316
1317 // Given that the content models should match, the current selected
1318 // format should be supported.
1319 if ( !$content->isSupportedFormat( $this->contentFormat ) ) {
1320 $logger->warning( "Current revision content format unsupported. Overriding {prev} to {new}", [
1321
1322 'prev' => $this->contentFormat,
1323 'new' => $rev->getContentFormat(),
1324 'title' => $this->getTitle()->getPrefixedDBkey(),
1325 'method' => __METHOD__
1326 ] );
1327 $this->contentFormat = $rev->getContentFormat();
1328 }
1329 }
1330 return $content;
1331 }
1332
1333 /**
1334 * Use this method before edit() to preload some content into the edit box
1335 *
1336 * @param Content $content
1337 *
1338 * @since 1.21
1339 */
1340 public function setPreloadedContent( Content $content ) {
1341 $this->mPreloadContent = $content;
1342 }
1343
1344 /**
1345 * Get the contents to be preloaded into the box, either set by
1346 * an earlier setPreloadText() or by loading the given page.
1347 *
1348 * @param string $preload Representing the title to preload from.
1349 * @param array $params Parameters to use (interface-message style) in the preloaded text
1350 *
1351 * @return Content
1352 *
1353 * @since 1.21
1354 */
1355 protected function getPreloadedContent( $preload, $params = [] ) {
1356 global $wgUser;
1357
1358 if ( !empty( $this->mPreloadContent ) ) {
1359 return $this->mPreloadContent;
1360 }
1361
1362 $handler = ContentHandler::getForModelID( $this->contentModel );
1363
1364 if ( $preload === '' ) {
1365 return $handler->makeEmptyContent();
1366 }
1367
1368 $title = Title::newFromText( $preload );
1369 # Check for existence to avoid getting MediaWiki:Noarticletext
1370 if ( $title === null || !$title->exists() || !$title->userCan( 'read', $wgUser ) ) {
1371 // TODO: somehow show a warning to the user!
1372 return $handler->makeEmptyContent();
1373 }
1374
1375 $page = WikiPage::factory( $title );
1376 if ( $page->isRedirect() ) {
1377 $title = $page->getRedirectTarget();
1378 # Same as before
1379 if ( $title === null || !$title->exists() || !$title->userCan( 'read', $wgUser ) ) {
1380 // TODO: somehow show a warning to the user!
1381 return $handler->makeEmptyContent();
1382 }
1383 $page = WikiPage::factory( $title );
1384 }
1385
1386 $parserOptions = ParserOptions::newFromUser( $wgUser );
1387 $content = $page->getContent( Revision::RAW );
1388
1389 if ( !$content ) {
1390 // TODO: somehow show a warning to the user!
1391 return $handler->makeEmptyContent();
1392 }
1393
1394 if ( $content->getModel() !== $handler->getModelID() ) {
1395 $converted = $content->convert( $handler->getModelID() );
1396
1397 if ( !$converted ) {
1398 // TODO: somehow show a warning to the user!
1399 wfDebug( "Attempt to preload incompatible content: " .
1400 "can't convert " . $content->getModel() .
1401 " to " . $handler->getModelID() );
1402
1403 return $handler->makeEmptyContent();
1404 }
1405
1406 $content = $converted;
1407 }
1408
1409 return $content->preloadTransform( $title, $parserOptions, $params );
1410 }
1411
1412 /**
1413 * Make sure the form isn't faking a user's credentials.
1414 *
1415 * @param WebRequest $request
1416 * @return bool
1417 * @private
1418 */
1419 function tokenOk( &$request ) {
1420 global $wgUser;
1421 $token = $request->getVal( 'wpEditToken' );
1422 $this->mTokenOk = $wgUser->matchEditToken( $token );
1423 $this->mTokenOkExceptSuffix = $wgUser->matchEditTokenNoSuffix( $token );
1424 return $this->mTokenOk;
1425 }
1426
1427 /**
1428 * Sets post-edit cookie indicating the user just saved a particular revision.
1429 *
1430 * This uses a temporary cookie for each revision ID so separate saves will never
1431 * interfere with each other.
1432 *
1433 * The cookie is deleted in the mediawiki.action.view.postEdit JS module after
1434 * the redirect. It must be clearable by JavaScript code, so it must not be
1435 * marked HttpOnly. The JavaScript code converts the cookie to a wgPostEdit config
1436 * variable.
1437 *
1438 * If the variable were set on the server, it would be cached, which is unwanted
1439 * since the post-edit state should only apply to the load right after the save.
1440 *
1441 * @param int $statusValue The status value (to check for new article status)
1442 */
1443 protected function setPostEditCookie( $statusValue ) {
1444 $revisionId = $this->page->getLatest();
1445 $postEditKey = self::POST_EDIT_COOKIE_KEY_PREFIX . $revisionId;
1446
1447 $val = 'saved';
1448 if ( $statusValue == self::AS_SUCCESS_NEW_ARTICLE ) {
1449 $val = 'created';
1450 } elseif ( $this->oldid ) {
1451 $val = 'restored';
1452 }
1453
1454 $response = RequestContext::getMain()->getRequest()->response();
1455 $response->setCookie( $postEditKey, $val, time() + self::POST_EDIT_COOKIE_DURATION, [
1456 'httpOnly' => false,
1457 ] );
1458 }
1459
1460 /**
1461 * Attempt submission
1462 * @param array|bool $resultDetails See docs for $result in internalAttemptSave
1463 * @throws UserBlockedError|ReadOnlyError|ThrottledError|PermissionsError
1464 * @return Status The resulting status object.
1465 */
1466 public function attemptSave( &$resultDetails = false ) {
1467 global $wgUser;
1468
1469 # Allow bots to exempt some edits from bot flagging
1470 $bot = $wgUser->isAllowed( 'bot' ) && $this->bot;
1471 $status = $this->internalAttemptSave( $resultDetails, $bot );
1472
1473 Hooks::run( 'EditPage::attemptSave:after', [ $this, $status, $resultDetails ] );
1474
1475 return $status;
1476 }
1477
1478 /**
1479 * Handle status, such as after attempt save
1480 *
1481 * @param Status $status
1482 * @param array|bool $resultDetails
1483 *
1484 * @throws ErrorPageError
1485 * @return bool False, if output is done, true if rest of the form should be displayed
1486 */
1487 private function handleStatus( Status $status, $resultDetails ) {
1488 global $wgUser, $wgOut;
1489
1490 /**
1491 * @todo FIXME: once the interface for internalAttemptSave() is made
1492 * nicer, this should use the message in $status
1493 */
1494 if ( $status->value == self::AS_SUCCESS_UPDATE
1495 || $status->value == self::AS_SUCCESS_NEW_ARTICLE
1496 ) {
1497 $this->didSave = true;
1498 if ( !$resultDetails['nullEdit'] ) {
1499 $this->setPostEditCookie( $status->value );
1500 }
1501 }
1502
1503 // "wpExtraQueryRedirect" is a hidden input to modify
1504 // after save URL and is not used by actual edit form
1505 $request = RequestContext::getMain()->getRequest();
1506 $extraQueryRedirect = $request->getVal( 'wpExtraQueryRedirect' );
1507
1508 switch ( $status->value ) {
1509 case self::AS_HOOK_ERROR_EXPECTED:
1510 case self::AS_CONTENT_TOO_BIG:
1511 case self::AS_ARTICLE_WAS_DELETED:
1512 case self::AS_CONFLICT_DETECTED:
1513 case self::AS_SUMMARY_NEEDED:
1514 case self::AS_TEXTBOX_EMPTY:
1515 case self::AS_MAX_ARTICLE_SIZE_EXCEEDED:
1516 case self::AS_END:
1517 case self::AS_BLANK_ARTICLE:
1518 case self::AS_SELF_REDIRECT:
1519 return true;
1520
1521 case self::AS_HOOK_ERROR:
1522 return false;
1523
1524 case self::AS_CANNOT_USE_CUSTOM_MODEL:
1525 case self::AS_PARSE_ERROR:
1526 $wgOut->addWikiText( '<div class="error">' . "\n" . $status->getWikiText() . '</div>' );
1527 return true;
1528
1529 case self::AS_SUCCESS_NEW_ARTICLE:
1530 $query = $resultDetails['redirect'] ? 'redirect=no' : '';
1531 if ( $extraQueryRedirect ) {
1532 if ( $query === '' ) {
1533 $query = $extraQueryRedirect;
1534 } else {
1535 $query = $query . '&' . $extraQueryRedirect;
1536 }
1537 }
1538 $anchor = isset( $resultDetails['sectionanchor'] ) ? $resultDetails['sectionanchor'] : '';
1539 $wgOut->redirect( $this->mTitle->getFullURL( $query ) . $anchor );
1540 return false;
1541
1542 case self::AS_SUCCESS_UPDATE:
1543 $extraQuery = '';
1544 $sectionanchor = $resultDetails['sectionanchor'];
1545
1546 // Give extensions a chance to modify URL query on update
1547 Hooks::run(
1548 'ArticleUpdateBeforeRedirect',
1549 [ $this->mArticle, &$sectionanchor, &$extraQuery ]
1550 );
1551
1552 if ( $resultDetails['redirect'] ) {
1553 if ( $extraQuery == '' ) {
1554 $extraQuery = 'redirect=no';
1555 } else {
1556 $extraQuery = 'redirect=no&' . $extraQuery;
1557 }
1558 }
1559 if ( $extraQueryRedirect ) {
1560 if ( $extraQuery === '' ) {
1561 $extraQuery = $extraQueryRedirect;
1562 } else {
1563 $extraQuery = $extraQuery . '&' . $extraQueryRedirect;
1564 }
1565 }
1566
1567 $wgOut->redirect( $this->mTitle->getFullURL( $extraQuery ) . $sectionanchor );
1568 return false;
1569
1570 case self::AS_SPAM_ERROR:
1571 $this->spamPageWithContent( $resultDetails['spam'] );
1572 return false;
1573
1574 case self::AS_BLOCKED_PAGE_FOR_USER:
1575 throw new UserBlockedError( $wgUser->getBlock() );
1576
1577 case self::AS_IMAGE_REDIRECT_ANON:
1578 case self::AS_IMAGE_REDIRECT_LOGGED:
1579 throw new PermissionsError( 'upload' );
1580
1581 case self::AS_READ_ONLY_PAGE_ANON:
1582 case self::AS_READ_ONLY_PAGE_LOGGED:
1583 throw new PermissionsError( 'edit' );
1584
1585 case self::AS_READ_ONLY_PAGE:
1586 throw new ReadOnlyError;
1587
1588 case self::AS_RATE_LIMITED:
1589 throw new ThrottledError();
1590
1591 case self::AS_NO_CREATE_PERMISSION:
1592 $permission = $this->mTitle->isTalkPage() ? 'createtalk' : 'createpage';
1593 throw new PermissionsError( $permission );
1594
1595 case self::AS_NO_CHANGE_CONTENT_MODEL:
1596 throw new PermissionsError( 'editcontentmodel' );
1597
1598 default:
1599 // We don't recognize $status->value. The only way that can happen
1600 // is if an extension hook aborted from inside ArticleSave.
1601 // Render the status object into $this->hookError
1602 // FIXME this sucks, we should just use the Status object throughout
1603 $this->hookError = '<div class="error">' ."\n" . $status->getWikiText() .
1604 '</div>';
1605 return true;
1606 }
1607 }
1608
1609 /**
1610 * Run hooks that can filter edits just before they get saved.
1611 *
1612 * @param Content $content The Content to filter.
1613 * @param Status $status For reporting the outcome to the caller
1614 * @param User $user The user performing the edit
1615 *
1616 * @return bool
1617 */
1618 protected function runPostMergeFilters( Content $content, Status $status, User $user ) {
1619 // Run old style post-section-merge edit filter
1620 if ( !ContentHandler::runLegacyHooks( 'EditFilterMerged',
1621 [ $this, $content, &$this->hookError, $this->summary ],
1622 '1.21'
1623 ) ) {
1624 # Error messages etc. could be handled within the hook...
1625 $status->fatal( 'hookaborted' );
1626 $status->value = self::AS_HOOK_ERROR;
1627 return false;
1628 } elseif ( $this->hookError != '' ) {
1629 # ...or the hook could be expecting us to produce an error
1630 $status->fatal( 'hookaborted' );
1631 $status->value = self::AS_HOOK_ERROR_EXPECTED;
1632 return false;
1633 }
1634
1635 // Run new style post-section-merge edit filter
1636 if ( !Hooks::run( 'EditFilterMergedContent',
1637 [ $this->mArticle->getContext(), $content, $status, $this->summary,
1638 $user, $this->minoredit ] )
1639 ) {
1640 # Error messages etc. could be handled within the hook...
1641 if ( $status->isGood() ) {
1642 $status->fatal( 'hookaborted' );
1643 // Not setting $this->hookError here is a hack to allow the hook
1644 // to cause a return to the edit page without $this->hookError
1645 // being set. This is used by ConfirmEdit to display a captcha
1646 // without any error message cruft.
1647 } else {
1648 $this->hookError = $status->getWikiText();
1649 }
1650 // Use the existing $status->value if the hook set it
1651 if ( !$status->value ) {
1652 $status->value = self::AS_HOOK_ERROR;
1653 }
1654 return false;
1655 } elseif ( !$status->isOK() ) {
1656 # ...or the hook could be expecting us to produce an error
1657 // FIXME this sucks, we should just use the Status object throughout
1658 $this->hookError = $status->getWikiText();
1659 $status->fatal( 'hookaborted' );
1660 $status->value = self::AS_HOOK_ERROR_EXPECTED;
1661 return false;
1662 }
1663
1664 return true;
1665 }
1666
1667 /**
1668 * Return the summary to be used for a new section.
1669 *
1670 * @param string $sectionanchor Set to the section anchor text
1671 * @return string
1672 */
1673 private function newSectionSummary( &$sectionanchor = null ) {
1674 global $wgParser;
1675
1676 if ( $this->sectiontitle !== '' ) {
1677 $sectionanchor = $wgParser->guessLegacySectionNameFromWikiText( $this->sectiontitle );
1678 // If no edit summary was specified, create one automatically from the section
1679 // title and have it link to the new section. Otherwise, respect the summary as
1680 // passed.
1681 if ( $this->summary === '' ) {
1682 $cleanSectionTitle = $wgParser->stripSectionName( $this->sectiontitle );
1683 return $this->context->msg( 'newsectionsummary' )
1684 ->rawParams( $cleanSectionTitle )->inContentLanguage()->text();
1685 }
1686 } elseif ( $this->summary !== '' ) {
1687 $sectionanchor = $wgParser->guessLegacySectionNameFromWikiText( $this->summary );
1688 # This is a new section, so create a link to the new section
1689 # in the revision summary.
1690 $cleanSummary = $wgParser->stripSectionName( $this->summary );
1691 return $this->context->msg( 'newsectionsummary' )
1692 ->rawParams( $cleanSummary )->inContentLanguage()->text();
1693 }
1694 return $this->summary;
1695 }
1696
1697 /**
1698 * Attempt submission (no UI)
1699 *
1700 * @param array $result Array to add statuses to, currently with the
1701 * possible keys:
1702 * - spam (string): Spam string from content if any spam is detected by
1703 * matchSpamRegex.
1704 * - sectionanchor (string): Section anchor for a section save.
1705 * - nullEdit (boolean): Set if doEditContent is OK. True if null edit,
1706 * false otherwise.
1707 * - redirect (bool): Set if doEditContent is OK. True if resulting
1708 * revision is a redirect.
1709 * @param bool $bot True if edit is being made under the bot right.
1710 *
1711 * @return Status Status object, possibly with a message, but always with
1712 * one of the AS_* constants in $status->value,
1713 *
1714 * @todo FIXME: This interface is TERRIBLE, but hard to get rid of due to
1715 * various error display idiosyncrasies. There are also lots of cases
1716 * where error metadata is set in the object and retrieved later instead
1717 * of being returned, e.g. AS_CONTENT_TOO_BIG and
1718 * AS_BLOCKED_PAGE_FOR_USER. All that stuff needs to be cleaned up some
1719 * time.
1720 */
1721 function internalAttemptSave( &$result, $bot = false ) {
1722 global $wgUser, $wgRequest, $wgParser, $wgMaxArticleSize;
1723 global $wgContentHandlerUseDB;
1724
1725 $status = Status::newGood();
1726
1727 if ( !Hooks::run( 'EditPage::attemptSave', [ $this ] ) ) {
1728 wfDebug( "Hook 'EditPage::attemptSave' aborted article saving\n" );
1729 $status->fatal( 'hookaborted' );
1730 $status->value = self::AS_HOOK_ERROR;
1731 return $status;
1732 }
1733
1734 $spam = $wgRequest->getText( 'wpAntispam' );
1735 if ( $spam !== '' ) {
1736 wfDebugLog(
1737 'SimpleAntiSpam',
1738 $wgUser->getName() .
1739 ' editing "' .
1740 $this->mTitle->getPrefixedText() .
1741 '" submitted bogus field "' .
1742 $spam .
1743 '"'
1744 );
1745 $status->fatal( 'spamprotectionmatch', false );
1746 $status->value = self::AS_SPAM_ERROR;
1747 return $status;
1748 }
1749
1750 try {
1751 # Construct Content object
1752 $textbox_content = $this->toEditContent( $this->textbox1 );
1753 } catch ( MWContentSerializationException $ex ) {
1754 $status->fatal(
1755 'content-failed-to-parse',
1756 $this->contentModel,
1757 $this->contentFormat,
1758 $ex->getMessage()
1759 );
1760 $status->value = self::AS_PARSE_ERROR;
1761 return $status;
1762 }
1763
1764 # Check image redirect
1765 if ( $this->mTitle->getNamespace() == NS_FILE &&
1766 $textbox_content->isRedirect() &&
1767 !$wgUser->isAllowed( 'upload' )
1768 ) {
1769 $code = $wgUser->isAnon() ? self::AS_IMAGE_REDIRECT_ANON : self::AS_IMAGE_REDIRECT_LOGGED;
1770 $status->setResult( false, $code );
1771
1772 return $status;
1773 }
1774
1775 # Check for spam
1776 $match = self::matchSummarySpamRegex( $this->summary );
1777 if ( $match === false && $this->section == 'new' ) {
1778 # $wgSpamRegex is enforced on this new heading/summary because, unlike
1779 # regular summaries, it is added to the actual wikitext.
1780 if ( $this->sectiontitle !== '' ) {
1781 # This branch is taken when the API is used with the 'sectiontitle' parameter.
1782 $match = self::matchSpamRegex( $this->sectiontitle );
1783 } else {
1784 # This branch is taken when the "Add Topic" user interface is used, or the API
1785 # is used with the 'summary' parameter.
1786 $match = self::matchSpamRegex( $this->summary );
1787 }
1788 }
1789 if ( $match === false ) {
1790 $match = self::matchSpamRegex( $this->textbox1 );
1791 }
1792 if ( $match !== false ) {
1793 $result['spam'] = $match;
1794 $ip = $wgRequest->getIP();
1795 $pdbk = $this->mTitle->getPrefixedDBkey();
1796 $match = str_replace( "\n", '', $match );
1797 wfDebugLog( 'SpamRegex', "$ip spam regex hit [[$pdbk]]: \"$match\"" );
1798 $status->fatal( 'spamprotectionmatch', $match );
1799 $status->value = self::AS_SPAM_ERROR;
1800 return $status;
1801 }
1802 if ( !Hooks::run(
1803 'EditFilter',
1804 [ $this, $this->textbox1, $this->section, &$this->hookError, $this->summary ] )
1805 ) {
1806 # Error messages etc. could be handled within the hook...
1807 $status->fatal( 'hookaborted' );
1808 $status->value = self::AS_HOOK_ERROR;
1809 return $status;
1810 } elseif ( $this->hookError != '' ) {
1811 # ...or the hook could be expecting us to produce an error
1812 $status->fatal( 'hookaborted' );
1813 $status->value = self::AS_HOOK_ERROR_EXPECTED;
1814 return $status;
1815 }
1816
1817 if ( $wgUser->isBlockedFrom( $this->mTitle, false ) ) {
1818 // Auto-block user's IP if the account was "hard" blocked
1819 if ( !wfReadOnly() ) {
1820 $wgUser->spreadAnyEditBlock();
1821 }
1822 # Check block state against master, thus 'false'.
1823 $status->setResult( false, self::AS_BLOCKED_PAGE_FOR_USER );
1824 return $status;
1825 }
1826
1827 $this->contentLength = strlen( $this->textbox1 );
1828 if ( $this->contentLength > $wgMaxArticleSize * 1024 ) {
1829 // Error will be displayed by showEditForm()
1830 $this->tooBig = true;
1831 $status->setResult( false, self::AS_CONTENT_TOO_BIG );
1832 return $status;
1833 }
1834
1835 if ( !$wgUser->isAllowed( 'edit' ) ) {
1836 if ( $wgUser->isAnon() ) {
1837 $status->setResult( false, self::AS_READ_ONLY_PAGE_ANON );
1838 return $status;
1839 } else {
1840 $status->fatal( 'readonlytext' );
1841 $status->value = self::AS_READ_ONLY_PAGE_LOGGED;
1842 return $status;
1843 }
1844 }
1845
1846 $changingContentModel = false;
1847 if ( $this->contentModel !== $this->mTitle->getContentModel() ) {
1848 if ( !$wgContentHandlerUseDB ) {
1849 $status->fatal( 'editpage-cannot-use-custom-model' );
1850 $status->value = self::AS_CANNOT_USE_CUSTOM_MODEL;
1851 return $status;
1852 } elseif ( !$wgUser->isAllowed( 'editcontentmodel' ) ) {
1853 $status->setResult( false, self::AS_NO_CHANGE_CONTENT_MODEL );
1854 return $status;
1855 }
1856 // Make sure the user can edit the page under the new content model too
1857 $titleWithNewContentModel = clone $this->mTitle;
1858 $titleWithNewContentModel->setContentModel( $this->contentModel );
1859 if ( !$titleWithNewContentModel->userCan( 'editcontentmodel', $wgUser )
1860 || !$titleWithNewContentModel->userCan( 'edit', $wgUser )
1861 ) {
1862 $status->setResult( false, self::AS_NO_CHANGE_CONTENT_MODEL );
1863 return $status;
1864 }
1865
1866 $changingContentModel = true;
1867 $oldContentModel = $this->mTitle->getContentModel();
1868 }
1869
1870 if ( $this->changeTags ) {
1871 $changeTagsStatus = ChangeTags::canAddTagsAccompanyingChange(
1872 $this->changeTags, $wgUser );
1873 if ( !$changeTagsStatus->isOK() ) {
1874 $changeTagsStatus->value = self::AS_CHANGE_TAG_ERROR;
1875 return $changeTagsStatus;
1876 }
1877 }
1878
1879 if ( wfReadOnly() ) {
1880 $status->fatal( 'readonlytext' );
1881 $status->value = self::AS_READ_ONLY_PAGE;
1882 return $status;
1883 }
1884 if ( $wgUser->pingLimiter() || $wgUser->pingLimiter( 'linkpurge', 0 )
1885 || ( $changingContentModel && $wgUser->pingLimiter( 'editcontentmodel' ) )
1886 ) {
1887 $status->fatal( 'actionthrottledtext' );
1888 $status->value = self::AS_RATE_LIMITED;
1889 return $status;
1890 }
1891
1892 # If the article has been deleted while editing, don't save it without
1893 # confirmation
1894 if ( $this->wasDeletedSinceLastEdit() && !$this->recreate ) {
1895 $status->setResult( false, self::AS_ARTICLE_WAS_DELETED );
1896 return $status;
1897 }
1898
1899 # Load the page data from the master. If anything changes in the meantime,
1900 # we detect it by using page_latest like a token in a 1 try compare-and-swap.
1901 $this->page->loadPageData( 'fromdbmaster' );
1902 $new = !$this->page->exists();
1903
1904 if ( $new ) {
1905 // Late check for create permission, just in case *PARANOIA*
1906 if ( !$this->mTitle->userCan( 'create', $wgUser ) ) {
1907 $status->fatal( 'nocreatetext' );
1908 $status->value = self::AS_NO_CREATE_PERMISSION;
1909 wfDebug( __METHOD__ . ": no create permission\n" );
1910 return $status;
1911 }
1912
1913 // Don't save a new page if it's blank or if it's a MediaWiki:
1914 // message with content equivalent to default (allow empty pages
1915 // in this case to disable messages, see bug 50124)
1916 $defaultMessageText = $this->mTitle->getDefaultMessageText();
1917 if ( $this->mTitle->getNamespace() === NS_MEDIAWIKI && $defaultMessageText !== false ) {
1918 $defaultText = $defaultMessageText;
1919 } else {
1920 $defaultText = '';
1921 }
1922
1923 if ( !$this->allowBlankArticle && $this->textbox1 === $defaultText ) {
1924 $this->blankArticle = true;
1925 $status->fatal( 'blankarticle' );
1926 $status->setResult( false, self::AS_BLANK_ARTICLE );
1927 return $status;
1928 }
1929
1930 if ( !$this->runPostMergeFilters( $textbox_content, $status, $wgUser ) ) {
1931 return $status;
1932 }
1933
1934 $content = $textbox_content;
1935
1936 $result['sectionanchor'] = '';
1937 if ( $this->section == 'new' ) {
1938 if ( $this->sectiontitle !== '' ) {
1939 // Insert the section title above the content.
1940 $content = $content->addSectionHeader( $this->sectiontitle );
1941 } elseif ( $this->summary !== '' ) {
1942 // Insert the section title above the content.
1943 $content = $content->addSectionHeader( $this->summary );
1944 }
1945 $this->summary = $this->newSectionSummary( $result['sectionanchor'] );
1946 }
1947
1948 $status->value = self::AS_SUCCESS_NEW_ARTICLE;
1949
1950 } else { # not $new
1951
1952 # Article exists. Check for edit conflict.
1953
1954 $this->page->clear(); # Force reload of dates, etc.
1955 $timestamp = $this->page->getTimestamp();
1956 $latest = $this->page->getLatest();
1957
1958 wfDebug( "timestamp: {$timestamp}, edittime: {$this->edittime}\n" );
1959
1960 // Check editRevId if set, which handles same-second timestamp collisions
1961 if ( $timestamp != $this->edittime
1962 || ( $this->editRevId !== null && $this->editRevId != $latest )
1963 ) {
1964 $this->isConflict = true;
1965 if ( $this->section == 'new' ) {
1966 if ( $this->page->getUserText() == $wgUser->getName() &&
1967 $this->page->getComment() == $this->newSectionSummary()
1968 ) {
1969 // Probably a duplicate submission of a new comment.
1970 // This can happen when CDN resends a request after
1971 // a timeout but the first one actually went through.
1972 wfDebug( __METHOD__
1973 . ": duplicate new section submission; trigger edit conflict!\n" );
1974 } else {
1975 // New comment; suppress conflict.
1976 $this->isConflict = false;
1977 wfDebug( __METHOD__ . ": conflict suppressed; new section\n" );
1978 }
1979 } elseif ( $this->section == ''
1980 && Revision::userWasLastToEdit(
1981 DB_MASTER, $this->mTitle->getArticleID(),
1982 $wgUser->getId(), $this->edittime
1983 )
1984 ) {
1985 # Suppress edit conflict with self, except for section edits where merging is required.
1986 wfDebug( __METHOD__ . ": Suppressing edit conflict, same user.\n" );
1987 $this->isConflict = false;
1988 }
1989 }
1990
1991 // If sectiontitle is set, use it, otherwise use the summary as the section title.
1992 if ( $this->sectiontitle !== '' ) {
1993 $sectionTitle = $this->sectiontitle;
1994 } else {
1995 $sectionTitle = $this->summary;
1996 }
1997
1998 $content = null;
1999
2000 if ( $this->isConflict ) {
2001 wfDebug( __METHOD__
2002 . ": conflict! getting section '{$this->section}' for time '{$this->edittime}'"
2003 . " (id '{$this->editRevId}') (article time '{$timestamp}')\n" );
2004 // @TODO: replaceSectionAtRev() with base ID (not prior current) for ?oldid=X case
2005 // ...or disable section editing for non-current revisions (not exposed anyway).
2006 if ( $this->editRevId !== null ) {
2007 $content = $this->page->replaceSectionAtRev(
2008 $this->section,
2009 $textbox_content,
2010 $sectionTitle,
2011 $this->editRevId
2012 );
2013 } else {
2014 $content = $this->page->replaceSectionContent(
2015 $this->section,
2016 $textbox_content,
2017 $sectionTitle,
2018 $this->edittime
2019 );
2020 }
2021 } else {
2022 wfDebug( __METHOD__ . ": getting section '{$this->section}'\n" );
2023 $content = $this->page->replaceSectionContent(
2024 $this->section,
2025 $textbox_content,
2026 $sectionTitle
2027 );
2028 }
2029
2030 if ( is_null( $content ) ) {
2031 wfDebug( __METHOD__ . ": activating conflict; section replace failed.\n" );
2032 $this->isConflict = true;
2033 $content = $textbox_content; // do not try to merge here!
2034 } elseif ( $this->isConflict ) {
2035 # Attempt merge
2036 if ( $this->mergeChangesIntoContent( $content ) ) {
2037 // Successful merge! Maybe we should tell the user the good news?
2038 $this->isConflict = false;
2039 wfDebug( __METHOD__ . ": Suppressing edit conflict, successful merge.\n" );
2040 } else {
2041 $this->section = '';
2042 $this->textbox1 = ContentHandler::getContentText( $content );
2043 wfDebug( __METHOD__ . ": Keeping edit conflict, failed merge.\n" );
2044 }
2045 }
2046
2047 if ( $this->isConflict ) {
2048 $status->setResult( false, self::AS_CONFLICT_DETECTED );
2049 return $status;
2050 }
2051
2052 if ( !$this->runPostMergeFilters( $content, $status, $wgUser ) ) {
2053 return $status;
2054 }
2055
2056 if ( $this->section == 'new' ) {
2057 // Handle the user preference to force summaries here
2058 if ( !$this->allowBlankSummary && trim( $this->summary ) == '' ) {
2059 $this->missingSummary = true;
2060 $status->fatal( 'missingsummary' ); // or 'missingcommentheader' if $section == 'new'. Blegh
2061 $status->value = self::AS_SUMMARY_NEEDED;
2062 return $status;
2063 }
2064
2065 // Do not allow the user to post an empty comment
2066 if ( $this->textbox1 == '' ) {
2067 $this->missingComment = true;
2068 $status->fatal( 'missingcommenttext' );
2069 $status->value = self::AS_TEXTBOX_EMPTY;
2070 return $status;
2071 }
2072 } elseif ( !$this->allowBlankSummary
2073 && !$content->equals( $this->getOriginalContent( $wgUser ) )
2074 && !$content->isRedirect()
2075 && md5( $this->summary ) == $this->autoSumm
2076 ) {
2077 $this->missingSummary = true;
2078 $status->fatal( 'missingsummary' );
2079 $status->value = self::AS_SUMMARY_NEEDED;
2080 return $status;
2081 }
2082
2083 # All's well
2084 $sectionanchor = '';
2085 if ( $this->section == 'new' ) {
2086 $this->summary = $this->newSectionSummary( $sectionanchor );
2087 } elseif ( $this->section != '' ) {
2088 # Try to get a section anchor from the section source, redirect
2089 # to edited section if header found.
2090 # XXX: Might be better to integrate this into Article::replaceSectionAtRev
2091 # for duplicate heading checking and maybe parsing.
2092 $hasmatch = preg_match( "/^ *([=]{1,6})(.*?)(\\1) *\\n/i", $this->textbox1, $matches );
2093 # We can't deal with anchors, includes, html etc in the header for now,
2094 # headline would need to be parsed to improve this.
2095 if ( $hasmatch && strlen( $matches[2] ) > 0 ) {
2096 $sectionanchor = $wgParser->guessLegacySectionNameFromWikiText( $matches[2] );
2097 }
2098 }
2099 $result['sectionanchor'] = $sectionanchor;
2100
2101 // Save errors may fall down to the edit form, but we've now
2102 // merged the section into full text. Clear the section field
2103 // so that later submission of conflict forms won't try to
2104 // replace that into a duplicated mess.
2105 $this->textbox1 = $this->toEditText( $content );
2106 $this->section = '';
2107
2108 $status->value = self::AS_SUCCESS_UPDATE;
2109 }
2110
2111 if ( !$this->allowSelfRedirect
2112 && $content->isRedirect()
2113 && $content->getRedirectTarget()->equals( $this->getTitle() )
2114 ) {
2115 // If the page already redirects to itself, don't warn.
2116 $currentTarget = $this->getCurrentContent()->getRedirectTarget();
2117 if ( !$currentTarget || !$currentTarget->equals( $this->getTitle() ) ) {
2118 $this->selfRedirect = true;
2119 $status->fatal( 'selfredirect' );
2120 $status->value = self::AS_SELF_REDIRECT;
2121 return $status;
2122 }
2123 }
2124
2125 // Check for length errors again now that the section is merged in
2126 $this->contentLength = strlen( $this->toEditText( $content ) );
2127 if ( $this->contentLength > $wgMaxArticleSize * 1024 ) {
2128 $this->tooBig = true;
2129 $status->setResult( false, self::AS_MAX_ARTICLE_SIZE_EXCEEDED );
2130 return $status;
2131 }
2132
2133 $flags = EDIT_AUTOSUMMARY |
2134 ( $new ? EDIT_NEW : EDIT_UPDATE ) |
2135 ( ( $this->minoredit && !$this->isNew ) ? EDIT_MINOR : 0 ) |
2136 ( $bot ? EDIT_FORCE_BOT : 0 );
2137
2138 $doEditStatus = $this->page->doEditContent(
2139 $content,
2140 $this->summary,
2141 $flags,
2142 false,
2143 $wgUser,
2144 $content->getDefaultFormat(),
2145 $this->changeTags
2146 );
2147
2148 if ( !$doEditStatus->isOK() ) {
2149 // Failure from doEdit()
2150 // Show the edit conflict page for certain recognized errors from doEdit(),
2151 // but don't show it for errors from extension hooks
2152 $errors = $doEditStatus->getErrorsArray();
2153 if ( in_array( $errors[0][0],
2154 [ 'edit-gone-missing', 'edit-conflict', 'edit-already-exists' ] )
2155 ) {
2156 $this->isConflict = true;
2157 // Destroys data doEdit() put in $status->value but who cares
2158 $doEditStatus->value = self::AS_END;
2159 }
2160 return $doEditStatus;
2161 }
2162
2163 $result['nullEdit'] = $doEditStatus->hasMessage( 'edit-no-change' );
2164 if ( $result['nullEdit'] ) {
2165 // We don't know if it was a null edit until now, so increment here
2166 $wgUser->pingLimiter( 'linkpurge' );
2167 }
2168 $result['redirect'] = $content->isRedirect();
2169
2170 $this->updateWatchlist();
2171
2172 // If the content model changed, add a log entry
2173 if ( $changingContentModel ) {
2174 $this->addContentModelChangeLogEntry(
2175 $wgUser,
2176 $new ? false : $oldContentModel,
2177 $this->contentModel,
2178 $this->summary
2179 );
2180 }
2181
2182 return $status;
2183 }
2184
2185 /**
2186 * @param User $user
2187 * @param string|false $oldModel false if the page is being newly created
2188 * @param string $newModel
2189 * @param string $reason
2190 */
2191 protected function addContentModelChangeLogEntry( User $user, $oldModel, $newModel, $reason ) {
2192 $new = $oldModel === false;
2193 $log = new ManualLogEntry( 'contentmodel', $new ? 'new' : 'change' );
2194 $log->setPerformer( $user );
2195 $log->setTarget( $this->mTitle );
2196 $log->setComment( $reason );
2197 $log->setParameters( [
2198 '4::oldmodel' => $oldModel,
2199 '5::newmodel' => $newModel
2200 ] );
2201 $logid = $log->insert();
2202 $log->publish( $logid );
2203 }
2204
2205 /**
2206 * Register the change of watch status
2207 */
2208 protected function updateWatchlist() {
2209 global $wgUser;
2210
2211 if ( !$wgUser->isLoggedIn() ) {
2212 return;
2213 }
2214
2215 $user = $wgUser;
2216 $title = $this->mTitle;
2217 $watch = $this->watchthis;
2218 // Do this in its own transaction to reduce contention...
2219 DeferredUpdates::addCallableUpdate( function () use ( $user, $title, $watch ) {
2220 if ( $watch == $user->isWatched( $title, User::IGNORE_USER_RIGHTS ) ) {
2221 return; // nothing to change
2222 }
2223 WatchAction::doWatchOrUnwatch( $watch, $title, $user );
2224 } );
2225 }
2226
2227 /**
2228 * Attempts to do 3-way merge of edit content with a base revision
2229 * and current content, in case of edit conflict, in whichever way appropriate
2230 * for the content type.
2231 *
2232 * @since 1.21
2233 *
2234 * @param Content $editContent
2235 *
2236 * @return bool
2237 */
2238 private function mergeChangesIntoContent( &$editContent ) {
2239 $db = wfGetDB( DB_MASTER );
2240
2241 // This is the revision the editor started from
2242 $baseRevision = $this->getBaseRevision();
2243 $baseContent = $baseRevision ? $baseRevision->getContent() : null;
2244
2245 if ( is_null( $baseContent ) ) {
2246 return false;
2247 }
2248
2249 // The current state, we want to merge updates into it
2250 $currentRevision = Revision::loadFromTitle( $db, $this->mTitle );
2251 $currentContent = $currentRevision ? $currentRevision->getContent() : null;
2252
2253 if ( is_null( $currentContent ) ) {
2254 return false;
2255 }
2256
2257 $handler = ContentHandler::getForModelID( $baseContent->getModel() );
2258
2259 $result = $handler->merge3( $baseContent, $editContent, $currentContent );
2260
2261 if ( $result ) {
2262 $editContent = $result;
2263 // Update parentRevId to what we just merged.
2264 $this->parentRevId = $currentRevision->getId();
2265 return true;
2266 }
2267
2268 return false;
2269 }
2270
2271 /**
2272 * @note: this method is very poorly named. If the user opened the form with ?oldid=X,
2273 * one might think of X as the "base revision", which is NOT what this returns.
2274 * @return Revision Current version when the edit was started
2275 */
2276 function getBaseRevision() {
2277 if ( !$this->mBaseRevision ) {
2278 $db = wfGetDB( DB_MASTER );
2279 $this->mBaseRevision = $this->editRevId
2280 ? Revision::newFromId( $this->editRevId, Revision::READ_LATEST )
2281 : Revision::loadFromTimestamp( $db, $this->mTitle, $this->edittime );
2282 }
2283 return $this->mBaseRevision;
2284 }
2285
2286 /**
2287 * Check given input text against $wgSpamRegex, and return the text of the first match.
2288 *
2289 * @param string $text
2290 *
2291 * @return string|bool Matching string or false
2292 */
2293 public static function matchSpamRegex( $text ) {
2294 global $wgSpamRegex;
2295 // For back compatibility, $wgSpamRegex may be a single string or an array of regexes.
2296 $regexes = (array)$wgSpamRegex;
2297 return self::matchSpamRegexInternal( $text, $regexes );
2298 }
2299
2300 /**
2301 * Check given input text against $wgSummarySpamRegex, and return the text of the first match.
2302 *
2303 * @param string $text
2304 *
2305 * @return string|bool Matching string or false
2306 */
2307 public static function matchSummarySpamRegex( $text ) {
2308 global $wgSummarySpamRegex;
2309 $regexes = (array)$wgSummarySpamRegex;
2310 return self::matchSpamRegexInternal( $text, $regexes );
2311 }
2312
2313 /**
2314 * @param string $text
2315 * @param array $regexes
2316 * @return bool|string
2317 */
2318 protected static function matchSpamRegexInternal( $text, $regexes ) {
2319 foreach ( $regexes as $regex ) {
2320 $matches = [];
2321 if ( preg_match( $regex, $text, $matches ) ) {
2322 return $matches[0];
2323 }
2324 }
2325 return false;
2326 }
2327
2328 function setHeaders() {
2329 global $wgOut, $wgUser, $wgAjaxEditStash, $wgCookieSetOnAutoblock;
2330
2331 $wgOut->addModules( 'mediawiki.action.edit' );
2332 if ( $wgCookieSetOnAutoblock === true ) {
2333 $wgOut->addModules( 'mediawiki.user.blockcookie' );
2334 }
2335 $wgOut->addModuleStyles( 'mediawiki.action.edit.styles' );
2336
2337 if ( $wgUser->getOption( 'showtoolbar' ) ) {
2338 // The addition of default buttons is handled by getEditToolbar() which
2339 // has its own dependency on this module. The call here ensures the module
2340 // is loaded in time (it has position "top") for other modules to register
2341 // buttons (e.g. extensions, gadgets, user scripts).
2342 $wgOut->addModules( 'mediawiki.toolbar' );
2343 }
2344
2345 if ( $wgUser->getOption( 'uselivepreview' ) ) {
2346 $wgOut->addModules( 'mediawiki.action.edit.preview' );
2347 }
2348
2349 if ( $wgUser->getOption( 'useeditwarning' ) ) {
2350 $wgOut->addModules( 'mediawiki.action.edit.editWarning' );
2351 }
2352
2353 # Enabled article-related sidebar, toplinks, etc.
2354 $wgOut->setArticleRelated( true );
2355
2356 $contextTitle = $this->getContextTitle();
2357 if ( $this->isConflict ) {
2358 $msg = 'editconflict';
2359 } elseif ( $contextTitle->exists() && $this->section != '' ) {
2360 $msg = $this->section == 'new' ? 'editingcomment' : 'editingsection';
2361 } else {
2362 $msg = $contextTitle->exists()
2363 || ( $contextTitle->getNamespace() == NS_MEDIAWIKI
2364 && $contextTitle->getDefaultMessageText() !== false
2365 )
2366 ? 'editing'
2367 : 'creating';
2368 }
2369
2370 # Use the title defined by DISPLAYTITLE magic word when present
2371 # NOTE: getDisplayTitle() returns HTML while getPrefixedText() returns plain text.
2372 # setPageTitle() treats the input as wikitext, which should be safe in either case.
2373 $displayTitle = isset( $this->mParserOutput ) ? $this->mParserOutput->getDisplayTitle() : false;
2374 if ( $displayTitle === false ) {
2375 $displayTitle = $contextTitle->getPrefixedText();
2376 }
2377 $wgOut->setPageTitle( $this->context->msg( $msg, $displayTitle ) );
2378 # Transmit the name of the message to JavaScript for live preview
2379 # Keep Resources.php/mediawiki.action.edit.preview in sync with the possible keys
2380 $wgOut->addJsConfigVars( [
2381 'wgEditMessage' => $msg,
2382 'wgAjaxEditStash' => $wgAjaxEditStash,
2383 ] );
2384 }
2385
2386 /**
2387 * Show all applicable editing introductions
2388 */
2389 protected function showIntro() {
2390 global $wgOut, $wgUser;
2391 if ( $this->suppressIntro ) {
2392 return;
2393 }
2394
2395 $namespace = $this->mTitle->getNamespace();
2396
2397 if ( $namespace == NS_MEDIAWIKI ) {
2398 # Show a warning if editing an interface message
2399 $wgOut->wrapWikiMsg( "<div class='mw-editinginterface'>\n$1\n</div>", 'editinginterface' );
2400 # If this is a default message (but not css or js),
2401 # show a hint that it is translatable on translatewiki.net
2402 if ( !$this->mTitle->hasContentModel( CONTENT_MODEL_CSS )
2403 && !$this->mTitle->hasContentModel( CONTENT_MODEL_JAVASCRIPT )
2404 ) {
2405 $defaultMessageText = $this->mTitle->getDefaultMessageText();
2406 if ( $defaultMessageText !== false ) {
2407 $wgOut->wrapWikiMsg( "<div class='mw-translateinterface'>\n$1\n</div>",
2408 'translateinterface' );
2409 }
2410 }
2411 } elseif ( $namespace == NS_FILE ) {
2412 # Show a hint to shared repo
2413 $file = wfFindFile( $this->mTitle );
2414 if ( $file && !$file->isLocal() ) {
2415 $descUrl = $file->getDescriptionUrl();
2416 # there must be a description url to show a hint to shared repo
2417 if ( $descUrl ) {
2418 if ( !$this->mTitle->exists() ) {
2419 $wgOut->wrapWikiMsg( "<div class=\"mw-sharedupload-desc-create\">\n$1\n</div>", [
2420 'sharedupload-desc-create', $file->getRepo()->getDisplayName(), $descUrl
2421 ] );
2422 } else {
2423 $wgOut->wrapWikiMsg( "<div class=\"mw-sharedupload-desc-edit\">\n$1\n</div>", [
2424 'sharedupload-desc-edit', $file->getRepo()->getDisplayName(), $descUrl
2425 ] );
2426 }
2427 }
2428 }
2429 }
2430
2431 # Show a warning message when someone creates/edits a user (talk) page but the user does not exist
2432 # Show log extract when the user is currently blocked
2433 if ( $namespace == NS_USER || $namespace == NS_USER_TALK ) {
2434 $username = explode( '/', $this->mTitle->getText(), 2 )[0];
2435 $user = User::newFromName( $username, false /* allow IP users*/ );
2436 $ip = User::isIP( $username );
2437 $block = Block::newFromTarget( $user, $user );
2438 if ( !( $user && $user->isLoggedIn() ) && !$ip ) { # User does not exist
2439 $wgOut->wrapWikiMsg( "<div class=\"mw-userpage-userdoesnotexist error\">\n$1\n</div>",
2440 [ 'userpage-userdoesnotexist', wfEscapeWikiText( $username ) ] );
2441 } elseif ( !is_null( $block ) && $block->getType() != Block::TYPE_AUTO ) {
2442 # Show log extract if the user is currently blocked
2443 LogEventsList::showLogExtract(
2444 $wgOut,
2445 'block',
2446 MWNamespace::getCanonicalName( NS_USER ) . ':' . $block->getTarget(),
2447 '',
2448 [
2449 'lim' => 1,
2450 'showIfEmpty' => false,
2451 'msgKey' => [
2452 'blocked-notice-logextract',
2453 $user->getName() # Support GENDER in notice
2454 ]
2455 ]
2456 );
2457 }
2458 }
2459 # Try to add a custom edit intro, or use the standard one if this is not possible.
2460 if ( !$this->showCustomIntro() && !$this->mTitle->exists() ) {
2461 $helpLink = wfExpandUrl( Skin::makeInternalOrExternalUrl(
2462 $this->context->msg( 'helppage' )->inContentLanguage()->text()
2463 ) );
2464 if ( $wgUser->isLoggedIn() ) {
2465 $wgOut->wrapWikiMsg(
2466 // Suppress the external link icon, consider the help url an internal one
2467 "<div class=\"mw-newarticletext plainlinks\">\n$1\n</div>",
2468 [
2469 'newarticletext',
2470 $helpLink
2471 ]
2472 );
2473 } else {
2474 $wgOut->wrapWikiMsg(
2475 // Suppress the external link icon, consider the help url an internal one
2476 "<div class=\"mw-newarticletextanon plainlinks\">\n$1\n</div>",
2477 [
2478 'newarticletextanon',
2479 $helpLink
2480 ]
2481 );
2482 }
2483 }
2484 # Give a notice if the user is editing a deleted/moved page...
2485 if ( !$this->mTitle->exists() ) {
2486 LogEventsList::showLogExtract( $wgOut, [ 'delete', 'move' ], $this->mTitle,
2487 '',
2488 [
2489 'lim' => 10,
2490 'conds' => [ "log_action != 'revision'" ],
2491 'showIfEmpty' => false,
2492 'msgKey' => [ 'recreate-moveddeleted-warn' ]
2493 ]
2494 );
2495 }
2496 }
2497
2498 /**
2499 * Attempt to show a custom editing introduction, if supplied
2500 *
2501 * @return bool
2502 */
2503 protected function showCustomIntro() {
2504 if ( $this->editintro ) {
2505 $title = Title::newFromText( $this->editintro );
2506 if ( $title instanceof Title && $title->exists() && $title->userCan( 'read' ) ) {
2507 global $wgOut;
2508 // Added using template syntax, to take <noinclude>'s into account.
2509 $wgOut->addWikiTextTitleTidy(
2510 '<div class="mw-editintro">{{:' . $title->getFullText() . '}}</div>',
2511 $this->mTitle
2512 );
2513 return true;
2514 }
2515 }
2516 return false;
2517 }
2518
2519 /**
2520 * Gets an editable textual representation of $content.
2521 * The textual representation can be turned by into a Content object by the
2522 * toEditContent() method.
2523 *
2524 * If $content is null or false or a string, $content is returned unchanged.
2525 *
2526 * If the given Content object is not of a type that can be edited using
2527 * the text base EditPage, an exception will be raised. Set
2528 * $this->allowNonTextContent to true to allow editing of non-textual
2529 * content.
2530 *
2531 * @param Content|null|bool|string $content
2532 * @return string The editable text form of the content.
2533 *
2534 * @throws MWException If $content is not an instance of TextContent and
2535 * $this->allowNonTextContent is not true.
2536 */
2537 protected function toEditText( $content ) {
2538 if ( $content === null || $content === false || is_string( $content ) ) {
2539 return $content;
2540 }
2541
2542 if ( !$this->isSupportedContentModel( $content->getModel() ) ) {
2543 throw new MWException( 'This content model is not supported: ' . $content->getModel() );
2544 }
2545
2546 return $content->serialize( $this->contentFormat );
2547 }
2548
2549 /**
2550 * Turns the given text into a Content object by unserializing it.
2551 *
2552 * If the resulting Content object is not of a type that can be edited using
2553 * the text base EditPage, an exception will be raised. Set
2554 * $this->allowNonTextContent to true to allow editing of non-textual
2555 * content.
2556 *
2557 * @param string|null|bool $text Text to unserialize
2558 * @return Content|bool|null The content object created from $text. If $text was false
2559 * or null, false resp. null will be returned instead.
2560 *
2561 * @throws MWException If unserializing the text results in a Content
2562 * object that is not an instance of TextContent and
2563 * $this->allowNonTextContent is not true.
2564 */
2565 protected function toEditContent( $text ) {
2566 if ( $text === false || $text === null ) {
2567 return $text;
2568 }
2569
2570 $content = ContentHandler::makeContent( $text, $this->getTitle(),
2571 $this->contentModel, $this->contentFormat );
2572
2573 if ( !$this->isSupportedContentModel( $content->getModel() ) ) {
2574 throw new MWException( 'This content model is not supported: ' . $content->getModel() );
2575 }
2576
2577 return $content;
2578 }
2579
2580 /**
2581 * Send the edit form and related headers to $wgOut
2582 * @param callable|null $formCallback That takes an OutputPage parameter; will be called
2583 * during form output near the top, for captchas and the like.
2584 *
2585 * The $formCallback parameter is deprecated since MediaWiki 1.25. Please
2586 * use the EditPage::showEditForm:fields hook instead.
2587 */
2588 function showEditForm( $formCallback = null ) {
2589 global $wgOut, $wgUser;
2590
2591 # need to parse the preview early so that we know which templates are used,
2592 # otherwise users with "show preview after edit box" will get a blank list
2593 # we parse this near the beginning so that setHeaders can do the title
2594 # setting work instead of leaving it in getPreviewText
2595 $previewOutput = '';
2596 if ( $this->formtype == 'preview' ) {
2597 $previewOutput = $this->getPreviewText();
2598 }
2599
2600 Hooks::run( 'EditPage::showEditForm:initial', [ &$this, &$wgOut ] );
2601
2602 $this->setHeaders();
2603
2604 $this->addTalkPageText();
2605 $this->addEditNotices();
2606
2607 if ( !$this->isConflict &&
2608 $this->section != '' &&
2609 !$this->isSectionEditSupported() ) {
2610 // We use $this->section to much before this and getVal('wgSection') directly in other places
2611 // at this point we can't reset $this->section to '' to fallback to non-section editing.
2612 // Someone is welcome to try refactoring though
2613 $wgOut->showErrorPage( 'sectioneditnotsupported-title', 'sectioneditnotsupported-text' );
2614 return;
2615 }
2616
2617 $this->showHeader();
2618
2619 $wgOut->addHTML( $this->editFormPageTop );
2620
2621 if ( $wgUser->getOption( 'previewontop' ) ) {
2622 $this->displayPreviewArea( $previewOutput, true );
2623 }
2624
2625 $wgOut->addHTML( $this->editFormTextTop );
2626
2627 $showToolbar = true;
2628 if ( $this->wasDeletedSinceLastEdit() ) {
2629 if ( $this->formtype == 'save' ) {
2630 // Hide the toolbar and edit area, user can click preview to get it back
2631 // Add an confirmation checkbox and explanation.
2632 $showToolbar = false;
2633 } else {
2634 $wgOut->wrapWikiMsg( "<div class='error mw-deleted-while-editing'>\n$1\n</div>",
2635 'deletedwhileediting' );
2636 }
2637 }
2638
2639 // @todo add EditForm plugin interface and use it here!
2640 // search for textarea1 and textares2, and allow EditForm to override all uses.
2641 $wgOut->addHTML( Html::openElement(
2642 'form',
2643 [
2644 'id' => self::EDITFORM_ID,
2645 'name' => self::EDITFORM_ID,
2646 'method' => 'post',
2647 'action' => $this->getActionURL( $this->getContextTitle() ),
2648 'enctype' => 'multipart/form-data'
2649 ]
2650 ) );
2651
2652 if ( is_callable( $formCallback ) ) {
2653 wfWarn( 'The $formCallback parameter to ' . __METHOD__ . 'is deprecated' );
2654 call_user_func_array( $formCallback, [ &$wgOut ] );
2655 }
2656
2657 // Add an empty field to trip up spambots
2658 $wgOut->addHTML(
2659 Xml::openElement( 'div', [ 'id' => 'antispam-container', 'style' => 'display: none;' ] )
2660 . Html::rawElement(
2661 'label',
2662 [ 'for' => 'wpAntispam' ],
2663 $this->context->msg( 'simpleantispam-label' )->parse()
2664 )
2665 . Xml::element(
2666 'input',
2667 [
2668 'type' => 'text',
2669 'name' => 'wpAntispam',
2670 'id' => 'wpAntispam',
2671 'value' => ''
2672 ]
2673 )
2674 . Xml::closeElement( 'div' )
2675 );
2676
2677 Hooks::run( 'EditPage::showEditForm:fields', [ &$this, &$wgOut ] );
2678
2679 // Put these up at the top to ensure they aren't lost on early form submission
2680 $this->showFormBeforeText();
2681
2682 if ( $this->wasDeletedSinceLastEdit() && 'save' == $this->formtype ) {
2683 $username = $this->lastDelete->user_name;
2684 $comment = $this->lastDelete->log_comment;
2685
2686 // It is better to not parse the comment at all than to have templates expanded in the middle
2687 // TODO: can the checkLabel be moved outside of the div so that wrapWikiMsg could be used?
2688 $key = $comment === ''
2689 ? 'confirmrecreate-noreason'
2690 : 'confirmrecreate';
2691 $wgOut->addHTML(
2692 '<div class="mw-confirm-recreate">' .
2693 $this->context->msg( $key, $username, "<nowiki>$comment</nowiki>" )->parse() .
2694 Xml::checkLabel( $this->context->msg( 'recreate' )->text(), 'wpRecreate', 'wpRecreate', false,
2695 [ 'title' => Linker::titleAttrib( 'recreate' ), 'tabindex' => 1, 'id' => 'wpRecreate' ]
2696 ) .
2697 '</div>'
2698 );
2699 }
2700
2701 # When the summary is hidden, also hide them on preview/show changes
2702 if ( $this->nosummary ) {
2703 $wgOut->addHTML( Html::hidden( 'nosummary', true ) );
2704 }
2705
2706 # If a blank edit summary was previously provided, and the appropriate
2707 # user preference is active, pass a hidden tag as wpIgnoreBlankSummary. This will stop the
2708 # user being bounced back more than once in the event that a summary
2709 # is not required.
2710 # ####
2711 # For a bit more sophisticated detection of blank summaries, hash the
2712 # automatic one and pass that in the hidden field wpAutoSummary.
2713 if ( $this->missingSummary || ( $this->section == 'new' && $this->nosummary ) ) {
2714 $wgOut->addHTML( Html::hidden( 'wpIgnoreBlankSummary', true ) );
2715 }
2716
2717 if ( $this->undidRev ) {
2718 $wgOut->addHTML( Html::hidden( 'wpUndidRevision', $this->undidRev ) );
2719 }
2720
2721 if ( $this->selfRedirect ) {
2722 $wgOut->addHTML( Html::hidden( 'wpIgnoreSelfRedirect', true ) );
2723 }
2724
2725 if ( $this->hasPresetSummary ) {
2726 // If a summary has been preset using &summary= we don't want to prompt for
2727 // a different summary. Only prompt for a summary if the summary is blanked.
2728 // (Bug 17416)
2729 $this->autoSumm = md5( '' );
2730 }
2731
2732 $autosumm = $this->autoSumm ? $this->autoSumm : md5( $this->summary );
2733 $wgOut->addHTML( Html::hidden( 'wpAutoSummary', $autosumm ) );
2734
2735 $wgOut->addHTML( Html::hidden( 'oldid', $this->oldid ) );
2736 $wgOut->addHTML( Html::hidden( 'parentRevId', $this->getParentRevId() ) );
2737
2738 $wgOut->addHTML( Html::hidden( 'format', $this->contentFormat ) );
2739 $wgOut->addHTML( Html::hidden( 'model', $this->contentModel ) );
2740
2741 if ( $this->section == 'new' ) {
2742 $this->showSummaryInput( true, $this->summary );
2743 $wgOut->addHTML( $this->getSummaryPreview( true, $this->summary ) );
2744 }
2745
2746 $wgOut->addHTML( $this->editFormTextBeforeContent );
2747
2748 if ( !$this->isCssJsSubpage && $showToolbar && $wgUser->getOption( 'showtoolbar' ) ) {
2749 $wgOut->addHTML( EditPage::getEditToolbar( $this->mTitle ) );
2750 }
2751
2752 if ( $this->blankArticle ) {
2753 $wgOut->addHTML( Html::hidden( 'wpIgnoreBlankArticle', true ) );
2754 }
2755
2756 if ( $this->isConflict ) {
2757 // In an edit conflict bypass the overridable content form method
2758 // and fallback to the raw wpTextbox1 since editconflicts can't be
2759 // resolved between page source edits and custom ui edits using the
2760 // custom edit ui.
2761 $this->textbox2 = $this->textbox1;
2762
2763 $content = $this->getCurrentContent();
2764 $this->textbox1 = $this->toEditText( $content );
2765
2766 $this->showTextbox1();
2767 } else {
2768 $this->showContentForm();
2769 }
2770
2771 $wgOut->addHTML( $this->editFormTextAfterContent );
2772
2773 $this->showStandardInputs();
2774
2775 $this->showFormAfterText();
2776
2777 $this->showTosSummary();
2778
2779 $this->showEditTools();
2780
2781 $wgOut->addHTML( $this->editFormTextAfterTools . "\n" );
2782
2783 $wgOut->addHTML( $this->makeTemplatesOnThisPageList( $this->getTemplates() ) );
2784
2785 $wgOut->addHTML( Html::rawElement( 'div', [ 'class' => 'hiddencats' ],
2786 Linker::formatHiddenCategories( $this->page->getHiddenCategories() ) ) );
2787
2788 $wgOut->addHTML( Html::rawElement( 'div', [ 'class' => 'limitreport' ],
2789 self::getPreviewLimitReport( $this->mParserOutput ) ) );
2790
2791 $wgOut->addModules( 'mediawiki.action.edit.collapsibleFooter' );
2792
2793 if ( $this->isConflict ) {
2794 try {
2795 $this->showConflict();
2796 } catch ( MWContentSerializationException $ex ) {
2797 // this can't really happen, but be nice if it does.
2798 $msg = $this->context->msg(
2799 'content-failed-to-parse',
2800 $this->contentModel,
2801 $this->contentFormat,
2802 $ex->getMessage()
2803 );
2804 $wgOut->addWikiText( '<div class="error">' . $msg->text() . '</div>' );
2805 }
2806 }
2807
2808 // Set a hidden field so JS knows what edit form mode we are in
2809 if ( $this->isConflict ) {
2810 $mode = 'conflict';
2811 } elseif ( $this->preview ) {
2812 $mode = 'preview';
2813 } elseif ( $this->diff ) {
2814 $mode = 'diff';
2815 } else {
2816 $mode = 'text';
2817 }
2818 $wgOut->addHTML( Html::hidden( 'mode', $mode, [ 'id' => 'mw-edit-mode' ] ) );
2819
2820 // Marker for detecting truncated form data. This must be the last
2821 // parameter sent in order to be of use, so do not move me.
2822 $wgOut->addHTML( Html::hidden( 'wpUltimateParam', true ) );
2823 $wgOut->addHTML( $this->editFormTextBottom . "\n</form>\n" );
2824
2825 if ( !$wgUser->getOption( 'previewontop' ) ) {
2826 $this->displayPreviewArea( $previewOutput, false );
2827 }
2828 }
2829
2830 /**
2831 * Wrapper around TemplatesOnThisPageFormatter to make
2832 * a "templates on this page" list.
2833 *
2834 * @param Title[] $templates
2835 * @return string HTML
2836 */
2837 protected function makeTemplatesOnThisPageList( array $templates ) {
2838 $templateListFormatter = new TemplatesOnThisPageFormatter(
2839 $this->context, MediaWikiServices::getInstance()->getLinkRenderer()
2840 );
2841
2842 // preview if preview, else section if section, else false
2843 $type = false;
2844 if ( $this->preview ) {
2845 $type = 'preview';
2846 } elseif ( $this->section != '' ) {
2847 $type = 'section';
2848 }
2849
2850 return Html::rawElement( 'div', [ 'class' => 'templatesUsed' ],
2851 $templateListFormatter->format( $templates, $type )
2852 );
2853 }
2854
2855 /**
2856 * Extract the section title from current section text, if any.
2857 *
2858 * @param string $text
2859 * @return string|bool String or false
2860 */
2861 public static function extractSectionTitle( $text ) {
2862 preg_match( "/^(=+)(.+)\\1\\s*(\n|$)/i", $text, $matches );
2863 if ( !empty( $matches[2] ) ) {
2864 global $wgParser;
2865 return $wgParser->stripSectionName( trim( $matches[2] ) );
2866 } else {
2867 return false;
2868 }
2869 }
2870
2871 protected function showHeader() {
2872 global $wgOut, $wgUser;
2873 global $wgAllowUserCss, $wgAllowUserJs;
2874
2875 if ( $this->isConflict ) {
2876 $this->addExplainConflictHeader( $wgOut );
2877 $this->editRevId = $this->page->getLatest();
2878 } else {
2879 if ( $this->section != '' && $this->section != 'new' ) {
2880 if ( !$this->summary && !$this->preview && !$this->diff ) {
2881 $sectionTitle = self::extractSectionTitle( $this->textbox1 ); // FIXME: use Content object
2882 if ( $sectionTitle !== false ) {
2883 $this->summary = "/* $sectionTitle */ ";
2884 }
2885 }
2886 }
2887
2888 if ( $this->missingComment ) {
2889 $wgOut->wrapWikiMsg( "<div id='mw-missingcommenttext'>\n$1\n</div>", 'missingcommenttext' );
2890 }
2891
2892 if ( $this->missingSummary && $this->section != 'new' ) {
2893 $wgOut->wrapWikiMsg( "<div id='mw-missingsummary'>\n$1\n</div>", 'missingsummary' );
2894 }
2895
2896 if ( $this->missingSummary && $this->section == 'new' ) {
2897 $wgOut->wrapWikiMsg( "<div id='mw-missingcommentheader'>\n$1\n</div>", 'missingcommentheader' );
2898 }
2899
2900 if ( $this->blankArticle ) {
2901 $wgOut->wrapWikiMsg( "<div id='mw-blankarticle'>\n$1\n</div>", 'blankarticle' );
2902 }
2903
2904 if ( $this->selfRedirect ) {
2905 $wgOut->wrapWikiMsg( "<div id='mw-selfredirect'>\n$1\n</div>", 'selfredirect' );
2906 }
2907
2908 if ( $this->hookError !== '' ) {
2909 $wgOut->addWikiText( $this->hookError );
2910 }
2911
2912 if ( !$this->checkUnicodeCompliantBrowser() ) {
2913 $wgOut->addWikiMsg( 'nonunicodebrowser' );
2914 }
2915
2916 if ( $this->section != 'new' ) {
2917 $revision = $this->mArticle->getRevisionFetched();
2918 if ( $revision ) {
2919 // Let sysop know that this will make private content public if saved
2920
2921 if ( !$revision->userCan( Revision::DELETED_TEXT, $wgUser ) ) {
2922 $wgOut->wrapWikiMsg(
2923 "<div class='mw-warning plainlinks'>\n$1\n</div>\n",
2924 'rev-deleted-text-permission'
2925 );
2926 } elseif ( $revision->isDeleted( Revision::DELETED_TEXT ) ) {
2927 $wgOut->wrapWikiMsg(
2928 "<div class='mw-warning plainlinks'>\n$1\n</div>\n",
2929 'rev-deleted-text-view'
2930 );
2931 }
2932
2933 if ( !$revision->isCurrent() ) {
2934 $this->mArticle->setOldSubtitle( $revision->getId() );
2935 $wgOut->addWikiMsg( 'editingold' );
2936 $this->isOldRev = true;
2937 }
2938 } elseif ( $this->mTitle->exists() ) {
2939 // Something went wrong
2940
2941 $wgOut->wrapWikiMsg( "<div class='errorbox'>\n$1\n</div>\n",
2942 [ 'missing-revision', $this->oldid ] );
2943 }
2944 }
2945 }
2946
2947 if ( wfReadOnly() ) {
2948 $wgOut->wrapWikiMsg(
2949 "<div id=\"mw-read-only-warning\">\n$1\n</div>",
2950 [ 'readonlywarning', wfReadOnlyReason() ]
2951 );
2952 } elseif ( $wgUser->isAnon() ) {
2953 if ( $this->formtype != 'preview' ) {
2954 $wgOut->wrapWikiMsg(
2955 "<div id='mw-anon-edit-warning' class='warningbox'>\n$1\n</div>",
2956 [ 'anoneditwarning',
2957 // Log-in link
2958 SpecialPage::getTitleFor( 'Userlogin' )->getFullURL( [
2959 'returnto' => $this->getTitle()->getPrefixedDBkey()
2960 ] ),
2961 // Sign-up link
2962 SpecialPage::getTitleFor( 'CreateAccount' )->getFullURL( [
2963 'returnto' => $this->getTitle()->getPrefixedDBkey()
2964 ] )
2965 ]
2966 );
2967 } else {
2968 $wgOut->wrapWikiMsg( "<div id=\"mw-anon-preview-warning\" class=\"warningbox\">\n$1</div>",
2969 'anonpreviewwarning'
2970 );
2971 }
2972 } else {
2973 if ( $this->isCssJsSubpage ) {
2974 # Check the skin exists
2975 if ( $this->isWrongCaseCssJsPage ) {
2976 $wgOut->wrapWikiMsg(
2977 "<div class='error' id='mw-userinvalidcssjstitle'>\n$1\n</div>",
2978 [ 'userinvalidcssjstitle', $this->mTitle->getSkinFromCssJsSubpage() ]
2979 );
2980 }
2981 if ( $this->getTitle()->isSubpageOf( $wgUser->getUserPage() ) ) {
2982 $wgOut->wrapWikiMsg( '<div class="mw-usercssjspublic">$1</div>',
2983 $this->isCssSubpage ? 'usercssispublic' : 'userjsispublic'
2984 );
2985 if ( $this->formtype !== 'preview' ) {
2986 if ( $this->isCssSubpage && $wgAllowUserCss ) {
2987 $wgOut->wrapWikiMsg(
2988 "<div id='mw-usercssyoucanpreview'>\n$1\n</div>",
2989 [ 'usercssyoucanpreview' ]
2990 );
2991 }
2992
2993 if ( $this->isJsSubpage && $wgAllowUserJs ) {
2994 $wgOut->wrapWikiMsg(
2995 "<div id='mw-userjsyoucanpreview'>\n$1\n</div>",
2996 [ 'userjsyoucanpreview' ]
2997 );
2998 }
2999 }
3000 }
3001 }
3002 }
3003
3004 $this->addPageProtectionWarningHeaders();
3005
3006 $this->addLongPageWarningHeader();
3007
3008 # Add header copyright warning
3009 $this->showHeaderCopyrightWarning();
3010 }
3011
3012 /**
3013 * Standard summary input and label (wgSummary), abstracted so EditPage
3014 * subclasses may reorganize the form.
3015 * Note that you do not need to worry about the label's for=, it will be
3016 * inferred by the id given to the input. You can remove them both by
3017 * passing [ 'id' => false ] to $userInputAttrs.
3018 *
3019 * @param string $summary The value of the summary input
3020 * @param string $labelText The html to place inside the label
3021 * @param array $inputAttrs Array of attrs to use on the input
3022 * @param array $spanLabelAttrs Array of attrs to use on the span inside the label
3023 *
3024 * @return array An array in the format [ $label, $input ]
3025 */
3026 function getSummaryInput( $summary = "", $labelText = null,
3027 $inputAttrs = null, $spanLabelAttrs = null
3028 ) {
3029 // Note: the maxlength is overridden in JS to 255 and to make it use UTF-8 bytes, not characters.
3030 $inputAttrs = ( is_array( $inputAttrs ) ? $inputAttrs : [] ) + [
3031 'id' => 'wpSummary',
3032 'maxlength' => '200',
3033 'tabindex' => '1',
3034 'size' => 60,
3035 'spellcheck' => 'true',
3036 ] + Linker::tooltipAndAccesskeyAttribs( 'summary' );
3037
3038 $spanLabelAttrs = ( is_array( $spanLabelAttrs ) ? $spanLabelAttrs : [] ) + [
3039 'class' => $this->missingSummary ? 'mw-summarymissed' : 'mw-summary',
3040 'id' => "wpSummaryLabel"
3041 ];
3042
3043 $label = null;
3044 if ( $labelText ) {
3045 $label = Xml::tags(
3046 'label',
3047 $inputAttrs['id'] ? [ 'for' => $inputAttrs['id'] ] : null,
3048 $labelText
3049 );
3050 $label = Xml::tags( 'span', $spanLabelAttrs, $label );
3051 }
3052
3053 $input = Html::input( 'wpSummary', $summary, 'text', $inputAttrs );
3054
3055 return [ $label, $input ];
3056 }
3057
3058 /**
3059 * @param bool $isSubjectPreview True if this is the section subject/title
3060 * up top, or false if this is the comment summary
3061 * down below the textarea
3062 * @param string $summary The text of the summary to display
3063 */
3064 protected function showSummaryInput( $isSubjectPreview, $summary = "" ) {
3065 global $wgOut;
3066 # Add a class if 'missingsummary' is triggered to allow styling of the summary line
3067 $summaryClass = $this->missingSummary ? 'mw-summarymissed' : 'mw-summary';
3068 if ( $isSubjectPreview ) {
3069 if ( $this->nosummary ) {
3070 return;
3071 }
3072 } else {
3073 if ( !$this->mShowSummaryField ) {
3074 return;
3075 }
3076 }
3077 $labelText = $this->context->msg( $isSubjectPreview ? 'subject' : 'summary' )->parse();
3078 list( $label, $input ) = $this->getSummaryInput(
3079 $summary,
3080 $labelText,
3081 [ 'class' => $summaryClass ],
3082 []
3083 );
3084 $wgOut->addHTML( "{$label} {$input}" );
3085 }
3086
3087 /**
3088 * @param bool $isSubjectPreview True if this is the section subject/title
3089 * up top, or false if this is the comment summary
3090 * down below the textarea
3091 * @param string $summary The text of the summary to display
3092 * @return string
3093 */
3094 protected function getSummaryPreview( $isSubjectPreview, $summary = "" ) {
3095 // avoid spaces in preview, gets always trimmed on save
3096 $summary = trim( $summary );
3097 if ( !$summary || ( !$this->preview && !$this->diff ) ) {
3098 return "";
3099 }
3100
3101 global $wgParser;
3102
3103 if ( $isSubjectPreview ) {
3104 $summary = $this->context->msg( 'newsectionsummary' )
3105 ->rawParams( $wgParser->stripSectionName( $summary ) )
3106 ->inContentLanguage()->text();
3107 }
3108
3109 $message = $isSubjectPreview ? 'subject-preview' : 'summary-preview';
3110
3111 $summary = $this->context->msg( $message )->parse()
3112 . Linker::commentBlock( $summary, $this->mTitle, $isSubjectPreview );
3113 return Xml::tags( 'div', [ 'class' => 'mw-summary-preview' ], $summary );
3114 }
3115
3116 protected function showFormBeforeText() {
3117 global $wgOut;
3118 $section = htmlspecialchars( $this->section );
3119 $wgOut->addHTML( <<<HTML
3120 <input type='hidden' value="{$section}" name="wpSection"/>
3121 <input type='hidden' value="{$this->starttime}" name="wpStarttime" />
3122 <input type='hidden' value="{$this->edittime}" name="wpEdittime" />
3123 <input type='hidden' value="{$this->editRevId}" name="editRevId" />
3124 <input type='hidden' value="{$this->scrolltop}" name="wpScrolltop" id="wpScrolltop" />
3125
3126 HTML
3127 );
3128 if ( !$this->checkUnicodeCompliantBrowser() ) {
3129 $wgOut->addHTML( Html::hidden( 'safemode', '1' ) );
3130 }
3131 }
3132
3133 protected function showFormAfterText() {
3134 global $wgOut, $wgUser;
3135 /**
3136 * To make it harder for someone to slip a user a page
3137 * which submits an edit form to the wiki without their
3138 * knowledge, a random token is associated with the login
3139 * session. If it's not passed back with the submission,
3140 * we won't save the page, or render user JavaScript and
3141 * CSS previews.
3142 *
3143 * For anon editors, who may not have a session, we just
3144 * include the constant suffix to prevent editing from
3145 * broken text-mangling proxies.
3146 */
3147 $wgOut->addHTML( "\n" . Html::hidden( "wpEditToken", $wgUser->getEditToken() ) . "\n" );
3148 }
3149
3150 /**
3151 * Subpage overridable method for printing the form for page content editing
3152 * By default this simply outputs wpTextbox1
3153 * Subclasses can override this to provide a custom UI for editing;
3154 * be it a form, or simply wpTextbox1 with a modified content that will be
3155 * reverse modified when extracted from the post data.
3156 * Note that this is basically the inverse for importContentFormData
3157 */
3158 protected function showContentForm() {
3159 $this->showTextbox1();
3160 }
3161
3162 /**
3163 * Method to output wpTextbox1
3164 * The $textoverride method can be used by subclasses overriding showContentForm
3165 * to pass back to this method.
3166 *
3167 * @param array $customAttribs Array of html attributes to use in the textarea
3168 * @param string $textoverride Optional text to override $this->textarea1 with
3169 */
3170 protected function showTextbox1( $customAttribs = null, $textoverride = null ) {
3171 if ( $this->wasDeletedSinceLastEdit() && $this->formtype == 'save' ) {
3172 $attribs = [ 'style' => 'display:none;' ];
3173 } else {
3174 $classes = []; // Textarea CSS
3175 if ( $this->mTitle->isProtected( 'edit' ) &&
3176 MWNamespace::getRestrictionLevels( $this->mTitle->getNamespace() ) !== [ '' ]
3177 ) {
3178 # Is the title semi-protected?
3179 if ( $this->mTitle->isSemiProtected() ) {
3180 $classes[] = 'mw-textarea-sprotected';
3181 } else {
3182 # Then it must be protected based on static groups (regular)
3183 $classes[] = 'mw-textarea-protected';
3184 }
3185 # Is the title cascade-protected?
3186 if ( $this->mTitle->isCascadeProtected() ) {
3187 $classes[] = 'mw-textarea-cprotected';
3188 }
3189 }
3190 # Is an old revision being edited?
3191 if ( $this->isOldRev ) {
3192 $classes[] = 'mw-textarea-oldrev';
3193 }
3194
3195 $attribs = [ 'tabindex' => 1 ];
3196
3197 if ( is_array( $customAttribs ) ) {
3198 $attribs += $customAttribs;
3199 }
3200
3201 if ( count( $classes ) ) {
3202 if ( isset( $attribs['class'] ) ) {
3203 $classes[] = $attribs['class'];
3204 }
3205 $attribs['class'] = implode( ' ', $classes );
3206 }
3207 }
3208
3209 $this->showTextbox(
3210 $textoverride !== null ? $textoverride : $this->textbox1,
3211 'wpTextbox1',
3212 $attribs
3213 );
3214 }
3215
3216 protected function showTextbox2() {
3217 $this->showTextbox( $this->textbox2, 'wpTextbox2', [ 'tabindex' => 6, 'readonly' ] );
3218 }
3219
3220 protected function showTextbox( $text, $name, $customAttribs = [] ) {
3221 global $wgOut, $wgUser;
3222
3223 $wikitext = $this->safeUnicodeOutput( $text );
3224 $wikitext = $this->addNewLineAtEnd( $wikitext );
3225
3226 $attribs = $this->buildTextboxAttribs( $name, $customAttribs, $wgUser );
3227
3228 $wgOut->addHTML( Html::textarea( $name, $wikitext, $attribs ) );
3229 }
3230
3231 protected function displayPreviewArea( $previewOutput, $isOnTop = false ) {
3232 global $wgOut;
3233 $classes = [];
3234 if ( $isOnTop ) {
3235 $classes[] = 'ontop';
3236 }
3237
3238 $attribs = [ 'id' => 'wikiPreview', 'class' => implode( ' ', $classes ) ];
3239
3240 if ( $this->formtype != 'preview' ) {
3241 $attribs['style'] = 'display: none;';
3242 }
3243
3244 $wgOut->addHTML( Xml::openElement( 'div', $attribs ) );
3245
3246 if ( $this->formtype == 'preview' ) {
3247 $this->showPreview( $previewOutput );
3248 } else {
3249 // Empty content container for LivePreview
3250 $pageViewLang = $this->mTitle->getPageViewLanguage();
3251 $attribs = [ 'lang' => $pageViewLang->getHtmlCode(), 'dir' => $pageViewLang->getDir(),
3252 'class' => 'mw-content-' . $pageViewLang->getDir() ];
3253 $wgOut->addHTML( Html::rawElement( 'div', $attribs ) );
3254 }
3255
3256 $wgOut->addHTML( '</div>' );
3257
3258 if ( $this->formtype == 'diff' ) {
3259 try {
3260 $this->showDiff();
3261 } catch ( MWContentSerializationException $ex ) {
3262 $msg = $this->context->msg(
3263 'content-failed-to-parse',
3264 $this->contentModel,
3265 $this->contentFormat,
3266 $ex->getMessage()
3267 );
3268 $wgOut->addWikiText( '<div class="error">' . $msg->text() . '</div>' );
3269 }
3270 }
3271 }
3272
3273 /**
3274 * Append preview output to $wgOut.
3275 * Includes category rendering if this is a category page.
3276 *
3277 * @param string $text The HTML to be output for the preview.
3278 */
3279 protected function showPreview( $text ) {
3280 global $wgOut;
3281 if ( $this->mTitle->getNamespace() == NS_CATEGORY ) {
3282 $this->mArticle->openShowCategory();
3283 }
3284 # This hook seems slightly odd here, but makes things more
3285 # consistent for extensions.
3286 Hooks::run( 'OutputPageBeforeHTML', [ &$wgOut, &$text ] );
3287 $wgOut->addHTML( $text );
3288 if ( $this->mTitle->getNamespace() == NS_CATEGORY ) {
3289 $this->mArticle->closeShowCategory();
3290 }
3291 }
3292
3293 /**
3294 * Get a diff between the current contents of the edit box and the
3295 * version of the page we're editing from.
3296 *
3297 * If this is a section edit, we'll replace the section as for final
3298 * save and then make a comparison.
3299 */
3300 function showDiff() {
3301 global $wgUser, $wgContLang, $wgOut;
3302
3303 $oldtitlemsg = 'currentrev';
3304 # if message does not exist, show diff against the preloaded default
3305 if ( $this->mTitle->getNamespace() == NS_MEDIAWIKI && !$this->mTitle->exists() ) {
3306 $oldtext = $this->mTitle->getDefaultMessageText();
3307 if ( $oldtext !== false ) {
3308 $oldtitlemsg = 'defaultmessagetext';
3309 $oldContent = $this->toEditContent( $oldtext );
3310 } else {
3311 $oldContent = null;
3312 }
3313 } else {
3314 $oldContent = $this->getCurrentContent();
3315 }
3316
3317 $textboxContent = $this->toEditContent( $this->textbox1 );
3318 if ( $this->editRevId !== null ) {
3319 $newContent = $this->page->replaceSectionAtRev(
3320 $this->section, $textboxContent, $this->summary, $this->editRevId
3321 );
3322 } else {
3323 $newContent = $this->page->replaceSectionContent(
3324 $this->section, $textboxContent, $this->summary, $this->edittime
3325 );
3326 }
3327
3328 if ( $newContent ) {
3329 Hooks::run( 'EditPageGetDiffContent', [ $this, &$newContent ] );
3330
3331 $popts = ParserOptions::newFromUserAndLang( $wgUser, $wgContLang );
3332 $newContent = $newContent->preSaveTransform( $this->mTitle, $wgUser, $popts );
3333 }
3334
3335 if ( ( $oldContent && !$oldContent->isEmpty() ) || ( $newContent && !$newContent->isEmpty() ) ) {
3336 $oldtitle = $this->context->msg( $oldtitlemsg )->parse();
3337 $newtitle = $this->context->msg( 'yourtext' )->parse();
3338
3339 if ( !$oldContent ) {
3340 $oldContent = $newContent->getContentHandler()->makeEmptyContent();
3341 }
3342
3343 if ( !$newContent ) {
3344 $newContent = $oldContent->getContentHandler()->makeEmptyContent();
3345 }
3346
3347 $de = $oldContent->getContentHandler()->createDifferenceEngine( $this->mArticle->getContext() );
3348 $de->setContent( $oldContent, $newContent );
3349
3350 $difftext = $de->getDiff( $oldtitle, $newtitle );
3351 $de->showDiffStyle();
3352 } else {
3353 $difftext = '';
3354 }
3355
3356 $wgOut->addHTML( '<div id="wikiDiff">' . $difftext . '</div>' );
3357 }
3358
3359 /**
3360 * Show the header copyright warning.
3361 */
3362 protected function showHeaderCopyrightWarning() {
3363 $msg = 'editpage-head-copy-warn';
3364 if ( !$this->context->msg( $msg )->isDisabled() ) {
3365 global $wgOut;
3366 $wgOut->wrapWikiMsg( "<div class='editpage-head-copywarn'>\n$1\n</div>",
3367 'editpage-head-copy-warn' );
3368 }
3369 }
3370
3371 /**
3372 * Give a chance for site and per-namespace customizations of
3373 * terms of service summary link that might exist separately
3374 * from the copyright notice.
3375 *
3376 * This will display between the save button and the edit tools,
3377 * so should remain short!
3378 */
3379 protected function showTosSummary() {
3380 $msg = 'editpage-tos-summary';
3381 Hooks::run( 'EditPageTosSummary', [ $this->mTitle, &$msg ] );
3382 if ( !$this->context->msg( $msg )->isDisabled() ) {
3383 global $wgOut;
3384 $wgOut->addHTML( '<div class="mw-tos-summary">' );
3385 $wgOut->addWikiMsg( $msg );
3386 $wgOut->addHTML( '</div>' );
3387 }
3388 }
3389
3390 protected function showEditTools() {
3391 global $wgOut;
3392 $wgOut->addHTML( '<div class="mw-editTools">' .
3393 $this->context->msg( 'edittools' )->inContentLanguage()->parse() .
3394 '</div>' );
3395 }
3396
3397 /**
3398 * Get the copyright warning
3399 *
3400 * Renamed to getCopyrightWarning(), old name kept around for backwards compatibility
3401 * @return string
3402 */
3403 protected function getCopywarn() {
3404 return self::getCopyrightWarning( $this->mTitle );
3405 }
3406
3407 /**
3408 * Get the copyright warning, by default returns wikitext
3409 *
3410 * @param Title $title
3411 * @param string $format Output format, valid values are any function of a Message object
3412 * @param Language|string|null $langcode Language code or Language object.
3413 * @return string
3414 */
3415 public static function getCopyrightWarning( $title, $format = 'plain', $langcode = null ) {
3416 global $wgRightsText;
3417 if ( $wgRightsText ) {
3418 $copywarnMsg = [ 'copyrightwarning',
3419 '[[' . wfMessage( 'copyrightpage' )->inContentLanguage()->text() . ']]',
3420 $wgRightsText ];
3421 } else {
3422 $copywarnMsg = [ 'copyrightwarning2',
3423 '[[' . wfMessage( 'copyrightpage' )->inContentLanguage()->text() . ']]' ];
3424 }
3425 // Allow for site and per-namespace customization of contribution/copyright notice.
3426 Hooks::run( 'EditPageCopyrightWarning', [ $title, &$copywarnMsg ] );
3427
3428 $msg = call_user_func_array( 'wfMessage', $copywarnMsg )->title( $title );
3429 if ( $langcode ) {
3430 $msg->inLanguage( $langcode );
3431 }
3432 return "<div id=\"editpage-copywarn\">\n" .
3433 $msg->$format() . "\n</div>";
3434 }
3435
3436 /**
3437 * Get the Limit report for page previews
3438 *
3439 * @since 1.22
3440 * @param ParserOutput $output ParserOutput object from the parse
3441 * @return string HTML
3442 */
3443 public static function getPreviewLimitReport( $output ) {
3444 if ( !$output || !$output->getLimitReportData() ) {
3445 return '';
3446 }
3447
3448 $limitReport = Html::rawElement( 'div', [ 'class' => 'mw-limitReportExplanation' ],
3449 wfMessage( 'limitreport-title' )->parseAsBlock()
3450 );
3451
3452 // Show/hide animation doesn't work correctly on a table, so wrap it in a div.
3453 $limitReport .= Html::openElement( 'div', [ 'class' => 'preview-limit-report-wrapper' ] );
3454
3455 $limitReport .= Html::openElement( 'table', [
3456 'class' => 'preview-limit-report wikitable'
3457 ] ) .
3458 Html::openElement( 'tbody' );
3459
3460 foreach ( $output->getLimitReportData() as $key => $value ) {
3461 if ( Hooks::run( 'ParserLimitReportFormat',
3462 [ $key, &$value, &$limitReport, true, true ]
3463 ) ) {
3464 $keyMsg = wfMessage( $key );
3465 $valueMsg = wfMessage( [ "$key-value-html", "$key-value" ] );
3466 if ( !$valueMsg->exists() ) {
3467 $valueMsg = new RawMessage( '$1' );
3468 }
3469 if ( !$keyMsg->isDisabled() && !$valueMsg->isDisabled() ) {
3470 $limitReport .= Html::openElement( 'tr' ) .
3471 Html::rawElement( 'th', null, $keyMsg->parse() ) .
3472 Html::rawElement( 'td', null, $valueMsg->params( $value )->parse() ) .
3473 Html::closeElement( 'tr' );
3474 }
3475 }
3476 }
3477
3478 $limitReport .= Html::closeElement( 'tbody' ) .
3479 Html::closeElement( 'table' ) .
3480 Html::closeElement( 'div' );
3481
3482 return $limitReport;
3483 }
3484
3485 protected function showStandardInputs( &$tabindex = 2 ) {
3486 global $wgOut;
3487 $wgOut->addHTML( "<div class='editOptions'>\n" );
3488
3489 if ( $this->section != 'new' ) {
3490 $this->showSummaryInput( false, $this->summary );
3491 $wgOut->addHTML( $this->getSummaryPreview( false, $this->summary ) );
3492 }
3493
3494 $checkboxes = $this->getCheckboxes( $tabindex,
3495 [ 'minor' => $this->minoredit, 'watch' => $this->watchthis ] );
3496 $wgOut->addHTML( "<div class='editCheckboxes'>" . implode( $checkboxes, "\n" ) . "</div>\n" );
3497
3498 // Show copyright warning.
3499 $wgOut->addWikiText( $this->getCopywarn() );
3500 $wgOut->addHTML( $this->editFormTextAfterWarn );
3501
3502 $wgOut->addHTML( "<div class='editButtons'>\n" );
3503 $wgOut->addHTML( implode( $this->getEditButtons( $tabindex ), "\n" ) . "\n" );
3504
3505 $cancel = $this->getCancelLink();
3506 if ( $cancel !== '' ) {
3507 $cancel .= Html::element( 'span',
3508 [ 'class' => 'mw-editButtons-pipe-separator' ],
3509 $this->context->msg( 'pipe-separator' )->text() );
3510 }
3511
3512 $message = $this->context->msg( 'edithelppage' )->inContentLanguage()->text();
3513 $edithelpurl = Skin::makeInternalOrExternalUrl( $message );
3514 $attrs = [
3515 'target' => 'helpwindow',
3516 'href' => $edithelpurl,
3517 ];
3518 $edithelp = Html::linkButton( $this->context->msg( 'edithelp' )->text(),
3519 $attrs, [ 'mw-ui-quiet' ] ) .
3520 $this->context->msg( 'word-separator' )->escaped() .
3521 $this->context->msg( 'newwindow' )->parse();
3522
3523 $wgOut->addHTML( " <span class='cancelLink'>{$cancel}</span>\n" );
3524 $wgOut->addHTML( " <span class='editHelp'>{$edithelp}</span>\n" );
3525 $wgOut->addHTML( "</div><!-- editButtons -->\n" );
3526
3527 Hooks::run( 'EditPage::showStandardInputs:options', [ $this, $wgOut, &$tabindex ] );
3528
3529 $wgOut->addHTML( "</div><!-- editOptions -->\n" );
3530 }
3531
3532 /**
3533 * Show an edit conflict. textbox1 is already shown in showEditForm().
3534 * If you want to use another entry point to this function, be careful.
3535 */
3536 protected function showConflict() {
3537 global $wgOut;
3538
3539 if ( Hooks::run( 'EditPageBeforeConflictDiff', [ &$this, &$wgOut ] ) ) {
3540 $stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
3541 $stats->increment( 'edit.failures.conflict' );
3542 // Only include 'standard' namespaces to avoid creating unknown numbers of statsd metrics
3543 if (
3544 $this->mTitle->getNamespace() >= NS_MAIN &&
3545 $this->mTitle->getNamespace() <= NS_CATEGORY_TALK
3546 ) {
3547 $stats->increment( 'edit.failures.conflict.byNamespaceId.' . $this->mTitle->getNamespace() );
3548 }
3549
3550 $wgOut->wrapWikiMsg( '<h2>$1</h2>', "yourdiff" );
3551
3552 $content1 = $this->toEditContent( $this->textbox1 );
3553 $content2 = $this->toEditContent( $this->textbox2 );
3554
3555 $handler = ContentHandler::getForModelID( $this->contentModel );
3556 $de = $handler->createDifferenceEngine( $this->mArticle->getContext() );
3557 $de->setContent( $content2, $content1 );
3558 $de->showDiff(
3559 $this->context->msg( 'yourtext' )->parse(),
3560 $this->context->msg( 'storedversion' )->text()
3561 );
3562
3563 $wgOut->wrapWikiMsg( '<h2>$1</h2>', "yourtext" );
3564 $this->showTextbox2();
3565 }
3566 }
3567
3568 /**
3569 * @return string
3570 */
3571 public function getCancelLink() {
3572 $cancelParams = [];
3573 if ( !$this->isConflict && $this->oldid > 0 ) {
3574 $cancelParams['oldid'] = $this->oldid;
3575 } elseif ( $this->getContextTitle()->isRedirect() ) {
3576 $cancelParams['redirect'] = 'no';
3577 }
3578 $attrs = [ 'id' => 'mw-editform-cancel' ];
3579
3580 return Linker::linkKnown(
3581 $this->getContextTitle(),
3582 $this->context->msg( 'cancel' )->parse(),
3583 Html::buttonAttributes( $attrs, [ 'mw-ui-quiet' ] ),
3584 $cancelParams
3585 );
3586 }
3587
3588 /**
3589 * Returns the URL to use in the form's action attribute.
3590 * This is used by EditPage subclasses when simply customizing the action
3591 * variable in the constructor is not enough. This can be used when the
3592 * EditPage lives inside of a Special page rather than a custom page action.
3593 *
3594 * @param Title $title Title object for which is being edited (where we go to for &action= links)
3595 * @return string
3596 */
3597 protected function getActionURL( Title $title ) {
3598 return $title->getLocalURL( [ 'action' => $this->action ] );
3599 }
3600
3601 /**
3602 * Check if a page was deleted while the user was editing it, before submit.
3603 * Note that we rely on the logging table, which hasn't been always there,
3604 * but that doesn't matter, because this only applies to brand new
3605 * deletes.
3606 * @return bool
3607 */
3608 protected function wasDeletedSinceLastEdit() {
3609 if ( $this->deletedSinceEdit !== null ) {
3610 return $this->deletedSinceEdit;
3611 }
3612
3613 $this->deletedSinceEdit = false;
3614
3615 if ( !$this->mTitle->exists() && $this->mTitle->isDeletedQuick() ) {
3616 $this->lastDelete = $this->getLastDelete();
3617 if ( $this->lastDelete ) {
3618 $deleteTime = wfTimestamp( TS_MW, $this->lastDelete->log_timestamp );
3619 if ( $deleteTime > $this->starttime ) {
3620 $this->deletedSinceEdit = true;
3621 }
3622 }
3623 }
3624
3625 return $this->deletedSinceEdit;
3626 }
3627
3628 /**
3629 * @return bool|stdClass
3630 */
3631 protected function getLastDelete() {
3632 $dbr = wfGetDB( DB_REPLICA );
3633 $data = $dbr->selectRow(
3634 [ 'logging', 'user' ],
3635 [
3636 'log_type',
3637 'log_action',
3638 'log_timestamp',
3639 'log_user',
3640 'log_namespace',
3641 'log_title',
3642 'log_comment',
3643 'log_params',
3644 'log_deleted',
3645 'user_name'
3646 ], [
3647 'log_namespace' => $this->mTitle->getNamespace(),
3648 'log_title' => $this->mTitle->getDBkey(),
3649 'log_type' => 'delete',
3650 'log_action' => 'delete',
3651 'user_id=log_user'
3652 ],
3653 __METHOD__,
3654 [ 'LIMIT' => 1, 'ORDER BY' => 'log_timestamp DESC' ]
3655 );
3656 // Quick paranoid permission checks...
3657 if ( is_object( $data ) ) {
3658 if ( $data->log_deleted & LogPage::DELETED_USER ) {
3659 $data->user_name = $this->context->msg( 'rev-deleted-user' )->escaped();
3660 }
3661
3662 if ( $data->log_deleted & LogPage::DELETED_COMMENT ) {
3663 $data->log_comment = $this->context->msg( 'rev-deleted-comment' )->escaped();
3664 }
3665 }
3666
3667 return $data;
3668 }
3669
3670 /**
3671 * Get the rendered text for previewing.
3672 * @throws MWException
3673 * @return string
3674 */
3675 function getPreviewText() {
3676 global $wgOut, $wgRawHtml, $wgLang;
3677 global $wgAllowUserCss, $wgAllowUserJs;
3678
3679 $stats = MediaWikiServices::getInstance()->getStatsdDataFactory();
3680
3681 if ( $wgRawHtml && !$this->mTokenOk ) {
3682 // Could be an offsite preview attempt. This is very unsafe if
3683 // HTML is enabled, as it could be an attack.
3684 $parsedNote = '';
3685 if ( $this->textbox1 !== '' ) {
3686 // Do not put big scary notice, if previewing the empty
3687 // string, which happens when you initially edit
3688 // a category page, due to automatic preview-on-open.
3689 $parsedNote = $wgOut->parse( "<div class='previewnote'>" .
3690 $this->context->msg( 'session_fail_preview_html' )->text() . "</div>",
3691 true, /* interface */true );
3692 }
3693 $stats->increment( 'edit.failures.session_loss' );
3694 return $parsedNote;
3695 }
3696
3697 $note = '';
3698
3699 try {
3700 $content = $this->toEditContent( $this->textbox1 );
3701
3702 $previewHTML = '';
3703 if ( !Hooks::run(
3704 'AlternateEditPreview',
3705 [ $this, &$content, &$previewHTML, &$this->mParserOutput ] )
3706 ) {
3707 return $previewHTML;
3708 }
3709
3710 # provide a anchor link to the editform
3711 $continueEditing = '<span class="mw-continue-editing">' .
3712 '[[#' . self::EDITFORM_ID . '|' . $wgLang->getArrow() . ' ' .
3713 $this->context->msg( 'continue-editing' )->text() . ']]</span>';
3714 if ( $this->mTriedSave && !$this->mTokenOk ) {
3715 if ( $this->mTokenOkExceptSuffix ) {
3716 $note = $this->context->msg( 'token_suffix_mismatch' )->plain();
3717 $stats->increment( 'edit.failures.bad_token' );
3718 } else {
3719 $note = $this->context->msg( 'session_fail_preview' )->plain();
3720 $stats->increment( 'edit.failures.session_loss' );
3721 }
3722 } elseif ( $this->incompleteForm ) {
3723 $note = $this->context->msg( 'edit_form_incomplete' )->plain();
3724 if ( $this->mTriedSave ) {
3725 $stats->increment( 'edit.failures.incomplete_form' );
3726 }
3727 } else {
3728 $note = $this->context->msg( 'previewnote' )->plain() . ' ' . $continueEditing;
3729 }
3730
3731 # don't parse non-wikitext pages, show message about preview
3732 if ( $this->mTitle->isCssJsSubpage() || $this->mTitle->isCssOrJsPage() ) {
3733 if ( $this->mTitle->isCssJsSubpage() ) {
3734 $level = 'user';
3735 } elseif ( $this->mTitle->isCssOrJsPage() ) {
3736 $level = 'site';
3737 } else {
3738 $level = false;
3739 }
3740
3741 if ( $content->getModel() == CONTENT_MODEL_CSS ) {
3742 $format = 'css';
3743 if ( $level === 'user' && !$wgAllowUserCss ) {
3744 $format = false;
3745 }
3746 } elseif ( $content->getModel() == CONTENT_MODEL_JAVASCRIPT ) {
3747 $format = 'js';
3748 if ( $level === 'user' && !$wgAllowUserJs ) {
3749 $format = false;
3750 }
3751 } else {
3752 $format = false;
3753 }
3754
3755 # Used messages to make sure grep find them:
3756 # Messages: usercsspreview, userjspreview, sitecsspreview, sitejspreview
3757 if ( $level && $format ) {
3758 $note = "<div id='mw-{$level}{$format}preview'>" .
3759 $this->context->msg( "{$level}{$format}preview" )->text() .
3760 ' ' . $continueEditing . "</div>";
3761 }
3762 }
3763
3764 # If we're adding a comment, we need to show the
3765 # summary as the headline
3766 if ( $this->section === "new" && $this->summary !== "" ) {
3767 $content = $content->addSectionHeader( $this->summary );
3768 }
3769
3770 $hook_args = [ $this, &$content ];
3771 ContentHandler::runLegacyHooks( 'EditPageGetPreviewText', $hook_args, '1.25' );
3772 Hooks::run( 'EditPageGetPreviewContent', $hook_args );
3773
3774 $parserResult = $this->doPreviewParse( $content );
3775 $parserOutput = $parserResult['parserOutput'];
3776 $previewHTML = $parserResult['html'];
3777 $this->mParserOutput = $parserOutput;
3778 $wgOut->addParserOutputMetadata( $parserOutput );
3779
3780 if ( count( $parserOutput->getWarnings() ) ) {
3781 $note .= "\n\n" . implode( "\n\n", $parserOutput->getWarnings() );
3782 }
3783
3784 } catch ( MWContentSerializationException $ex ) {
3785 $m = $this->context->msg(
3786 'content-failed-to-parse',
3787 $this->contentModel,
3788 $this->contentFormat,
3789 $ex->getMessage()
3790 );
3791 $note .= "\n\n" . $m->parse();
3792 $previewHTML = '';
3793 }
3794
3795 if ( $this->isConflict ) {
3796 $conflict = '<h2 id="mw-previewconflict">'
3797 . $this->context->msg( 'previewconflict' )->escaped() . "</h2>\n";
3798 } else {
3799 $conflict = '<hr />';
3800 }
3801
3802 $previewhead = "<div class='previewnote'>\n" .
3803 '<h2 id="mw-previewheader">' . $this->context->msg( 'preview' )->escaped() . "</h2>" .
3804 $wgOut->parse( $note, true, /* interface */true ) . $conflict . "</div>\n";
3805
3806 $pageViewLang = $this->mTitle->getPageViewLanguage();
3807 $attribs = [ 'lang' => $pageViewLang->getHtmlCode(), 'dir' => $pageViewLang->getDir(),
3808 'class' => 'mw-content-' . $pageViewLang->getDir() ];
3809 $previewHTML = Html::rawElement( 'div', $attribs, $previewHTML );
3810
3811 return $previewhead . $previewHTML . $this->previewTextAfterContent;
3812 }
3813
3814 /**
3815 * Get parser options for a preview
3816 * @return ParserOptions
3817 */
3818 protected function getPreviewParserOptions() {
3819 $parserOptions = $this->page->makeParserOptions( $this->mArticle->getContext() );
3820 $parserOptions->setIsPreview( true );
3821 $parserOptions->setIsSectionPreview( !is_null( $this->section ) && $this->section !== '' );
3822 $parserOptions->enableLimitReport();
3823 return $parserOptions;
3824 }
3825
3826 /**
3827 * Parse the page for a preview. Subclasses may override this class, in order
3828 * to parse with different options, or to otherwise modify the preview HTML.
3829 *
3830 * @param Content $content The page content
3831 * @return array with keys:
3832 * - parserOutput: The ParserOutput object
3833 * - html: The HTML to be displayed
3834 */
3835 protected function doPreviewParse( Content $content ) {
3836 global $wgUser;
3837 $parserOptions = $this->getPreviewParserOptions();
3838 $pstContent = $content->preSaveTransform( $this->mTitle, $wgUser, $parserOptions );
3839 $scopedCallback = $parserOptions->setupFakeRevision(
3840 $this->mTitle, $pstContent, $wgUser );
3841 $parserOutput = $pstContent->getParserOutput( $this->mTitle, null, $parserOptions );
3842 ScopedCallback::consume( $scopedCallback );
3843 $parserOutput->setEditSectionTokens( false ); // no section edit links
3844 return [
3845 'parserOutput' => $parserOutput,
3846 'html' => $parserOutput->getText() ];
3847 }
3848
3849 /**
3850 * @return array
3851 */
3852 function getTemplates() {
3853 if ( $this->preview || $this->section != '' ) {
3854 $templates = [];
3855 if ( !isset( $this->mParserOutput ) ) {
3856 return $templates;
3857 }
3858 foreach ( $this->mParserOutput->getTemplates() as $ns => $template ) {
3859 foreach ( array_keys( $template ) as $dbk ) {
3860 $templates[] = Title::makeTitle( $ns, $dbk );
3861 }
3862 }
3863 return $templates;
3864 } else {
3865 return $this->mTitle->getTemplateLinksFrom();
3866 }
3867 }
3868
3869 /**
3870 * Shows a bulletin board style toolbar for common editing functions.
3871 * It can be disabled in the user preferences.
3872 *
3873 * @param Title $title Title object for the page being edited (optional)
3874 * @return string
3875 */
3876 static function getEditToolbar( $title = null ) {
3877 global $wgContLang, $wgOut;
3878 global $wgEnableUploads, $wgForeignFileRepos;
3879
3880 $imagesAvailable = $wgEnableUploads || count( $wgForeignFileRepos );
3881 $showSignature = true;
3882 if ( $title ) {
3883 $showSignature = MWNamespace::wantSignatures( $title->getNamespace() );
3884 }
3885
3886 /**
3887 * $toolarray is an array of arrays each of which includes the
3888 * opening tag, the closing tag, optionally a sample text that is
3889 * inserted between the two when no selection is highlighted
3890 * and. The tip text is shown when the user moves the mouse
3891 * over the button.
3892 *
3893 * Images are defined in ResourceLoaderEditToolbarModule.
3894 */
3895 $toolarray = [
3896 [
3897 'id' => 'mw-editbutton-bold',
3898 'open' => '\'\'\'',
3899 'close' => '\'\'\'',
3900 'sample' => wfMessage( 'bold_sample' )->text(),
3901 'tip' => wfMessage( 'bold_tip' )->text(),
3902 ],
3903 [
3904 'id' => 'mw-editbutton-italic',
3905 'open' => '\'\'',
3906 'close' => '\'\'',
3907 'sample' => wfMessage( 'italic_sample' )->text(),
3908 'tip' => wfMessage( 'italic_tip' )->text(),
3909 ],
3910 [
3911 'id' => 'mw-editbutton-link',
3912 'open' => '[[',
3913 'close' => ']]',
3914 'sample' => wfMessage( 'link_sample' )->text(),
3915 'tip' => wfMessage( 'link_tip' )->text(),
3916 ],
3917 [
3918 'id' => 'mw-editbutton-extlink',
3919 'open' => '[',
3920 'close' => ']',
3921 'sample' => wfMessage( 'extlink_sample' )->text(),
3922 'tip' => wfMessage( 'extlink_tip' )->text(),
3923 ],
3924 [
3925 'id' => 'mw-editbutton-headline',
3926 'open' => "\n== ",
3927 'close' => " ==\n",
3928 'sample' => wfMessage( 'headline_sample' )->text(),
3929 'tip' => wfMessage( 'headline_tip' )->text(),
3930 ],
3931 $imagesAvailable ? [
3932 'id' => 'mw-editbutton-image',
3933 'open' => '[[' . $wgContLang->getNsText( NS_FILE ) . ':',
3934 'close' => ']]',
3935 'sample' => wfMessage( 'image_sample' )->text(),
3936 'tip' => wfMessage( 'image_tip' )->text(),
3937 ] : false,
3938 $imagesAvailable ? [
3939 'id' => 'mw-editbutton-media',
3940 'open' => '[[' . $wgContLang->getNsText( NS_MEDIA ) . ':',
3941 'close' => ']]',
3942 'sample' => wfMessage( 'media_sample' )->text(),
3943 'tip' => wfMessage( 'media_tip' )->text(),
3944 ] : false,
3945 [
3946 'id' => 'mw-editbutton-nowiki',
3947 'open' => "<nowiki>",
3948 'close' => "</nowiki>",
3949 'sample' => wfMessage( 'nowiki_sample' )->text(),
3950 'tip' => wfMessage( 'nowiki_tip' )->text(),
3951 ],
3952 $showSignature ? [
3953 'id' => 'mw-editbutton-signature',
3954 'open' => wfMessage( 'sig-text', '~~~~' )->inContentLanguage()->text(),
3955 'close' => '',
3956 'sample' => '',
3957 'tip' => wfMessage( 'sig_tip' )->text(),
3958 ] : false,
3959 [
3960 'id' => 'mw-editbutton-hr',
3961 'open' => "\n----\n",
3962 'close' => '',
3963 'sample' => '',
3964 'tip' => wfMessage( 'hr_tip' )->text(),
3965 ]
3966 ];
3967
3968 $script = 'mw.loader.using("mediawiki.toolbar", function () {';
3969 foreach ( $toolarray as $tool ) {
3970 if ( !$tool ) {
3971 continue;
3972 }
3973
3974 $params = [
3975 // Images are defined in ResourceLoaderEditToolbarModule
3976 false,
3977 // Note that we use the tip both for the ALT tag and the TITLE tag of the image.
3978 // Older browsers show a "speedtip" type message only for ALT.
3979 // Ideally these should be different, realistically they
3980 // probably don't need to be.
3981 $tool['tip'],
3982 $tool['open'],
3983 $tool['close'],
3984 $tool['sample'],
3985 $tool['id'],
3986 ];
3987
3988 $script .= Xml::encodeJsCall(
3989 'mw.toolbar.addButton',
3990 $params,
3991 ResourceLoader::inDebugMode()
3992 );
3993 }
3994
3995 $script .= '});';
3996 $wgOut->addScript( ResourceLoader::makeInlineScript( $script ) );
3997
3998 $toolbar = '<div id="toolbar"></div>';
3999
4000 Hooks::run( 'EditPageBeforeEditToolbar', [ &$toolbar ] );
4001
4002 return $toolbar;
4003 }
4004
4005 /**
4006 * Returns an array of html code of the following checkboxes:
4007 * minor and watch
4008 *
4009 * @param int $tabindex Current tabindex
4010 * @param array $checked Array of checkbox => bool, where bool indicates the checked
4011 * status of the checkbox
4012 *
4013 * @return array
4014 */
4015 public function getCheckboxes( &$tabindex, $checked ) {
4016 global $wgUser, $wgUseMediaWikiUIEverywhere;
4017
4018 $checkboxes = [];
4019
4020 // don't show the minor edit checkbox if it's a new page or section
4021 if ( !$this->isNew ) {
4022 $checkboxes['minor'] = '';
4023 $minorLabel = $this->context->msg( 'minoredit' )->parse();
4024 if ( $wgUser->isAllowed( 'minoredit' ) ) {
4025 $attribs = [
4026 'tabindex' => ++$tabindex,
4027 'accesskey' => $this->context->msg( 'accesskey-minoredit' )->text(),
4028 'id' => 'wpMinoredit',
4029 ];
4030 $minorEditHtml =
4031 Xml::check( 'wpMinoredit', $checked['minor'], $attribs ) .
4032 "&#160;<label for='wpMinoredit' id='mw-editpage-minoredit'" .
4033 Xml::expandAttributes( [ 'title' => Linker::titleAttrib( 'minoredit', 'withaccess' ) ] ) .
4034 ">{$minorLabel}</label>";
4035
4036 if ( $wgUseMediaWikiUIEverywhere ) {
4037 $checkboxes['minor'] = Html::openElement( 'div', [ 'class' => 'mw-ui-checkbox' ] ) .
4038 $minorEditHtml .
4039 Html::closeElement( 'div' );
4040 } else {
4041 $checkboxes['minor'] = $minorEditHtml;
4042 }
4043 }
4044 }
4045
4046 $watchLabel = $this->context->msg( 'watchthis' )->parse();
4047 $checkboxes['watch'] = '';
4048 if ( $wgUser->isLoggedIn() ) {
4049 $attribs = [
4050 'tabindex' => ++$tabindex,
4051 'accesskey' => $this->context->msg( 'accesskey-watch' )->text(),
4052 'id' => 'wpWatchthis',
4053 ];
4054 $watchThisHtml =
4055 Xml::check( 'wpWatchthis', $checked['watch'], $attribs ) .
4056 "&#160;<label for='wpWatchthis' id='mw-editpage-watch'" .
4057 Xml::expandAttributes( [ 'title' => Linker::titleAttrib( 'watch', 'withaccess' ) ] ) .
4058 ">{$watchLabel}</label>";
4059 if ( $wgUseMediaWikiUIEverywhere ) {
4060 $checkboxes['watch'] = Html::openElement( 'div', [ 'class' => 'mw-ui-checkbox' ] ) .
4061 $watchThisHtml .
4062 Html::closeElement( 'div' );
4063 } else {
4064 $checkboxes['watch'] = $watchThisHtml;
4065 }
4066 }
4067 Hooks::run( 'EditPageBeforeEditChecks', [ &$this, &$checkboxes, &$tabindex ] );
4068 return $checkboxes;
4069 }
4070
4071 /**
4072 * Returns an array of html code of the following buttons:
4073 * save, diff and preview
4074 *
4075 * @param int $tabindex Current tabindex
4076 *
4077 * @return array
4078 */
4079 public function getEditButtons( &$tabindex ) {
4080 $buttons = [];
4081
4082 $labelAsPublish =
4083 $this->mArticle->getContext()->getConfig()->get( 'EditSubmitButtonLabelPublish' );
4084
4085 // Can't use $this->isNew as that's also true if we're adding a new section to an extant page
4086 if ( $labelAsPublish ) {
4087 $buttonLabelKey = !$this->mTitle->exists() ? 'publishpage' : 'publishchanges';
4088 } else {
4089 $buttonLabelKey = !$this->mTitle->exists() ? 'savearticle' : 'savechanges';
4090 }
4091 $buttonLabel = $this->context->msg( $buttonLabelKey )->text();
4092 $attribs = [
4093 'id' => 'wpSave',
4094 'name' => 'wpSave',
4095 'tabindex' => ++$tabindex,
4096 ] + Linker::tooltipAndAccesskeyAttribs( 'save' );
4097 $buttons['save'] = Html::submitButton( $buttonLabel, $attribs, [ 'mw-ui-progressive' ] );
4098
4099 ++$tabindex; // use the same for preview and live preview
4100 $attribs = [
4101 'id' => 'wpPreview',
4102 'name' => 'wpPreview',
4103 'tabindex' => $tabindex,
4104 ] + Linker::tooltipAndAccesskeyAttribs( 'preview' );
4105 $buttons['preview'] = Html::submitButton( $this->context->msg( 'showpreview' )->text(),
4106 $attribs );
4107
4108 $attribs = [
4109 'id' => 'wpDiff',
4110 'name' => 'wpDiff',
4111 'tabindex' => ++$tabindex,
4112 ] + Linker::tooltipAndAccesskeyAttribs( 'diff' );
4113 $buttons['diff'] = Html::submitButton( $this->context->msg( 'showdiff' )->text(),
4114 $attribs );
4115
4116 Hooks::run( 'EditPageBeforeEditButtons', [ &$this, &$buttons, &$tabindex ] );
4117 return $buttons;
4118 }
4119
4120 /**
4121 * Creates a basic error page which informs the user that
4122 * they have attempted to edit a nonexistent section.
4123 */
4124 function noSuchSectionPage() {
4125 global $wgOut;
4126
4127 $wgOut->prepareErrorPage( $this->context->msg( 'nosuchsectiontitle' ) );
4128
4129 $res = $this->context->msg( 'nosuchsectiontext', $this->section )->parseAsBlock();
4130 Hooks::run( 'EditPageNoSuchSection', [ &$this, &$res ] );
4131 $wgOut->addHTML( $res );
4132
4133 $wgOut->returnToMain( false, $this->mTitle );
4134 }
4135
4136 /**
4137 * Show "your edit contains spam" page with your diff and text
4138 *
4139 * @param string|array|bool $match Text (or array of texts) which triggered one or more filters
4140 */
4141 public function spamPageWithContent( $match = false ) {
4142 global $wgOut, $wgLang;
4143 $this->textbox2 = $this->textbox1;
4144
4145 if ( is_array( $match ) ) {
4146 $match = $wgLang->listToText( $match );
4147 }
4148 $wgOut->prepareErrorPage( $this->context->msg( 'spamprotectiontitle' ) );
4149
4150 $wgOut->addHTML( '<div id="spamprotected">' );
4151 $wgOut->addWikiMsg( 'spamprotectiontext' );
4152 if ( $match ) {
4153 $wgOut->addWikiMsg( 'spamprotectionmatch', wfEscapeWikiText( $match ) );
4154 }
4155 $wgOut->addHTML( '</div>' );
4156
4157 $wgOut->wrapWikiMsg( '<h2>$1</h2>', "yourdiff" );
4158 $this->showDiff();
4159
4160 $wgOut->wrapWikiMsg( '<h2>$1</h2>', "yourtext" );
4161 $this->showTextbox2();
4162
4163 $wgOut->addReturnTo( $this->getContextTitle(), [ 'action' => 'edit' ] );
4164 }
4165
4166 /**
4167 * Check if the browser is on a blacklist of user-agents known to
4168 * mangle UTF-8 data on form submission. Returns true if Unicode
4169 * should make it through, false if it's known to be a problem.
4170 * @return bool
4171 */
4172 private function checkUnicodeCompliantBrowser() {
4173 global $wgBrowserBlackList, $wgRequest;
4174
4175 $currentbrowser = $wgRequest->getHeader( 'User-Agent' );
4176 if ( $currentbrowser === false ) {
4177 // No User-Agent header sent? Trust it by default...
4178 return true;
4179 }
4180
4181 foreach ( $wgBrowserBlackList as $browser ) {
4182 if ( preg_match( $browser, $currentbrowser ) ) {
4183 return false;
4184 }
4185 }
4186 return true;
4187 }
4188
4189 /**
4190 * Filter an input field through a Unicode de-armoring process if it
4191 * came from an old browser with known broken Unicode editing issues.
4192 *
4193 * @param WebRequest $request
4194 * @param string $field
4195 * @return string
4196 */
4197 protected function safeUnicodeInput( $request, $field ) {
4198 $text = rtrim( $request->getText( $field ) );
4199 return $request->getBool( 'safemode' )
4200 ? $this->unmakeSafe( $text )
4201 : $text;
4202 }
4203
4204 /**
4205 * Filter an output field through a Unicode armoring process if it is
4206 * going to an old browser with known broken Unicode editing issues.
4207 *
4208 * @param string $text
4209 * @return string
4210 */
4211 protected function safeUnicodeOutput( $text ) {
4212 return $this->checkUnicodeCompliantBrowser()
4213 ? $text
4214 : $this->makeSafe( $text );
4215 }
4216
4217 /**
4218 * A number of web browsers are known to corrupt non-ASCII characters
4219 * in a UTF-8 text editing environment. To protect against this,
4220 * detected browsers will be served an armored version of the text,
4221 * with non-ASCII chars converted to numeric HTML character references.
4222 *
4223 * Preexisting such character references will have a 0 added to them
4224 * to ensure that round-trips do not alter the original data.
4225 *
4226 * @param string $invalue
4227 * @return string
4228 */
4229 private function makeSafe( $invalue ) {
4230 // Armor existing references for reversibility.
4231 $invalue = strtr( $invalue, [ "&#x" => "&#x0" ] );
4232
4233 $bytesleft = 0;
4234 $result = "";
4235 $working = 0;
4236 $valueLength = strlen( $invalue );
4237 for ( $i = 0; $i < $valueLength; $i++ ) {
4238 $bytevalue = ord( $invalue[$i] );
4239 if ( $bytevalue <= 0x7F ) { // 0xxx xxxx
4240 $result .= chr( $bytevalue );
4241 $bytesleft = 0;
4242 } elseif ( $bytevalue <= 0xBF ) { // 10xx xxxx
4243 $working = $working << 6;
4244 $working += ( $bytevalue & 0x3F );
4245 $bytesleft--;
4246 if ( $bytesleft <= 0 ) {
4247 $result .= "&#x" . strtoupper( dechex( $working ) ) . ";";
4248 }
4249 } elseif ( $bytevalue <= 0xDF ) { // 110x xxxx
4250 $working = $bytevalue & 0x1F;
4251 $bytesleft = 1;
4252 } elseif ( $bytevalue <= 0xEF ) { // 1110 xxxx
4253 $working = $bytevalue & 0x0F;
4254 $bytesleft = 2;
4255 } else { // 1111 0xxx
4256 $working = $bytevalue & 0x07;
4257 $bytesleft = 3;
4258 }
4259 }
4260 return $result;
4261 }
4262
4263 /**
4264 * Reverse the previously applied transliteration of non-ASCII characters
4265 * back to UTF-8. Used to protect data from corruption by broken web browsers
4266 * as listed in $wgBrowserBlackList.
4267 *
4268 * @param string $invalue
4269 * @return string
4270 */
4271 private function unmakeSafe( $invalue ) {
4272 $result = "";
4273 $valueLength = strlen( $invalue );
4274 for ( $i = 0; $i < $valueLength; $i++ ) {
4275 if ( ( substr( $invalue, $i, 3 ) == "&#x" ) && ( $invalue[$i + 3] != '0' ) ) {
4276 $i += 3;
4277 $hexstring = "";
4278 do {
4279 $hexstring .= $invalue[$i];
4280 $i++;
4281 } while ( ctype_xdigit( $invalue[$i] ) && ( $i < strlen( $invalue ) ) );
4282
4283 // Do some sanity checks. These aren't needed for reversibility,
4284 // but should help keep the breakage down if the editor
4285 // breaks one of the entities whilst editing.
4286 if ( ( substr( $invalue, $i, 1 ) == ";" ) && ( strlen( $hexstring ) <= 6 ) ) {
4287 $codepoint = hexdec( $hexstring );
4288 $result .= UtfNormal\Utils::codepointToUtf8( $codepoint );
4289 } else {
4290 $result .= "&#x" . $hexstring . substr( $invalue, $i, 1 );
4291 }
4292 } else {
4293 $result .= substr( $invalue, $i, 1 );
4294 }
4295 }
4296 // reverse the transform that we made for reversibility reasons.
4297 return strtr( $result, [ "&#x0" => "&#x" ] );
4298 }
4299
4300 /**
4301 * @since 1.29
4302 */
4303 protected function addEditNotices() {
4304 global $wgOut;
4305
4306 $editNotices = $this->mTitle->getEditNotices( $this->oldid );
4307 if ( count( $editNotices ) ) {
4308 $wgOut->addHTML( implode( "\n", $editNotices ) );
4309 } else {
4310 $msg = $this->context->msg( 'editnotice-notext' );
4311 if ( !$msg->isDisabled() ) {
4312 $wgOut->addHTML(
4313 '<div class="mw-editnotice-notext">'
4314 . $msg->parseAsBlock()
4315 . '</div>'
4316 );
4317 }
4318 }
4319 }
4320
4321 /**
4322 * @since 1.29
4323 */
4324 protected function addTalkPageText() {
4325 global $wgOut;
4326
4327 if ( $this->mTitle->isTalkPage() ) {
4328 $wgOut->addWikiMsg( 'talkpagetext' );
4329 }
4330 }
4331
4332 /**
4333 * @since 1.29
4334 */
4335 protected function addLongPageWarningHeader() {
4336 global $wgMaxArticleSize, $wgOut, $wgLang;
4337
4338 if ( $this->contentLength === false ) {
4339 $this->contentLength = strlen( $this->textbox1 );
4340 }
4341
4342 if ( $this->tooBig || $this->contentLength > $wgMaxArticleSize * 1024 ) {
4343 $wgOut->wrapWikiMsg( "<div class='error' id='mw-edit-longpageerror'>\n$1\n</div>",
4344 [
4345 'longpageerror',
4346 $wgLang->formatNum( round( $this->contentLength / 1024, 3 ) ),
4347 $wgLang->formatNum( $wgMaxArticleSize )
4348 ]
4349 );
4350 } else {
4351 if ( !$this->context->msg( 'longpage-hint' )->isDisabled() ) {
4352 $wgOut->wrapWikiMsg( "<div id='mw-edit-longpage-hint'>\n$1\n</div>",
4353 [
4354 'longpage-hint',
4355 $wgLang->formatSize( strlen( $this->textbox1 ) ),
4356 strlen( $this->textbox1 )
4357 ]
4358 );
4359 }
4360 }
4361 }
4362
4363 /**
4364 * @since 1.29
4365 */
4366 protected function addPageProtectionWarningHeaders() {
4367 global $wgOut;
4368
4369 if ( $this->mTitle->isProtected( 'edit' ) &&
4370 MWNamespace::getRestrictionLevels( $this->mTitle->getNamespace() ) !== [ '' ]
4371 ) {
4372 # Is the title semi-protected?
4373 if ( $this->mTitle->isSemiProtected() ) {
4374 $noticeMsg = 'semiprotectedpagewarning';
4375 } else {
4376 # Then it must be protected based on static groups (regular)
4377 $noticeMsg = 'protectedpagewarning';
4378 }
4379 LogEventsList::showLogExtract( $wgOut, 'protect', $this->mTitle, '',
4380 [ 'lim' => 1, 'msgKey' => [ $noticeMsg ] ] );
4381 }
4382 if ( $this->mTitle->isCascadeProtected() ) {
4383 # Is this page under cascading protection from some source pages?
4384 /** @var Title[] $cascadeSources */
4385 list( $cascadeSources, /* $restrictions */ ) = $this->mTitle->getCascadeProtectionSources();
4386 $notice = "<div class='mw-cascadeprotectedwarning'>\n$1\n";
4387 $cascadeSourcesCount = count( $cascadeSources );
4388 if ( $cascadeSourcesCount > 0 ) {
4389 # Explain, and list the titles responsible
4390 foreach ( $cascadeSources as $page ) {
4391 $notice .= '* [[:' . $page->getPrefixedText() . "]]\n";
4392 }
4393 }
4394 $notice .= '</div>';
4395 $wgOut->wrapWikiMsg( $notice, [ 'cascadeprotectedwarning', $cascadeSourcesCount ] );
4396 }
4397 if ( !$this->mTitle->exists() && $this->mTitle->getRestrictions( 'create' ) ) {
4398 LogEventsList::showLogExtract( $wgOut, 'protect', $this->mTitle, '',
4399 [ 'lim' => 1,
4400 'showIfEmpty' => false,
4401 'msgKey' => [ 'titleprotectedwarning' ],
4402 'wrap' => "<div class=\"mw-titleprotectedwarning\">\n$1</div>" ] );
4403 }
4404 }
4405
4406 /**
4407 * @param OutputPage $out
4408 * @since 1.29
4409 */
4410 protected function addExplainConflictHeader( OutputPage $out ) {
4411 $out->wrapWikiMsg( "<div class='mw-explainconflict'>\n$1\n</div>", 'explainconflict' );
4412 }
4413
4414 /**
4415 * @param string $name
4416 * @param mixed[] $customAttribs
4417 * @param User $user
4418 * @return mixed[]
4419 * @since 1.29
4420 */
4421 protected function buildTextboxAttribs( $name, array $customAttribs, User $user ) {
4422 $attribs = $customAttribs + [
4423 'accesskey' => ',',
4424 'id' => $name,
4425 'cols' => $user->getIntOption( 'cols' ),
4426 'rows' => $user->getIntOption( 'rows' ),
4427 // Avoid PHP notices when appending preferences
4428 // (appending allows customAttribs['style'] to still work).
4429 'style' => ''
4430 ];
4431
4432 // The following classes can be used here:
4433 // * mw-editfont-default
4434 // * mw-editfont-monospace
4435 // * mw-editfont-sans-serif
4436 // * mw-editfont-serif
4437 $class = 'mw-editfont-' . $user->getOption( 'editfont' );
4438
4439 if ( isset( $attribs['class'] ) ) {
4440 if ( is_string( $attribs['class'] ) ) {
4441 $attribs['class'] .= ' ' . $class;
4442 } elseif ( is_array( $attribs['class'] ) ) {
4443 $attribs['class'][] = $class;
4444 }
4445 } else {
4446 $attribs['class'] = $class;
4447 }
4448
4449 $pageLang = $this->mTitle->getPageLanguage();
4450 $attribs['lang'] = $pageLang->getHtmlCode();
4451 $attribs['dir'] = $pageLang->getDir();
4452
4453 return $attribs;
4454 }
4455
4456 /**
4457 * @param string $wikitext
4458 * @return string
4459 * @since 1.29
4460 */
4461 protected function addNewLineAtEnd( $wikitext ) {
4462 if ( strval( $wikitext ) !== '' ) {
4463 // Ensure there's a newline at the end, otherwise adding lines
4464 // is awkward.
4465 // But don't add a newline if the text is empty, or Firefox in XHTML
4466 // mode will show an extra newline. A bit annoying.
4467 $wikitext .= "\n";
4468 return $wikitext;
4469 }
4470 return $wikitext;
4471 }
4472 }
Wiklou, le Wiki du Wiklou