PhabricatorInlineCommentController.php
51cb7a3db9e8master

PhabricatorInlineCommentController.php
View Options

			<?php

			abstract class PhabricatorInlineCommentController
			extends PhabricatorController {

			private $containerObject;

			abstract protected function createComment();
			abstract protected function newInlineCommentQuery();
			abstract protected function loadCommentForDone($id);
			abstract protected function loadObjectOwnerPHID(
			PhabricatorInlineComment $inline);
			abstract protected function newContainerObject();

			final protected function getContainerObject() {
			if ($this->containerObject === null) {
			$object = $this->newContainerObject();
			if (!$object) {
			throw new Exception(
			pht(
			'Failed to load container object for inline comment.'));
			}
			$this->containerObject = $object;
			}

			return $this->containerObject;
			}

			protected function hideComments(array $ids) {
			throw new PhutilMethodNotImplementedException();
			}

			protected function showComments(array $ids) {
			throw new PhutilMethodNotImplementedException();
			}

			private $changesetID;
			private $isNewFile;
			private $isOnRight;
			private $lineNumber;
			private $lineLength;
			private $operation;
			private $commentID;
			private $renderer;
			private $replyToCommentPHID;

			public function getCommentID() {
			return $this->commentID;
			}

			public function getOperation() {
			return $this->operation;
			}

			public function getLineLength() {
			return $this->lineLength;
			}

			public function getLineNumber() {
			return $this->lineNumber;
			}

			public function getIsOnRight() {
			return $this->isOnRight;
			}

			public function getChangesetID() {
			return $this->changesetID;
			}

			public function getIsNewFile() {
			return $this->isNewFile;
			}

			public function setRenderer($renderer) {
			$this->renderer = $renderer;
			return $this;
			}

			public function getRenderer() {
			return $this->renderer;
			}

			public function setReplyToCommentPHID($phid) {
			$this->replyToCommentPHID = $phid;
			return $this;
			}

			public function getReplyToCommentPHID() {
			return $this->replyToCommentPHID;
			}

			public function processRequest() {
			$request = $this->getRequest();
			$viewer = $this->getViewer();

			if (!$request->validateCSRF()) {
			return new Aphront404Response();
			}

			$this->readRequestParameters();

			$op = $this->getOperation();
			switch ($op) {
			case 'hide':
			case 'show':
			$ids = $request->getStrList('ids');
			if ($ids) {
			if ($op == 'hide') {
			$this->hideComments($ids);
			} else {
			$this->showComments($ids);
			}
			}

			return id(new AphrontAjaxResponse())->setContent(array());
			case 'done':
			$inline = $this->loadCommentForDone($this->getCommentID());

			$is_draft_state = false;
			$is_checked = false;
			switch ($inline->getFixedState()) {
			case PhabricatorInlineComment::STATE_DRAFT:
			$next_state = PhabricatorInlineComment::STATE_UNDONE;
			break;
			case PhabricatorInlineComment::STATE_UNDRAFT:
			$next_state = PhabricatorInlineComment::STATE_DONE;
			$is_checked = true;
			break;
			case PhabricatorInlineComment::STATE_DONE:
			$next_state = PhabricatorInlineComment::STATE_UNDRAFT;
			$is_draft_state = true;
			break;
			default:
			case PhabricatorInlineComment::STATE_UNDONE:
			$next_state = PhabricatorInlineComment::STATE_DRAFT;
			$is_draft_state = true;
			$is_checked = true;
			break;
			}

			$inline->setFixedState($next_state)->save();

			return id(new AphrontAjaxResponse())
			->setContent(
			array(
			'isChecked' => $is_checked,
			'draftState' => $is_draft_state,
			));
			case 'delete':
			case 'undelete':
			case 'refdelete':
			// NOTE: For normal deletes, we just process the delete immediately
			// and show an "Undo" action. For deletes by reference from the
			// preview ("refdelete"), we prompt first (because the "Undo" may
			// not draw, or may not be easy to locate).

			if ($op == 'refdelete') {
			if (!$request->isFormPost()) {
			return $this->newDialog()
			->setTitle(pht('Really delete comment?'))
			->addHiddenInput('id', $this->getCommentID())
			->addHiddenInput('op', $op)
			->appendParagraph(pht('Delete this inline comment?'))
			->addCancelButton('#')
			->addSubmitButton(pht('Delete'));
			}
			}

			$is_delete = ($op == 'delete' \|\| $op == 'refdelete');

			$inline = $this->loadCommentByIDForEdit($this->getCommentID());

			if ($is_delete) {
			$inline
			->setIsEditing(false)
			->setIsDeleted(1);
			} else {
			$inline->setIsDeleted(0);
			}

			$this->saveComment($inline);

			return $this->buildEmptyResponse();
			case 'save':
			$inline = $this->loadCommentByIDForEdit($this->getCommentID());

			$this->updateCommentContentState($inline);

			$inline
			->setIsEditing(false)
			->setIsDeleted(0);

			// Since we're saving the comment, update the committed state.
			$active_state = $inline->getContentState();
			$inline->setCommittedContentState($active_state);

			$this->saveComment($inline);

			return $this->buildRenderedCommentResponse(
			$inline,
			$this->getIsOnRight());
			case 'edit':
			$inline = $this->loadCommentByIDForEdit($this->getCommentID());

			// NOTE: At time of writing, the "editing" state of inlines is
			// preserved by simulating a click on "Edit" when the inline loads.

			// In this case, we don't want to "saveComment()", because it
			// recalculates object drafts and purges versioned drafts.

			// The recalculation is merely unnecessary (state doesn't change)
			// but purging drafts means that loading a page and then closing it
			// discards your drafts.

			// To avoid the purge, only invoke "saveComment()" if we actually
			// have changes to apply.

			$is_dirty = false;
			if (!$inline->getIsEditing()) {
			$inline
			->setIsDeleted(0)
			->setIsEditing(true);

			$is_dirty = true;
			}

			if ($this->hasContentState()) {
			$this->updateCommentContentState($inline);
			$is_dirty = true;
			} else {
			PhabricatorInlineComment::loadAndAttachVersionedDrafts(
			$viewer,
			array($inline));
			}

			if ($is_dirty) {
			$this->saveComment($inline);
			}

			$edit_dialog = $this->buildEditDialog($inline)
			->setTitle(pht('Edit Inline Comment'));

			$view = $this->buildScaffoldForView($edit_dialog);

			return $this->newInlineResponse($inline, $view, true);
			case 'cancel':
			$inline = $this->loadCommentByIDForEdit($this->getCommentID());

			$inline->setIsEditing(false);

			// If the user uses "Undo" to get into an edited state ("AB"), then
			// clicks cancel to return to the previous state ("A"), we also want
			// to set the stored state back to "A".
			$this->updateCommentContentState($inline);

			$this->saveComment($inline);

			return $this->buildEmptyResponse();
			case 'draft':
			$inline = $this->loadCommentByIDForEdit($this->getCommentID());

			$versioned_draft = PhabricatorVersionedDraft::loadOrCreateDraft(
			$inline->getPHID(),
			$viewer->getPHID(),
			$inline->getID());

			$map = $this->newRequestContentState($inline)->newStorageMap();
			$versioned_draft->setProperty('inline.state', $map);
			$versioned_draft->save();

			// We have to synchronize the draft engine after saving a versioned
			// draft, because taking an inline comment from "no text, no draft"
			// to "no text, text in a draft" marks the container object as having
			// a draft.
			$draft_engine = $this->newDraftEngine();
			if ($draft_engine) {
			$draft_engine->synchronize();
			}

			return $this->buildEmptyResponse();
			case 'new':
			case 'reply':
			default:
			// NOTE: We read the values from the client (the display values), not
			// the values from the database (the original values) when replying.
			// In particular, when replying to a ghost comment which was moved
			// across diffs and then moved backward to the most recent visible
			// line, we want to reply on the display line (which exists), not on
			// the comment's original line (which may not exist in this changeset).
			$is_new = $this->getIsNewFile();
			$number = $this->getLineNumber();
			$length = $this->getLineLength();

			$inline = $this->createComment()
			->setChangesetID($this->getChangesetID())
			->setAuthorPHID($viewer->getPHID())
			->setIsNewFile($is_new)
			->setLineNumber($number)
			->setLineLength($length)
			->setReplyToCommentPHID($this->getReplyToCommentPHID())
			->setIsEditing(true)
			->setStartOffset($request->getInt('startOffset'))
			->setEndOffset($request->getInt('endOffset'))
			->setContent('');

			$document_engine_key = $request->getStr('documentEngineKey');
			if ($document_engine_key !== null) {
			$inline->setDocumentEngineKey($document_engine_key);
			}

			// If you own this object, mark your own inlines as "Done" by default.
			$owner_phid = $this->loadObjectOwnerPHID($inline);
			if ($owner_phid) {
			if ($viewer->getPHID() == $owner_phid) {
			$fixed_state = PhabricatorInlineComment::STATE_DRAFT;
			$inline->setFixedState($fixed_state);
			}
			}

			if ($this->hasContentState()) {
			$this->updateCommentContentState($inline);
			}

			// NOTE: We're writing the comment as "deleted", then reloading to
			// pick up context and undeleting it. This is silly -- we just want
			// to load and attach context -- but just loading context is currently
			// complicated (for example, context relies on cache keys that expect
			// the inline to have an ID).

			$inline->setIsDeleted(1);

			$this->saveComment($inline);

			// Reload the inline to attach context.
			$inline = $this->loadCommentByIDForEdit($inline->getID());

			// Now, we can read the source file and set the initial state.
			$state = $inline->getContentState();
			$default_suggestion = $inline->getDefaultSuggestionText();
			$state->setContentSuggestionText($default_suggestion);

			$inline->setInitialContentState($state);
			$inline->setContentState($state);

			$inline->setIsDeleted(0);

			$this->saveComment($inline);

			$edit_dialog = $this->buildEditDialog($inline);

			if ($this->getOperation() == 'reply') {
			$edit_dialog->setTitle(pht('Reply to Inline Comment'));
			} else {
			$edit_dialog->setTitle(pht('New Inline Comment'));
			}

			$view = $this->buildScaffoldForView($edit_dialog);

			return $this->newInlineResponse($inline, $view, true);
			}
			}

			private function readRequestParameters() {
			$request = $this->getRequest();

			// NOTE: This isn't necessarily a DifferentialChangeset ID, just an
			// application identifier for the changeset. In Diffusion, it's a Path ID.
			$this->changesetID = $request->getInt('changesetID');

			$this->isNewFile = (int)$request->getBool('is_new');
			$this->isOnRight = $request->getBool('on_right');
			$this->lineNumber = $request->getInt('number');
			$this->lineLength = $request->getInt('length');
			$this->commentID = $request->getInt('id');
			$this->operation = $request->getStr('op');
			$this->renderer = $request->getStr('renderer');
			$this->replyToCommentPHID = $request->getStr('replyToCommentPHID');

			if ($this->getReplyToCommentPHID()) {
			$reply_phid = $this->getReplyToCommentPHID();
			$reply_comment = $this->loadCommentByPHID($reply_phid);
			if (!$reply_comment) {
			throw new Exception(
			pht('Failed to load comment "%s".', $reply_phid));
			}

			// When replying, force the new comment into the same location as the
			// old comment. If we don't do this, replying to a ghost comment from
			// diff A while viewing diff B can end up placing the two comments in
			// different places while viewing diff C, because the porting algorithm
			// makes a different decision. Forcing the comments to bind to the same
			// place makes sure they stick together no matter which diff is being
			// viewed. See T10562 for discussion.

			$this->changesetID = $reply_comment->getChangesetID();
			$this->isNewFile = $reply_comment->getIsNewFile();
			$this->lineNumber = $reply_comment->getLineNumber();
			$this->lineLength = $reply_comment->getLineLength();
			}
			}

			private function buildEditDialog(PhabricatorInlineComment $inline) {
			$request = $this->getRequest();
			$viewer = $this->getViewer();

			$edit_dialog = id(new PHUIDiffInlineCommentEditView())
			->setViewer($viewer)
			->setInlineComment($inline)
			->setIsOnRight($this->getIsOnRight())
			->setRenderer($this->getRenderer());

			return $edit_dialog;
			}

			private function buildEmptyResponse() {
			return id(new AphrontAjaxResponse())
			->setContent(
			array(
			'inline' => array(),
			'view' => null,
			));
			}

			private function buildRenderedCommentResponse(
			PhabricatorInlineComment $inline,
			$on_right) {

			$request = $this->getRequest();
			$viewer = $this->getViewer();

			$engine = new PhabricatorMarkupEngine();
			$engine->setViewer($viewer);
			$engine->addObject(
			$inline,
			PhabricatorInlineComment::MARKUP_FIELD_BODY);
			$engine->process();

			$phids = array($viewer->getPHID());

			$handles = $this->loadViewerHandles($phids);
			$object_owner_phid = $this->loadObjectOwnerPHID($inline);

			$view = id(new PHUIDiffInlineCommentDetailView())
			->setUser($viewer)
			->setInlineComment($inline)
			->setIsOnRight($on_right)
			->setMarkupEngine($engine)
			->setHandles($handles)
			->setEditable(true)
			->setCanMarkDone(false)
			->setObjectOwnerPHID($object_owner_phid);

			$view = $this->buildScaffoldForView($view);

			return $this->newInlineResponse($inline, $view, false);
			}

			private function buildScaffoldForView(PHUIDiffInlineCommentView $view) {
			$renderer = DifferentialChangesetHTMLRenderer::getHTMLRendererByKey(
			$this->getRenderer());

			$view = $renderer->getRowScaffoldForInline($view);

			return id(new PHUIDiffInlineCommentTableScaffold())
			->addRowScaffold($view);
			}

			private function newInlineResponse(
			PhabricatorInlineComment $inline,
			$view,
			$is_edit) {
			$viewer = $this->getViewer();

			if ($inline->getReplyToCommentPHID()) {
			$can_suggest = false;
			} else {
			$can_suggest = (bool)$inline->getInlineContext();
			}

			if ($is_edit) {
			$state = $inline->getContentStateMapForEdit($viewer);
			} else {
			$state = $inline->getContentStateMap();
			}

			$response = array(
			'inline' => array(
			'id' => $inline->getID(),
			'state' => $state,
			'canSuggestEdit' => $can_suggest,
			),
			'view' => hsprintf('%s', $view),
			);

			return id(new AphrontAjaxResponse())
			->setContent($response);
			}

			final protected function loadCommentByID($id) {
			$query = $this->newInlineCommentQuery()
			->withIDs(array($id));

			return $this->loadCommentByQuery($query);
			}

			final protected function loadCommentByPHID($phid) {
			$query = $this->newInlineCommentQuery()
			->withPHIDs(array($phid));

			return $this->loadCommentByQuery($query);
			}

			final protected function loadCommentByIDForEdit($id) {
			$viewer = $this->getViewer();

			$query = $this->newInlineCommentQuery()
			->withIDs(array($id))
			->needInlineContext(true);

			$inline = $this->loadCommentByQuery($query);

			if (!$inline) {
			throw new Exception(
			pht(
			'Unable to load inline "%s".',
			$id));
			}

			if (!$this->canEditInlineComment($viewer, $inline)) {
			throw new Exception(
			pht(
			'Inline comment "%s" is not editable.',
			$id));
			}

			return $inline;
			}

			private function loadCommentByQuery(
			PhabricatorDiffInlineCommentQuery $query) {
			$viewer = $this->getViewer();

			$inline = $query
			->setViewer($viewer)
			->executeOne();

			if ($inline) {
			$inline = $inline->newInlineCommentObject();
			}

			return $inline;
			}

			private function hasContentState() {
			$request = $this->getRequest();
			return (bool)$request->getBool('hasContentState');
			}

			private function newRequestContentState($inline) {
			$request = $this->getRequest();
			return $inline->newContentStateFromRequest($request);
			}

			private function updateCommentContentState(PhabricatorInlineComment $inline) {
			if (!$this->hasContentState()) {
			throw new Exception(
			pht(
			'Attempting to update comment content state, but request has no '.
			'content state.'));
			}

			$state = $this->newRequestContentState($inline);
			$inline->setContentState($state);
			}

			private function saveComment(PhabricatorInlineComment $inline) {
			$viewer = $this->getViewer();
			$draft_engine = $this->newDraftEngine();

			$inline->openTransaction();
			$inline->save();

			PhabricatorVersionedDraft::purgeDrafts(
			$inline->getPHID(),
			$viewer->getPHID());

			if ($draft_engine) {
			$draft_engine->synchronize();
			}

			$inline->saveTransaction();
			}

			private function newDraftEngine() {
			$viewer = $this->getViewer();
			$object = $this->getContainerObject();

			if (!($object instanceof PhabricatorDraftInterface)) {
			return null;
			}

			return $object->newDraftEngine()
			->setObject($object)
			->setViewer($viewer);
			}

			}

Owner Packages

No Owners

phabricator/src/infrastructure/diff/PhabricatorInlineCommentController.php51cb7a3db9e8master

PhabricatorInlineCommentController.phpView Options

Owner Packages

phabricator/src/infrastructure/diff/PhabricatorInlineCommentController.php
51cb7a3db9e8master

PhabricatorInlineCommentController.php
View Options