No OneTemporary
Actions

Size

85 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/constants/DifferentialReviewerStatus.php b/src/applications/differential/constants/DifferentialReviewerStatus.php
	index a892762914..725286ecf1 100644
	--- a/src/applications/differential/constants/DifferentialReviewerStatus.php
	+++ b/src/applications/differential/constants/DifferentialReviewerStatus.php
	@@ -1,11 +1,37 @@
	<?php

	final class DifferentialReviewerStatus {

	const STATUS_BLOCKING = 'blocking';
	const STATUS_ADDED = 'added';
	const STATUS_ACCEPTED = 'accepted';
	const STATUS_REJECTED = 'rejected';
	const STATUS_COMMENTED = 'commented';

	+ /**
	+ * Returns the relative strength of a status, used to pick a winner when a
	+ * transaction group makes several status changes to a particular reviewer.
	+ *
	+ * For example, if you accept a revision and leave a comment, the transactions
	+ * will attempt to update you to both "commented" and "accepted". We want
	+ * "accepted" to win, because it's the stronger of the two.
	+ *
	+ * @param const Reviewer status constant.
	+ * @return int Relative strength (higher is stronger).
	+ */
	+ public static function getStatusStrength($constant) {
	+ $map = array(
	+ self::STATUS_ADDED => 1,
	+
	+ self::STATUS_COMMENTED => 2,
	+
	+ self::STATUS_BLOCKING => 3,
	+
	+ self::STATUS_ACCEPTED => 4,
	+ self::STATUS_REJECTED => 4,
	+ );
	+
	+ return idx($map, $constant, 0);
	+ }
	+
	}
	diff --git a/src/applications/differential/editor/DifferentialTransactionEditor.php b/src/applications/differential/editor/DifferentialTransactionEditor.php
	index b6c5bdc902..d3fb3637fc 100644
	--- a/src/applications/differential/editor/DifferentialTransactionEditor.php
	+++ b/src/applications/differential/editor/DifferentialTransactionEditor.php
	@@ -1,742 +1,800 @@
	<?php

	final class DifferentialTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();

	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;

	$types[] = DifferentialTransaction::TYPE_ACTION;
	$types[] = DifferentialTransaction::TYPE_INLINE;
	$types[] = DifferentialTransaction::TYPE_STATUS;

	/*

	$types[] = DifferentialTransaction::TYPE_UPDATE;
	*/

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return $object->getViewPolicy();
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return $object->getEditPolicy();
	case DifferentialTransaction::TYPE_ACTION:
	return null;
	case DifferentialTransaction::TYPE_INLINE:
	return null;
	}

	return parent::getCustomTransactionOldValue($object, $xaction);
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case DifferentialTransaction::TYPE_ACTION:
	return $xaction->getNewValue();
	case DifferentialTransaction::TYPE_INLINE:
	return null;
	}

	return parent::getCustomTransactionNewValue($object, $xaction);
	}

	protected function transactionHasEffect(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	return $xaction->hasComment();
	case DifferentialTransaction::TYPE_ACTION:
	$status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	$status_abandoned = ArcanistDifferentialRevisionStatus::ABANDONED;
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	$status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;

	$action_type = $xaction->getNewValue();
	switch ($action_type) {
	case DifferentialAction::ACTION_ACCEPT:
	case DifferentialAction::ACTION_REJECT:
	if ($action_type == DifferentialAction::ACTION_ACCEPT) {
	$new_status = DifferentialReviewerStatus::STATUS_ACCEPTED;
	} else {
	$new_status = DifferentialReviewerStatus::STATUS_REJECTED;
	}

	$actor = $this->getActor();
	$actor_phid = $actor->getPHID();

	// These transactions can cause effects in to ways: by altering the
	// status of an existing reviewer; or by adding the actor as a new
	// reviewer.

	$will_add_reviewer = true;
	foreach ($object->getReviewerStatus() as $reviewer) {
	if ($reviewer->hasAuthority($actor)) {
	if ($reviewer->getStatus() != $new_status) {
	return true;
	}
	}
	if ($reviewer->getReviewerPHID() == $actor_phid) {
	$will_add_reviwer = false;
	}
	}

	return $will_add_reviewer;
	case DifferentialAction::ACTION_CLOSE:
	return ($object->getStatus() != $status_closed);
	case DifferentialAction::ACTION_ABANDON:
	return ($object->getStatus() != $status_abandoned);
	case DifferentialAction::ACTION_RECLAIM:
	return ($object->getStatus() == $status_abandoned);
	case DifferentialAction::ACTION_REOPEN:
	return ($object->getStatus() == $status_closed);
	case DifferentialAction::ACTION_RETHINK:
	return ($object->getStatus() != $status_revision);
	case DifferentialAction::ACTION_REQUEST:
	return ($object->getStatus() != $status_review);
	case DifferentialAction::ACTION_RESIGN:
	$actor_phid = $this->getActor()->getPHID();
	foreach ($object->getReviewerStatus() as $reviewer) {
	if ($reviewer->getReviewerPHID() == $actor_phid) {
	return true;
	}
	}
	return false;
	case DifferentialAction::ACTION_CLAIM:
	$actor_phid = $this->getActor()->getPHID();
	return ($actor_phid != $object->getAuthorPHID());
	}
	}

	return parent::transactionHasEffect($object, $xaction);
	}


	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	$object->setViewPolicy($xaction->getNewValue());
	return;
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	$object->setEditPolicy($xaction->getNewValue());
	return;
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	case PhabricatorTransactions::TYPE_COMMENT:
	case DifferentialTransaction::TYPE_INLINE:
	return;
	case PhabricatorTransactions::TYPE_EDGE:
	return;
	case DifferentialTransaction::TYPE_ACTION:
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	$status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;

	switch ($xaction->getNewValue()) {
	case DifferentialAction::ACTION_RESIGN:
	case DifferentialAction::ACTION_ACCEPT:
	case DifferentialAction::ACTION_REJECT:
	// These have no direct effects, and affect review status only
	// indirectly by altering reviewers with TYPE_EDGE transactions.
	return;
	case DifferentialAction::ACTION_ABANDON:
	$object->setStatus(ArcanistDifferentialRevisionStatus::ABANDONED);
	return;
	case DifferentialAction::ACTION_RETHINK:
	$object->setStatus($status_revision);
	return;
	case DifferentialAction::ACTION_RECLAIM:
	$object->setStatus($status_review);
	return;
	case DifferentialAction::ACTION_REOPEN:
	$object->setStatus($status_review);
	return;
	case DifferentialAction::ACTION_REQUEST:
	$object->setStatus($status_review);
	return;
	case DifferentialAction::ACTION_CLOSE:
	$object->setStatus(ArcanistDifferentialRevisionStatus::CLOSED);
	return;
	case DifferentialAction::ACTION_CLAIM:
	$object->setAuthorPHID($this->getActor()->getPHID());
	return;
	}
	break;
	}

	return parent::applyCustomInternalTransaction($object, $xaction);
	}

	protected function expandTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	+ $actor = $this->getActor();
	+ $actor_phid = $actor->getPHID();
	+ $type_edge = PhabricatorTransactions::TYPE_EDGE;
	+ $edge_reviewer = PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER;
	+
	$results = parent::expandTransaction($object, $xaction);
	switch ($xaction->getTransactionType()) {
	- // TODO: If the user comments and is a reviewer, we should upgrade their
	- // edge metadata to STATUS_COMMENTED.
	+ case PhabricatorTransactions::TYPE_COMMENT:
	+ // When a user leaves a comment, upgrade their reviewer status from
	+ // "added" to "commented" if they're also a reviewer. We may further
	+ // upgrade this based on other actions in the transaction group.
	+
	+ $status_added = DifferentialReviewerStatus::STATUS_ADDED;
	+ $status_commented = DifferentialReviewerStatus::STATUS_COMMENTED;
	+
	+ $data = array(
	+ 'status' => $status_commented,
	+ );
	+
	+ $edits = array();
	+ foreach ($object->getReviewerStatus() as $reviewer) {
	+ if ($reviewer->getReviewerPHID() == $actor_phid) {
	+ if ($reviewer->getStatus() == $status_added) {
	+ $edits[$actor_phid] = array(
	+ 'data' => $data,
	+ );
	+ }
	+ }
	+ }

	- case DifferentialTransaction::TYPE_ACTION:
	+ if ($edits) {
	+ $results[] = id(new DifferentialTransaction())
	+ ->setTransactionType($type_edge)
	+ ->setMetadataValue('edge:type', $edge_reviewer)
	+ ->setIgnoreOnNoEffect(true)
	+ ->setNewValue(array('+' => $edits));
	+ }
	+ break;

	- $actor = $this->getActor();
	- $actor_phid = $actor->getPHID();
	- $type_edge = PhabricatorTransactions::TYPE_EDGE;
	- $edge_reviewer = PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER;
	+ case DifferentialTransaction::TYPE_ACTION:
	$action_type = $xaction->getNewValue();

	switch ($action_type) {
	case DifferentialAction::ACTION_ACCEPT:
	case DifferentialAction::ACTION_REJECT:
	if ($action_type == DifferentialAction::ACTION_ACCEPT) {
	$data = array(
	'status' => DifferentialReviewerStatus::STATUS_ACCEPTED,
	);
	} else {
	$data = array(
	'status' => DifferentialReviewerStatus::STATUS_REJECTED,
	);
	}

	$edits = array();

	foreach ($object->getReviewerStatus() as $reviewer) {
	if ($reviewer->hasAuthority($actor)) {
	$edits[$reviewer->getReviewerPHID()] = array(
	'data' => $data,
	);
	}
	}

	// Also either update or add the actor themselves as a reviewer.
	$edits[$actor_phid] = array(
	'data' => $data,
	);

	$results[] = id(new DifferentialTransaction())
	->setTransactionType($type_edge)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setIgnoreOnNoEffect(true)
	->setNewValue(array('+' => $edits));
	break;

	case DifferentialAction::ACTION_CLAIM:
	// If the user is commandeering, add the previous owner as a
	// reviewer and remove the actor.

	$edits = array(
	'-' => array(
	$actor_phid => $actor_phid,
	),
	);

	$owner_phid = $object->getAuthorPHID();
	if ($owner_phid) {
	$reviewer = new DifferentialReviewer(
	$owner_phid,
	array(
	'status' => DifferentialReviewerStatus::STATUS_ADDED,
	));

	$edits['+'] = array(
	$owner_phid => array(
	'data' => $reviewer->getEdgeData(),
	),
	);
	}

	$results[] = id(new DifferentialTransaction())
	->setTransactionType($type_edge)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setIgnoreOnNoEffect(true)
	->setNewValue($edits);

	break;
	case DifferentialAction::ACTION_RESIGN:
	// If the user is resigning, add a separate reviewer edit
	// transaction which removes them as a reviewer.

	$results[] = id(new DifferentialTransaction())
	->setTransactionType($type_edge)
	->setMetadataValue('edge:type', $edge_reviewer)
	->setIgnoreOnNoEffect(true)
	->setNewValue(
	array(
	'-' => array(
	$actor_phid => $actor_phid,
	),
	));

	break;
	}
	break;
	}

	return $results;
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return;
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	case PhabricatorTransactions::TYPE_EDGE:
	case PhabricatorTransactions::TYPE_COMMENT:
	case DifferentialTransaction::TYPE_ACTION:
	case DifferentialTransaction::TYPE_INLINE:
	return;
	}

	return parent::applyCustomExternalTransaction($object, $xaction);
	}

	+ protected function mergeEdgeData($type, array $u, array $v) {
	+ $result = parent::mergeEdgeData($type, $u, $v);
	+
	+ switch ($type) {
	+ case PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER:
	+ // When the same reviewer has their status updated by multiple
	+ // transactions, we want the strongest status to win. An example of
	+ // this is when a user adds a comment and also accepts a revision which
	+ // they are a reviewer on. The comment creates a "commented" status,
	+ // while the accept creates an "accepted" status. Since accept is
	+ // stronger, it should win and persist.
	+
	+ $u_status = idx($u, 'status');
	+ $v_status = idx($v, 'status');
	+ $u_str = DifferentialReviewerStatus::getStatusStrength($u_status);
	+ $v_str = DifferentialReviewerStatus::getStatusStrength($v_status);
	+ if ($u_str > $v_str) {
	+ $result['status'] = $u_status;
	+ } else {
	+ $result['status'] = $v_status;
	+ }
	+ break;
	+ }
	+
	+ return $result;
	+ }
	+
	+
	+
	protected function applyFinalEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
	$status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;

	$old_status = $object->getStatus();
	switch ($old_status) {
	case $status_accepted:
	case $status_revision:
	case $status_review:
	// Load the most up-to-date version of the revision and its reviewers,
	// so we don't need to try to deduce the state of reviewers by examining
	// all the changes made by the transactions.
	$new_revision = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->needReviewerStatus(true)
	->withIDs(array($object->getID()))
	->executeOne();
	if (!$new_revision) {
	throw new Exception(
	pht('Failed to load revision from transaction finalization.'));
	}

	// Try to move a revision to "accepted". We look for:
	//
	// - at least one accepting reviewer who is a user; and
	// - no rejects; and
	// - no blocking reviewers.

	$has_accepting_user = false;
	$has_rejecting_reviewer = false;
	$has_blocking_reviewer = false;
	foreach ($new_revision->getReviewerStatus() as $reviewer) {
	$reviewer_status = $reviewer->getStatus();
	switch ($reviewer_status) {
	case DifferentialReviewerStatus::STATUS_REJECTED:
	$has_rejecting_reviewer = true;
	break;
	case DifferentialReviewerStatus::STATUS_BLOCKING:
	$has_blocking_reviewer = true;
	break;
	case DifferentialReviewerStatus::STATUS_ACCEPTED:
	if ($reviewer->isUser()) {
	$has_accepting_user = true;
	}
	break;
	}
	}

	$new_status = null;
	if ($has_accepting_user &&
	!$has_rejecting_reviewer &&
	!$has_blocking_reviewer) {
	$new_status = $status_accepted;
	} else if ($has_rejecting_reviewer) {
	// This isn't accepted, and there's at least one rejecting reviewer,
	// so the revision needs changes. This usually happens after a
	// "reject".
	$new_status = $status_revision;
	} else if ($old_status == $status_accepted) {
	// This revision was accepted, but it no longer satisfies the
	// conditions for acceptance. This usually happens after an accepting
	// reviewer resigns or is removed.
	$new_status = $status_review;
	}

	if ($new_status !== null && $new_status != $old_status) {
	$xaction = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_STATUS)
	->setOldValue($old_status)
	->setNewValue($new_status);

	$xaction = $this->populateTransaction($object, $xaction)->save();

	$xactions[] = $xaction;

	$object->setStatus($new_status)->save();
	}
	break;
	default:
	// Revisions can't transition out of other statuses (like closed or
	// abandoned) as a side effect of reviewer status changes.
	break;
	}

	return $xactions;
	}


	protected function validateTransaction(
	PhabricatorLiskDAO $object,
	$type,
	array $xactions) {

	$errors = parent::validateTransaction($object, $type, $xactions);

	foreach ($xactions as $xaction) {
	switch ($type) {
	case DifferentialTransaction::TYPE_ACTION:
	$error = $this->validateDifferentialAction(
	$object,
	$type,
	$xaction,
	$xaction->getNewValue());
	if ($error) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	$error,
	$xaction);
	}
	break;
	}
	}

	return $errors;
	}

	private function validateDifferentialAction(
	DifferentialRevision $revision,
	$type,
	DifferentialTransaction $xaction,
	$action) {

	$author_phid = $revision->getAuthorPHID();
	$actor_phid = $this->getActor()->getPHID();
	$actor_is_author = ($author_phid == $actor_phid);

	$config_close_key = 'differential.always-allow-close';
	$always_allow_close = PhabricatorEnv::getEnvConfig($config_close_key);

	$config_reopen_key = 'differential.allow-reopen';
	$allow_reopen = PhabricatorEnv::getEnvConfig($config_reopen_key);

	$config_self_accept_key = 'differential.allow-self-accept';
	$allow_self_accept = PhabricatorEnv::getEnvConfig($config_self_accept_key);

	$revision_status = $revision->getStatus();

	$status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
	$status_abandoned = ArcanistDifferentialRevisionStatus::ABANDONED;
	$status_closed = ArcanistDifferentialRevisionStatus::CLOSED;

	switch ($action) {
	case DifferentialAction::ACTION_ACCEPT:
	if ($actor_is_author && !$allow_self_accept) {
	return pht(
	'You can not accept this revision because you are the owner.');
	}

	if ($revision_status == $status_abandoned) {
	return pht(
	'You can not accept this revision because it has been '.
	'abandoned.');
	}

	if ($revision_status == $status_closed) {
	return pht(
	'You can not accept this revision because it has already been '.
	'closed.');
	}
	break;

	case DifferentialAction::ACTION_REJECT:
	if ($actor_is_author) {
	return pht(
	'You can not request changes to your own revision.');
	}

	if ($revision_status == $status_abandoned) {
	return pht(
	'You can not request changes to this revision because it has been '.
	'abandoned.');
	}

	if ($revision_status == $status_closed) {
	return pht(
	'You can not request changes to this revision because it has '.
	'already been closed.');
	}
	break;

	case DifferentialAction::ACTION_RESIGN:
	// You can always resign from a revision if you're a reviewer. If you
	// aren't, this is a no-op rather than invalid.
	break;

	case DifferentialAction::ACTION_CLAIM:
	// You can claim a revision if you're not the owner. If you are, this
	// is a no-op rather than invalid.

	if ($revision_status == $status_closed) {
	return pht(
	"You can not commandeer this revision because it has already been ".
	"closed.");
	}
	break;

	case DifferentialAction::ACTION_ABANDON:
	if (!$actor_is_author) {
	return pht(
	"You can not abandon this revision because you do not own it. ".
	"You can only abandon revisions you own.");
	}

	if ($revision_status == $status_closed) {
	return pht(
	"You can not abandon this revision because it has already been ".
	"closed.");
	}

	// NOTE: Abandons of already-abandoned revisions are treated as no-op
	// instead of invalid. Other abandons are OK.

	break;

	case DifferentialAction::ACTION_RECLAIM:
	if (!$actor_is_author) {
	return pht(
	"You can not reclaim this revision because you do not own ".
	"it. You can only reclaim revisions you own.");
	}

	if ($revision_status == $status_closed) {
	return pht(
	"You can not reclaim this revision because it has already been ".
	"closed.");
	}

	// NOTE: Reclaims of other non-abandoned revisions are treated as no-op
	// instead of invalid.

	break;

	case DifferentialAction::ACTION_REOPEN:
	if (!$allow_reopen) {
	return pht(
	'The reopen action is not enabled on this Phabricator install. '.
	'Adjust your configuration to enable it.');
	}

	// NOTE: If the revision is not closed, this is caught as a no-op
	// instead of an invalid transaction.

	break;

	case DifferentialAction::ACTION_RETHINK:
	if (!$actor_is_author) {
	return pht(
	"You can not plan changes to this revision because you do not ".
	"own it. To plan chagnes to a revision, you must be its owner.");
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	// These are OK.
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	return pht(
	"You can not plan changes to this revision because it has ".
	"been abandoned.");
	case ArcanistDifferentialRevisionStatus::CLOSED:
	return pht(
	"You can not plan changes to this revision because it has ".
	"already been closed.");
	default:
	throw new Exception(
	pht(
	'Encountered unexpected revision status ("%s") when '.
	'validating "%s" action.',
	$revision_status,
	$action));
	}
	break;

	case DifferentialAction::ACTION_REQUEST:
	if (!$actor_is_author) {
	return pht(
	"You can not request review of this revision because you do ".
	"not own it. To request review of a revision, you must be its ".
	"owner.");
	}

	switch ($revision_status) {
	case ArcanistDifferentialRevisionStatus::ACCEPTED:
	case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
	// These are OK.
	break;
	case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
	// This will be caught as "no effect" later on.
	break;
	case ArcanistDifferentialRevisionStatus::ABANDONED:
	return pht(
	"You can not request review of this revision because it has ".
	"been abandoned. Instead, reclaim it.");
	case ArcanistDifferentialRevisionStatus::CLOSED:
	return pht(
	"You can not request review of this revision because it has ".
	"already been closed.");
	default:
	throw new Exception(
	pht(
	'Encountered unexpected revision status ("%s") when '.
	'validating "%s" action.',
	$revision_status,
	$action));
	}
	break;

	case DifferentialAction::ACTION_CLOSE:

	// TODO: Permit the daemons to take this action in all cases.

	if (!$actor_is_author && !$always_allow_close) {
	return pht(
	"You can not close this revision because you do not own it. To ".
	"close a revision, you must be its owner.");
	}

	if ($revision_status != $status_accepted) {
	return pht(
	"You can not close this revision because it has not been ".
	"accepted. You can only close accepted revisions.");
	}
	break;
	}

	return null;
	}

	protected function sortTransactions(array $xactions) {
	$head = array();
	$tail = array();

	// Move bare comments to the end, so the actions precede them.
	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	if ($type == DifferentialTransaction::TYPE_INLINE) {
	$tail[] = $xaction;
	} else {
	$head[] = $xaction;
	}
	}

	return array_values(array_merge($head, $tail));
	}

	protected function requireCapabilities(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	}

	return parent::requireCapabilities($object, $xaction);
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return true;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();
	$phids[] = $object->getAuthorPHID();
	foreach ($object->getReviewerStatus() as $reviewer) {
	$phids[] = $reviewer->getReviewerPHID();
	}
	return $phids;
	}

	protected function getMailSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.differential.subject-prefix');
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	return id(new DifferentialReplyHandler())
	->setMailReceiver($object);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$title = $object->getTitle();

	$original_title = $object->getOriginalTitle();

	$subject = "D{$id}: {$title}";
	$thread_topic = "D{$id}: {$original_title}";

	return id(new PhabricatorMetaMTAMail())
	->setSubject($subject)
	->addHeader('Thread-Topic', $thread_topic);
	}

	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$body = parent::buildMailBody($object, $xactions);

	$body->addTextSection(
	pht('REVISION DETAIL'),
	PhabricatorEnv::getProductionURI('/D'.$object->getID()));

	return $body;
	}

	protected function supportsSearch() {
	return true;
	}

	protected function extractFilePHIDsFromCustomTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	}

	return parent::extractFilePHIDsFromCustomTransaction($object, $xaction);
	}

	}
	diff --git a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	index cfd3ffd6d4..adc83a2819 100644
	--- a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	+++ b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
	@@ -1,1847 +1,1894 @@
	<?php

	/**
	* @task mail Sending Mail
	* @task feed Publishing Feed Stories
	* @task search Search Index
	* @task files Integration with Files
	*/
	abstract class PhabricatorApplicationTransactionEditor
	extends PhabricatorEditor {

	private $contentSource;
	private $object;
	private $xactions;

	private $isNewObject;
	private $mentionedPHIDs;
	private $continueOnNoEffect;
	private $continueOnMissingFields;
	private $parentMessageID;
	private $heraldAdapter;
	private $heraldTranscript;
	private $subscribers;

	private $isPreview;

	/**
	* When the editor tries to apply transactions that have no effect, should
	* it raise an exception (default) or drop them and continue?
	*
	* Generally, you will set this flag for edits coming from "Edit" interfaces,
	* and leave it cleared for edits coming from "Comment" interfaces, so the
	* user will get a useful error if they try to submit a comment that does
	* nothing (e.g., empty comment with a status change that has already been
	* performed by another user).
	*
	* @param bool True to drop transactions without effect and continue.
	* @return this
	*/
	public function setContinueOnNoEffect($continue) {
	$this->continueOnNoEffect = $continue;
	return $this;
	}

	public function getContinueOnNoEffect() {
	return $this->continueOnNoEffect;
	}


	/**
	* When the editor tries to apply transactions which don't populate all of
	* an object's required fields, should it raise an exception (default) or
	* drop them and continue?
	*
	* For example, if a user adds a new required custom field (like "Severity")
	* to a task, all existing tasks won't have it populated. When users
	* manually edit existing tasks, it's usually desirable to have them provide
	* a severity. However, other operations (like batch editing just the
	* owner of a task) will fail by default.
	*
	* By setting this flag for edit operations which apply to specific fields
	* (like the priority, batch, and merge editors in Maniphest), these
	* operations can continue to function even if an object is outdated.
	*
	* @param bool True to continue when transactions don't completely satisfy
	* all required fields.
	* @return this
	*/
	public function setContinueOnMissingFields($continue_on_missing_fields) {
	$this->continueOnMissingFields = $continue_on_missing_fields;
	return $this;
	}

	public function getContinueOnMissingFields() {
	return $this->continueOnMissingFields;
	}


	/**
	* Not strictly necessary, but reply handlers ideally set this value to
	* make email threading work better.
	*/
	public function setParentMessageID($parent_message_id) {
	$this->parentMessageID = $parent_message_id;
	return $this;
	}
	public function getParentMessageID() {
	return $this->parentMessageID;
	}

	protected function getIsNewObject() {
	return $this->isNewObject;
	}

	protected function getMentionedPHIDs() {
	return $this->mentionedPHIDs;
	}

	public function setIsPreview($is_preview) {
	$this->isPreview = $is_preview;
	return $this;
	}

	public function getIsPreview() {
	return $this->isPreview;
	}

	public function getTransactionTypes() {
	$types = array();

	if ($this->object instanceof PhabricatorSubscribableInterface) {
	$types[] = PhabricatorTransactions::TYPE_SUBSCRIBERS;
	}

	if ($this->object instanceof PhabricatorCustomFieldInterface) {
	$types[] = PhabricatorTransactions::TYPE_CUSTOMFIELD;
	}

	return $types;
	}

	private function adjustTransactionValues(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	$old = $this->getTransactionOldValue($object, $xaction);
	$xaction->setOldValue($old);

	$new = $this->getTransactionNewValue($object, $xaction);
	$xaction->setNewValue($new);
	}

	private function getTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return array_values($this->subscribers);
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	return $object->getViewPolicy();
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	return $object->getEditPolicy();
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	return $object->getJoinPolicy();
	case PhabricatorTransactions::TYPE_EDGE:
	$edge_type = $xaction->getMetadataValue('edge:type');
	if (!$edge_type) {
	throw new Exception("Edge transaction has no 'edge:type'!");
	}

	$old_edges = array();
	if ($object->getPHID()) {
	$edge_src = $object->getPHID();

	$old_edges = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(array($edge_src))
	->withEdgeTypes(array($edge_type))
	->needEdgeData(true)
	->execute();

	$old_edges = $old_edges[$edge_src][$edge_type];
	}
	return $old_edges;
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	// NOTE: Custom fields have their old value pre-populated when they are
	// built by PhabricatorCustomFieldList.
	return $xaction->getOldValue();
	case PhabricatorTransactions::TYPE_COMMENT:
	return null;
	default:
	return $this->getCustomTransactionOldValue($object, $xaction);
	}
	}

	private function getTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return $this->getPHIDTransactionNewValue($xaction);
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case PhabricatorTransactions::TYPE_JOIN_POLICY:
	return $xaction->getNewValue();
	case PhabricatorTransactions::TYPE_EDGE:
	return $this->getEdgeTransactionNewValue($xaction);
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getCustomFieldForTransaction($object, $xaction);
	return $field->getNewValueFromApplicationTransactions($xaction);
	case PhabricatorTransactions::TYPE_COMMENT:
	return null;
	default:
	return $this->getCustomTransactionNewValue($object, $xaction);
	}
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	throw new Exception("Capability not supported!");
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	throw new Exception("Capability not supported!");
	}

	protected function transactionHasEffect(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	return $xaction->hasComment();
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getCustomFieldForTransaction($object, $xaction);
	return $field->getApplicationTransactionHasEffect($xaction);
	case PhabricatorTransactions::TYPE_EDGE:
	// A straight value comparison here doesn't always get the right
	// result, because newly added edges aren't fully populated. Instead,
	// compare the changes in a more granular way.
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	$old_dst = array_keys($old);
	$new_dst = array_keys($new);

	// NOTE: For now, we don't consider edge reordering to be a change.
	// We have very few order-dependent edges and effectively no order
	// oriented UI. This might change in the future.
	sort($old_dst);
	sort($new_dst);

	if ($old_dst !== $new_dst) {
	// We've added or removed edges, so this transaction definitely
	// has an effect.
	return true;
	}

	// We haven't added or removed edges, but we might have changed
	// edge data.
	foreach ($old as $key => $old_value) {
	$new_value = $new[$key];
	if ($old_value['data'] !== $new_value['data']) {
	return true;
	}
	}

	return false;
	}

	return ($xaction->getOldValue() !== $xaction->getNewValue());
	}

	protected function shouldApplyInitialEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return false;
	}

	protected function applyInitialEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {
	throw new Exception('Not implemented.');
	}

	private function applyInternalEffects(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	$object->setViewPolicy($xaction->getNewValue());
	break;
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	$object->setEditPolicy($xaction->getNewValue());
	break;
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getCustomFieldForTransaction($object, $xaction);
	return $field->applyApplicationTransactionInternalEffects($xaction);
	}
	return $this->applyCustomInternalTransaction($object, $xaction);
	}

	private function applyExternalEffects(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	$subeditor = id(new PhabricatorSubscriptionsEditor())
	->setObject($object)
	->setActor($this->requireActor());

	$old_map = array_fuse($xaction->getOldValue());
	$new_map = array_fuse($xaction->getNewValue());

	$subeditor->unsubscribe(
	array_keys(
	array_diff_key($old_map, $new_map)));

	$subeditor->subscribeExplicit(
	array_keys(
	array_diff_key($new_map, $old_map)));

	$subeditor->save();

	// for the rest of these edits, subscribers should include those just
	// added as well as those just removed.
	$subscribers = array_unique(array_merge(
	$this->subscribers,
	$xaction->getOldValue(),
	$xaction->getNewValue()));
	$this->subscribers = $subscribers;

	break;
	case PhabricatorTransactions::TYPE_EDGE:
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();
	$src = $object->getPHID();
	$type = $xaction->getMetadataValue('edge:type');

	foreach ($new as $dst_phid => $edge) {
	$new[$dst_phid]['src'] = $src;
	}

	$editor = id(new PhabricatorEdgeEditor())
	->setActor($this->getActor());

	foreach ($old as $dst_phid => $edge) {
	if (!empty($new[$dst_phid])) {
	if ($old[$dst_phid]['data'] === $new[$dst_phid]['data']) {
	continue;
	}
	}
	$editor->removeEdge($src, $type, $dst_phid);
	}

	foreach ($new as $dst_phid => $edge) {
	if (!empty($old[$dst_phid])) {
	if ($old[$dst_phid]['data'] === $new[$dst_phid]['data']) {
	continue;
	}
	}

	$data = array(
	'data' => $edge['data'],
	);

	$editor->addEdge($src, $type, $dst_phid, $data);
	}

	$editor->save();
	break;
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$field = $this->getCustomFieldForTransaction($object, $xaction);
	return $field->applyApplicationTransactionExternalEffects($xaction);
	}

	return $this->applyCustomExternalTransaction($object, $xaction);
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	$type = $xaction->getTransactionType();
	throw new Exception(
	"Transaction type '{$type}' is missing an internal apply ".
	"implementation!");
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	$type = $xaction->getTransactionType();
	throw new Exception(
	"Transaction type '{$type}' is missing an external apply ".
	"implementation!");
	}

	/**
	* Fill in a transaction's common values, like author and content source.
	*/
	protected function populateTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$actor = $this->getActor();

	// TODO: This needs to be more sophisticated once we have meta-policies.
	$xaction->setViewPolicy(PhabricatorPolicies::POLICY_PUBLIC);
	$xaction->setEditPolicy($actor->getPHID());

	$xaction->setAuthorPHID($actor->getPHID());
	$xaction->setContentSource($this->getContentSource());
	$xaction->attachViewer($actor);
	$xaction->attachObject($object);

	if ($object->getPHID()) {
	$xaction->setObjectPHID($object->getPHID());
	}

	return $xaction;
	}


	protected function applyFinalEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $xactions;
	}

	public function setContentSource(PhabricatorContentSource $content_source) {
	$this->contentSource = $content_source;
	return $this;
	}

	public function setContentSourceFromRequest(AphrontRequest $request) {
	return $this->setContentSource(
	PhabricatorContentSource::newFromRequest($request));
	}

	public function getContentSource() {
	return $this->contentSource;
	}

	final public function applyTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$this->object = $object;
	$this->xactions = $xactions;
	$this->isNewObject = ($object->getPHID() === null);

	$this->validateEditParameters($object, $xactions);

	$actor = $this->requireActor();

	$this->loadSubscribers($object);

	$xactions = $this->applyImplicitCC($object, $xactions);

	$mention_xaction = $this->buildMentionTransaction($object, $xactions);
	if ($mention_xaction) {
	$xactions[] = $mention_xaction;
	}

	$xactions = $this->expandTransactions($object, $xactions);
	$xactions = $this->combineTransactions($xactions);

	foreach ($xactions as $xaction) {
	$xaction = $this->populateTransaction($object, $xaction);
	}

	$is_preview = $this->getIsPreview();
	$read_locking = false;
	$transaction_open = false;

	if (!$is_preview) {
	$errors = array();
	$type_map = mgroup($xactions, 'getTransactionType');
	foreach ($this->getTransactionTypes() as $type) {
	$type_xactions = idx($type_map, $type, array());
	$errors[] = $this->validateTransaction($object, $type, $type_xactions);
	}

	$errors = array_mergev($errors);

	$continue_on_missing = $this->getContinueOnMissingFields();
	foreach ($errors as $key => $error) {
	if ($continue_on_missing && $error->getIsMissingFieldError()) {
	unset($errors[$key]);
	}
	}

	if ($errors) {
	throw new PhabricatorApplicationTransactionValidationException($errors);
	}

	$file_phids = $this->extractFilePHIDs($object, $xactions);

	if ($object->getID()) {
	foreach ($xactions as $xaction) {

	// If any of the transactions require a read lock, hold one and
	// reload the object. We need to do this fairly early so that the
	// call to `adjustTransactionValues()` (which populates old values)
	// is based on the synchronized state of the object, which may differ
	// from the state when it was originally loaded.

	if ($this->shouldReadLock($object, $xaction)) {
	$object->openTransaction();
	$object->beginReadLocking();
	$transaction_open = true;
	$read_locking = true;
	$object->reload();
	break;
	}
	}
	}

	if ($this->shouldApplyInitialEffects($object, $xactions)) {
	if (!$transaction_open) {
	$object->openTransaction();
	$transaction_open = true;
	}
	}
	}

	if ($this->shouldApplyInitialEffects($object, $xactions)) {
	$this->applyInitialEffects($object, $xactions);
	}

	foreach ($xactions as $xaction) {
	$this->adjustTransactionValues($object, $xaction);
	}

	$xactions = $this->filterTransactions($object, $xactions);

	if (!$xactions) {
	if ($read_locking) {
	$object->endReadLocking();
	$read_locking = false;
	}
	if ($transaction_open) {
	$object->killTransaction();
	$transaction_open = false;
	}
	return array();
	}

	// Now that we've merged, filtered, and combined transactions, check for
	// required capabilities.
	foreach ($xactions as $xaction) {
	$this->requireCapabilities($object, $xaction);
	}

	$xactions = $this->sortTransactions($xactions);

	if ($is_preview) {
	$this->loadHandles($xactions);
	return $xactions;
	}

	$comment_editor = id(new PhabricatorApplicationTransactionCommentEditor())
	->setActor($actor)
	->setContentSource($this->getContentSource());

	if (!$transaction_open) {
	$object->openTransaction();
	}

	foreach ($xactions as $xaction) {
	$this->applyInternalEffects($object, $xaction);
	}

	$object->save();

	foreach ($xactions as $xaction) {
	$xaction->setObjectPHID($object->getPHID());
	if ($xaction->getComment()) {
	$xaction->setPHID($xaction->generatePHID());
	$comment_editor->applyEdit($xaction, $xaction->getComment());
	} else {
	$xaction->save();
	}
	}

	if ($file_phids) {
	$this->attachFiles($object, $file_phids);
	}

	foreach ($xactions as $xaction) {
	$this->applyExternalEffects($object, $xaction);
	}

	if ($this->supportsHerald()) {
	$this->applyHeraldRules($object, $xactions);
	}

	$xactions = $this->applyFinalEffects($object, $xactions);

	if ($read_locking) {
	$object->endReadLocking();
	$read_locking = false;
	}

	$object->saveTransaction();

	$this->loadHandles($xactions);

	$mail = null;
	if ($this->shouldSendMail($object, $xactions)) {
	$mail = $this->sendMail($object, $xactions);
	}

	if ($this->supportsSearch()) {
	id(new PhabricatorSearchIndexer())
	->queueDocumentForIndexing($object->getPHID());
	}

	if ($this->supportsFeed()) {
	$mailed = array();
	if ($mail) {
	$mailed = $mail->buildRecipientList();
	}
	$this->publishFeedStory(
	$object,
	$xactions,
	$mailed);
	}

	$this->didApplyTransactions($xactions);

	if ($object instanceof PhabricatorCustomFieldInterface) {
	// Maybe this makes more sense to move into the search index itself? For
	// now I'm putting it here since I think we might end up with things that
	// need it to be up to date once the next page loads, but if we don't go
	// there we we could move it into search once search moves to the daemons.

	// It now happens in the search indexer as well, but the search indexer is
	// always daemonized, so the logic above still potentially holds. We could
	// possibly get rid of this. The major motivation for putting it in the
	// indexer was to enable reindexing to work.

	$fields = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	$fields->readFieldsFromStorage($object);
	$fields->rebuildIndexes($object);
	}

	return $xactions;
	}

	protected function didApplyTransactions(array $xactions) {
	// Hook for subclasses.
	return;
	}


	/**
	* Determine if the editor should hold a read lock on the object while
	* applying a transaction.
	*
	* If the editor does not hold a lock, two editors may read an object at the
	* same time, then apply their changes without any synchronization. For most
	* transactions, this does not matter much. However, it is important for some
	* transactions. For example, if an object has a transaction count on it, both
	* editors may read the object with `count = 23`, then independently update it
	* and save the object with `count = 24` twice. This will produce the wrong
	* state: the object really has 25 transactions, but the count is only 24.
	*
	* Generally, transactions fall into one of four buckets:
	*
	* - Append operations: Actions like adding a comment to an object purely
	* add information to its state, and do not depend on the current object
	* state in any way. These transactions never need to hold locks.
	* - Overwrite operations: Actions like changing the title or description
	* of an object replace the current value with a new value, so the end
	* state is consistent without a lock. We currently do not lock these
	* transactions, although we may in the future.
	* - Edge operations: Edge and subscription operations have internal
	* synchronization which limits the damage race conditions can cause.
	* We do not currently lock these transactions, although we may in the
	* future.
	* - Update operations: Actions like incrementing a count on an object.
	* These operations generally should use locks, unless it is not
	* important that the state remain consistent in the presence of races.
	*
	* @param PhabricatorLiskDAO Object being updated.
	* @param PhabricatorApplicationTransaction Transaction being applied.
	* @return bool True to synchronize the edit with a lock.
	*/
	protected function shouldReadLock(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	return false;
	}

	private function loadHandles(array $xactions) {
	$phids = array();
	foreach ($xactions as $key => $xaction) {
	$phids[$key] = $xaction->getRequiredHandlePHIDs();
	}
	$handles = array();
	$merged = array_mergev($phids);
	if ($merged) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireActor())
	->withPHIDs($merged)
	->execute();
	}
	foreach ($xactions as $key => $xaction) {
	$xaction->setHandles(array_select_keys($handles, $phids[$key]));
	}
	}

	private function loadSubscribers(PhabricatorLiskDAO $object) {
	if ($object->getPHID() &&
	($object instanceof PhabricatorSubscribableInterface)) {
	$subs = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$object->getPHID());
	$this->subscribers = array_fuse($subs);
	} else {
	$this->subscribers = array();
	}
	}

	private function validateEditParameters(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if (!$this->getContentSource()) {
	throw new Exception(
	"Call setContentSource() before applyTransactions()!");
	}

	// Do a bunch of sanity checks that the incoming transactions are fresh.
	// They should be unsaved and have only "transactionType" and "newValue"
	// set.

	$types = array_fill_keys($this->getTransactionTypes(), true);

	assert_instances_of($xactions, 'PhabricatorApplicationTransaction');
	foreach ($xactions as $xaction) {
	if ($xaction->getPHID() \|\| $xaction->getID()) {
	throw new Exception(
	"You can not apply transactions which already have IDs/PHIDs!");
	}
	if ($xaction->getObjectPHID()) {
	throw new Exception(
	"You can not apply transactions which already have objectPHIDs!");
	}
	if ($xaction->getAuthorPHID()) {
	throw new Exception(
	"You can not apply transactions which already have authorPHIDs!");
	}
	if ($xaction->getCommentPHID()) {
	throw new Exception(
	"You can not apply transactions which already have commentPHIDs!");
	}
	if ($xaction->getCommentVersion() !== 0) {
	throw new Exception(
	"You can not apply transactions which already have commentVersions!");
	}

	$exempt_types = array(
	// CustomField logic currently prefills these before we enter the
	// transaction editor.
	PhabricatorTransactions::TYPE_CUSTOMFIELD => true,

	// TODO: Remove this, this edge type is encumbered with a bunch of
	// legacy nonsense.
	ManiphestTransaction::TYPE_EDGE => true,
	);

	if (empty($exempt_types[$xaction->getTransactionType()])) {
	if ($xaction->getOldValue() !== null) {
	throw new Exception(
	"You can not apply transactions which already have oldValue!");
	}
	}

	$type = $xaction->getTransactionType();
	if (empty($types[$type])) {
	throw new Exception(
	pht(
	'Transaction has type "%s", but that transaction type is not '.
	'supported by this editor (%s).',
	$type,
	get_class($this)));
	}
	}

	// The actor must have permission to view and edit the object.

	$actor = $this->requireActor();

	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$object,
	PhabricatorPolicyCapability::CAN_VIEW);
	}

	protected function requireCapabilities(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	// You must have the edit capability to alter the edit policy of an
	// object. For other default transaction types, we don't enforce
	// anything for the moment.

	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	break;
	}
	}

	private function buildMentionTransaction(
	PhabricatorLiskDAO $object,
	array $xactions) {

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

	$texts = array();
	foreach ($xactions as $xaction) {
	$texts[] = $this->getRemarkupBlocksFromTransaction($xaction);
	}
	$texts = array_mergev($texts);

	$phids = PhabricatorMarkupEngine::extractPHIDsFromMentions($texts);

	$this->mentionedPHIDs = $phids;

	if ($object->getPHID()) {
	// Don't try to subscribe already-subscribed mentions: we want to generate
	// a dialog about an action having no effect if the user explicitly adds
	// existing CCs, but not if they merely mention existing subscribers.
	$phids = array_diff($phids, $this->subscribers);
	}

	foreach ($phids as $key => $phid) {
	if ($object->isAutomaticallySubscribed($phid)) {
	unset($phids[$key]);
	}
	}
	$phids = array_values($phids);

	if (!$phids) {
	return null;
	}

	$xaction = newv(get_class(head($xactions)), array());
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
	$xaction->setNewValue(array('+' => $phids));

	return $xaction;
	}

	protected function getRemarkupBlocksFromTransaction(
	PhabricatorApplicationTransaction $transaction) {
	$texts = array();
	if ($transaction->getComment()) {
	$texts[] = $transaction->getComment()->getContent();
	}
	return $texts;
	}

	protected function mergeTransactions(
	PhabricatorApplicationTransaction $u,
	PhabricatorApplicationTransaction $v) {

	$type = $u->getTransactionType();

	switch ($type) {
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return $this->mergePHIDOrEdgeTransactions($u, $v);
	case PhabricatorTransactions::TYPE_EDGE:
	$u_type = $u->getMetadataValue('edge:type');
	$v_type = $v->getMetadataValue('edge:type');
	if ($u_type == $v_type) {
	return $this->mergePHIDOrEdgeTransactions($u, $v);
	}
	return null;
	}

	// By default, do not merge the transactions.
	return null;
	}

	/**
	* Optionally expand transactions which imply other effects. For example,
	* resigning from a revision in Differential implies removing yourself as
	* a reviewer.
	*/
	private function expandTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$results = array();
	foreach ($xactions as $xaction) {
	foreach ($this->expandTransaction($object, $xaction) as $expanded) {
	$results[] = $expanded;
	}
	}

	return $results;
	}

	protected function expandTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	return array($xaction);
	}

	/**
	* Attempt to combine similar transactions into a smaller number of total
	* transactions. For example, two transactions which edit the title of an
	* object can be merged into a single edit.
	*/
	private function combineTransactions(array $xactions) {
	$stray_comments = array();

	$result = array();
	$types = array();
	foreach ($xactions as $key => $xaction) {
	$type = $xaction->getTransactionType();
	if (isset($types[$type])) {
	foreach ($types[$type] as $other_key) {
	$merged = $this->mergeTransactions($result[$other_key], $xaction);
	if ($merged) {
	$result[$other_key] = $merged;

	if ($xaction->getComment() &&
	($xaction->getComment() !== $merged->getComment())) {
	$stray_comments[] = $xaction->getComment();
	}

	if ($result[$other_key]->getComment() &&
	($result[$other_key]->getComment() !== $merged->getComment())) {
	$stray_comments[] = $result[$other_key]->getComment();
	}

	// Move on to the next transaction.
	continue 2;
	}
	}
	}
	$result[$key] = $xaction;
	$types[$type][] = $key;
	}

	// If we merged any comments away, restore them.
	foreach ($stray_comments as $comment) {
	$xaction = newv(get_class(head($result)), array());
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_COMMENT);
	$xaction->setComment($comment);
	$result[] = $xaction;
	}

	return array_values($result);
	}

	protected function mergePHIDOrEdgeTransactions(
	PhabricatorApplicationTransaction $u,
	PhabricatorApplicationTransaction $v) {

	$result = $u->getNewValue();
	foreach ($v->getNewValue() as $key => $value) {
	- $result[$key] = array_merge($value, idx($result, $key, array()));
	+ if ($u->getTransactionType() == PhabricatorTransactions::TYPE_EDGE) {
	+ if (empty($result[$key])) {
	+ $result[$key] = $value;
	+ } else {
	+ // We're merging two lists of edge adds, sets, or removes. Merge
	+ // them by merging individual PHIDs within them.
	+ $merged = $result[$key];
	+
	+ foreach ($value as $dst => $v_spec) {
	+ if (empty($merged[$dst])) {
	+ $merged[$dst] = $v_spec;
	+ } else {
	+ // Two transactions are trying to perform the same operation on
	+ // the same edge. Normalize the edge data and then merge it. This
	+ // allows transactions to specify how data merges execute in a
	+ // precise way.
	+
	+ $u_spec = $merged[$dst];
	+
	+ if (!is_array($u_spec)) {
	+ $u_spec = array('dst' => $u_spec);
	+ }
	+ if (!is_array($v_spec)) {
	+ $v_spec = array('dst' => $v_spec);
	+ }
	+
	+ $ux_data = idx($u_spec, 'data', array());
	+ $vx_data = idx($v_spec, 'data', array());
	+
	+ $merged_data = $this->mergeEdgeData(
	+ $u->getMetadataValue('edge:type'),
	+ $ux_data,
	+ $vx_data);
	+
	+ $u_spec['data'] = $merged_data;
	+ $merged[$dst] = $u_spec;
	+ }
	+ }
	+
	+ $result[$key] = $merged;
	+ }
	+ } else {
	+ $result[$key] = array_merge($value, idx($result, $key, array()));
	+ }
	}
	$u->setNewValue($result);

	// When combining an "ignore" transaction with a normal transaction, make
	// sure we don't propagate the "ignore" flag.
	if (!$v->getIgnoreOnNoEffect()) {
	$u->setIgnoreOnNoEffect(false);
	}

	return $u;
	}

	+ protected function mergeEdgeData($type, array $u, array $v) {
	+ return $v + $u;
	+ }
	+
	protected function getPHIDTransactionNewValue(
	PhabricatorApplicationTransaction $xaction) {

	$old = array_fuse($xaction->getOldValue());

	$new = $xaction->getNewValue();
	$new_add = idx($new, '+', array());
	unset($new['+']);
	$new_rem = idx($new, '-', array());
	unset($new['-']);
	$new_set = idx($new, '=', null);
	if ($new_set !== null) {
	$new_set = array_fuse($new_set);
	}
	unset($new['=']);

	if ($new) {
	throw new Exception(
	"Invalid 'new' value for PHID transaction. Value should contain only ".
	"keys '+' (add PHIDs), '-' (remove PHIDs) and '=' (set PHIDS).");
	}

	$result = array();

	foreach ($old as $phid) {
	if ($new_set !== null && empty($new_set[$phid])) {
	continue;
	}
	$result[$phid] = $phid;
	}

	if ($new_set !== null) {
	foreach ($new_set as $phid) {
	$result[$phid] = $phid;
	}
	}

	foreach ($new_add as $phid) {
	$result[$phid] = $phid;
	}

	foreach ($new_rem as $phid) {
	unset($result[$phid]);
	}

	return array_values($result);
	}

	protected function getEdgeTransactionNewValue(
	PhabricatorApplicationTransaction $xaction) {

	$new = $xaction->getNewValue();
	$new_add = idx($new, '+', array());
	unset($new['+']);
	$new_rem = idx($new, '-', array());
	unset($new['-']);
	$new_set = idx($new, '=', null);
	unset($new['=']);

	if ($new) {
	throw new Exception(
	"Invalid 'new' value for Edge transaction. Value should contain only ".
	"keys '+' (add edges), '-' (remove edges) and '=' (set edges).");
	}

	$old = $xaction->getOldValue();

	$lists = array($new_set, $new_add, $new_rem);
	foreach ($lists as $list) {
	$this->checkEdgeList($list);
	}

	$result = array();
	foreach ($old as $dst_phid => $edge) {
	if ($new_set !== null && empty($new_set[$dst_phid])) {
	continue;
	}
	$result[$dst_phid] = $this->normalizeEdgeTransactionValue(
	$xaction,
	$edge,
	$dst_phid);
	}

	if ($new_set !== null) {
	foreach ($new_set as $dst_phid => $edge) {
	$result[$dst_phid] = $this->normalizeEdgeTransactionValue(
	$xaction,
	$edge,
	$dst_phid);
	}
	}

	foreach ($new_add as $dst_phid => $edge) {
	$result[$dst_phid] = $this->normalizeEdgeTransactionValue(
	$xaction,
	$edge,
	$dst_phid);
	}

	foreach ($new_rem as $dst_phid => $edge) {
	unset($result[$dst_phid]);
	}

	return $result;
	}

	private function checkEdgeList($list) {
	if (!$list) {
	return;
	}
	foreach ($list as $key => $item) {
	if (phid_get_type($key) === PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
	throw new Exception(
	"Edge transactions must have destination PHIDs as in edge ".
	"lists (found key '{$key}').");
	}
	if (!is_array($item) && $item !== $key) {
	throw new Exception(
	"Edge transactions must have PHIDs or edge specs as values ".
	"(found value '{$item}').");
	}
	}
	}

	private function normalizeEdgeTransactionValue(
	PhabricatorApplicationTransaction $xaction,
	$edge,
	$dst_phid) {

	if (!is_array($edge)) {
	if ($edge != $dst_phid) {
	throw new Exception(
	pht(
	'Transaction edge data must either be the edge PHID or an edge '.
	'specification dictionary.'));
	}
	$edge = array();
	} else {
	foreach ($edge as $key => $value) {
	switch ($key) {
	case 'src':
	case 'dst':
	case 'type':
	case 'data':
	case 'dateCreated':
	case 'dateModified':
	case 'seq':
	case 'dataID':
	break;
	default:
	throw new Exception(
	pht(
	'Transaction edge specification contains unexpected key '.
	'"%s".',
	$key));
	}
	}
	}

	$edge['dst'] = $dst_phid;

	$edge_type = $xaction->getMetadataValue('edge:type');
	if (empty($edge['type'])) {
	$edge['type'] = $edge_type;
	} else {
	if ($edge['type'] != $edge_type) {
	$this_type = $edge['type'];
	throw new Exception(
	"Edge transaction includes edge of type '{$this_type}', but ".
	"transaction is of type '{$edge_type}'. Each edge transaction must ".
	"alter edges of only one type.");
	}
	}

	if (!isset($edge['data'])) {
	$edge['data'] = array();
	}

	return $edge;
	}

	protected function sortTransactions(array $xactions) {
	$head = array();
	$tail = array();

	// Move bare comments to the end, so the actions precede them.
	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	if ($type == PhabricatorTransactions::TYPE_COMMENT) {
	$tail[] = $xaction;
	} else {
	$head[] = $xaction;
	}
	}

	return array_values(array_merge($head, $tail));
	}


	protected function filterTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$type_comment = PhabricatorTransactions::TYPE_COMMENT;

	$no_effect = array();
	$has_comment = false;
	$any_effect = false;
	foreach ($xactions as $key => $xaction) {
	if ($this->transactionHasEffect($object, $xaction)) {
	if ($xaction->getTransactionType() != $type_comment) {
	$any_effect = true;
	}
	} else if ($xaction->getIgnoreOnNoEffect()) {
	unset($xactions[$key]);
	} else {
	$no_effect[$key] = $xaction;
	}
	if ($xaction->hasComment()) {
	$has_comment = true;
	}
	}

	if (!$no_effect) {
	return $xactions;
	}

	if (!$this->getContinueOnNoEffect() && !$this->getIsPreview()) {
	throw new PhabricatorApplicationTransactionNoEffectException(
	$no_effect,
	$any_effect,
	$has_comment);
	}

	if (!$any_effect && !$has_comment) {
	// If we only have empty comment transactions, just drop them all.
	return array();
	}

	foreach ($no_effect as $key => $xaction) {
	if ($xaction->getComment()) {
	$xaction->setTransactionType($type_comment);
	$xaction->setOldValue(null);
	$xaction->setNewValue(null);
	} else {
	unset($xactions[$key]);
	}
	}

	return $xactions;
	}


	/**
	* Hook for validating transactions. This callback will be invoked for each
	* available transaction type, even if an edit does not apply any transactions
	* of that type. This allows you to raise exceptions when required fields are
	* missing, by detecting that the object has no field value and there is no
	* transaction which sets one.
	*
	* @param PhabricatorLiskDAO Object being edited.
	* @param string Transaction type to validate.
	* @param list<PhabricatorApplicationTransaction> Transactions of given type,
	* which may be empty if the edit does not apply any transactions of the
	* given type.
	* @return list<PhabricatorApplicationTransactionValidationError> List of
	* validation errors.
	*/
	protected function validateTransaction(
	PhabricatorLiskDAO $object,
	$type,
	array $xactions) {

	$errors = array();
	switch ($type) {
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	// Make sure the user isn't editing away their ability to edit this
	// object.
	foreach ($xactions as $xaction) {
	try {
	PhabricatorPolicyFilter::requireCapabilityWithForcedPolicy(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_EDIT,
	$xaction->getNewValue());
	} catch (PhabricatorPolicyException $ex) {
	$errors[] = array(
	new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'You can not select this edit policy, because you would '.
	'no longer be able to edit the object.'),
	$xaction),
	);
	}
	}
	break;
	case PhabricatorTransactions::TYPE_CUSTOMFIELD:
	$groups = array();
	foreach ($xactions as $xaction) {
	$groups[$xaction->getMetadataValue('customfield:key')][] = $xaction;
	}

	$field_list = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_EDIT);

	$role_xactions = PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS;
	foreach ($field_list->getFields() as $field) {
	if (!$field->shouldEnableForRole($role_xactions)) {
	continue;
	}
	$errors[] = $field->validateApplicationTransactions(
	$this,
	$type,
	idx($groups, $field->getFieldKey(), array()));
	}
	break;
	}

	return array_mergev($errors);
	}


	/**
	* Check for a missing text field.
	*
	* A text field is missing if the object has no value and there are no
	* transactions which set a value, or if the transactions remove the value.
	* This method is intended to make implementing @{method:validateTransaction}
	* more convenient:
	*
	* $missing = $this->validateIsEmptyTextField(
	* $object->getName(),
	* $xactions);
	*
	* This will return `true` if the net effect of the object and transactions
	* is an empty field.
	*
	* @param wild Current field value.
	* @param list<PhabricatorApplicationTransaction> Transactions editing the
	* field.
	* @return bool True if the field will be an empty text field after edits.
	*/
	protected function validateIsEmptyTextField($field_value, array $xactions) {
	if (strlen($field_value) && empty($xactions)) {
	return false;
	}

	if ($xactions && strlen(last($xactions)->getNewValue())) {
	return false;
	}

	return true;
	}


	/* -( Implicit CCs )------------------------------------------------------- */


	/**
	* When a user interacts with an object, we might want to add them to CC.
	*/
	final public function applyImplicitCC(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if (!($object instanceof PhabricatorSubscribableInterface)) {
	// If the object isn't subscribable, we can't CC them.
	return $xactions;
	}

	$actor_phid = $this->requireActor()->getPHID();
	if ($object->isAutomaticallySubscribed($actor_phid)) {
	// If they're auto-subscribed, don't CC them.
	return $xactions;
	}

	$should_cc = false;
	foreach ($xactions as $xaction) {
	if ($this->shouldImplyCC($object, $xaction)) {
	$should_cc = true;
	break;
	}
	}

	if (!$should_cc) {
	// Only some types of actions imply a CC (like adding a comment).
	return $xactions;
	}

	if ($object->getPHID()) {
	if (isset($this->subscribers[$actor_phid])) {
	// If the user is already subscribed, don't implicitly CC them.
	return $xactions;
	}

	$unsub = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object->getPHID(),
	PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER);
	$unsub = array_fuse($unsub);
	if (isset($unsub[$actor_phid])) {
	// If the user has previously unsubscribed from this object explicitly,
	// don't implicitly CC them.
	return $xactions;
	}
	}

	$xaction = newv(get_class(head($xactions)), array());
	$xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
	$xaction->setNewValue(array('+' => array($actor_phid)));

	array_unshift($xactions, $xaction);

	return $xactions;
	}

	protected function shouldImplyCC(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	return $xaction->isCommentTransaction();
	}


	/* -( Sending Mail )------------------------------------------------------- */


	/**
	* @task mail
	*/
	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return false;
	}


	/**
	* @task mail
	*/
	protected function sendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$email_to = array_filter(array_unique($this->getMailTo($object)));
	$email_cc = array_filter(array_unique($this->getMailCC($object)));

	$phids = array_merge($email_to, $email_cc);
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireActor())
	->withPHIDs($phids)
	->execute();

	$template = $this->buildMailTemplate($object);
	$body = $this->buildMailBody($object, $xactions);

	$mail_tags = $this->getMailTags($object, $xactions);

	$action = $this->getStrongestAction($object, $xactions)->getActionName();

	$template
	->setFrom($this->requireActor()->getPHID())
	->setSubjectPrefix($this->getMailSubjectPrefix())
	->setVarySubjectPrefix('['.$action.']')
	->setThreadID($this->getMailThreadID($object), $this->getIsNewObject())
	->setRelatedPHID($object->getPHID())
	->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
	->setMailTags($mail_tags)
	->setIsBulk(true)
	->setBody($body->render());

	if ($this->getParentMessageID()) {
	$template->setParentMessageID($this->getParentMessageID());
	}

	$mails = $this
	->buildReplyHandler($object)
	->multiplexMail(
	$template,
	array_select_keys($handles, $email_to),
	array_select_keys($handles, $email_cc));

	foreach ($mails as $mail) {
	$mail->saveAndSend();
	}

	$template->addTos($email_to);
	$template->addCCs($email_cc);

	return $template;
	}

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	return $object->getPHID();
	}


	/**
	* @task mail
	*/
	protected function getStrongestAction(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return last(msort($xactions, 'getActionStrength'));
	}


	/**
	* @task mail
	*/
	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailSubjectPrefix() {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailTags(
	PhabricatorLiskDAO $object,
	array $xactions) {
	$tags = array();

	foreach ($xactions as $xaction) {
	$tags[] = $xaction->getMailTags();
	}

	return array_mergev($tags);
	}


	/**
	* @task mail
	*/
	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailTo(PhabricatorLiskDAO $object) {
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function getMailCC(PhabricatorLiskDAO $object) {
	if ($object instanceof PhabricatorSubscribableInterface) {
	return $this->subscribers;
	}
	throw new Exception("Capability not supported.");
	}


	/**
	* @task mail
	*/
	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$headers = array();
	$comments = array();

	foreach ($xactions as $xaction) {
	if ($xaction->shouldHideForMail()) {
	continue;
	}
	$headers[] = id(clone $xaction)->setRenderingTarget('text')->getTitle();
	$comment = $xaction->getComment();
	if ($comment && strlen($comment->getContent())) {
	$comments[] = $comment->getContent();
	}
	}

	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection(implode("\n", $headers));

	foreach ($comments as $comment) {
	$body->addRawSection($comment);
	}

	return $body;
	}


	/* -( Publishing Feed Stories )-------------------------------------------- */


	/**
	* @task feed
	*/
	protected function supportsFeed() {
	return false;
	}


	/**
	* @task feed
	*/
	protected function getFeedStoryType() {
	return 'PhabricatorApplicationTransactionFeedStory';
	}


	/**
	* @task feed
	*/
	protected function getFeedRelatedPHIDs(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return array(
	$object->getPHID(),
	$this->requireActor()->getPHID(),
	);
	}


	/**
	* @task feed
	*/
	protected function getFeedNotifyPHIDs(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return array_unique(array_merge(
	$this->getMailTo($object),
	$this->getMailCC($object)));
	}


	/**
	* @task feed
	*/
	protected function getFeedStoryData(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$xactions = msort($xactions, 'getActionStrength');
	$xactions = array_reverse($xactions);

	return array(
	'objectPHID' => $object->getPHID(),
	'transactionPHIDs' => mpull($xactions, 'getPHID'),
	);
	}


	/**
	* @task feed
	*/
	protected function publishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions,
	array $mailed_phids) {

	$related_phids = $this->getFeedRelatedPHIDs($object, $xactions);
	$subscribed_phids = $this->getFeedNotifyPHIDs($object, $xactions);

	$story_type = $this->getFeedStoryType();
	$story_data = $this->getFeedStoryData($object, $xactions);

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType($story_type)
	->setStoryData($story_data)
	->setStoryTime(time())
	->setStoryAuthorPHID($this->requireActor()->getPHID())
	->setRelatedPHIDs($related_phids)
	->setPrimaryObjectPHID($object->getPHID())
	->setSubscribedPHIDs($subscribed_phids)
	->setMailRecipientPHIDs($mailed_phids)
	->publish();
	}


	/* -( Search Index )------------------------------------------------------- */


	/**
	* @task search
	*/
	protected function supportsSearch() {
	return false;
	}


	/* -( Herald Integration )-------------------------------------------------- */


	protected function supportsHerald() {
	return false;
	}

	protected function buildHeraldAdapter(
	PhabricatorLiskDAO $object,
	array $xactions) {
	throw new Exception('No herald adapter specified.');
	}

	private function setHeraldAdapter(HeraldAdapter $adapter) {
	$this->heraldAdapter = $adapter;
	return $this;
	}

	protected function getHeraldAdapter() {
	return $this->heraldAdapter;
	}

	private function setHeraldTranscript(HeraldTranscript $transcript) {
	$this->heraldTranscript = $transcript;
	return $this;
	}

	protected function getHeraldTranscript() {
	return $this->heraldTranscript;
	}

	private function applyHeraldRules(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$adapter = $this->buildHeraldAdapter($object, $xactions);
	$adapter->setContentSource($this->getContentSource());
	$adapter->setIsNewObject($this->getIsNewObject());
	$xscript = HeraldEngine::loadAndApplyRules($adapter);

	$this->setHeraldAdapter($adapter);
	$this->setHeraldTranscript($xscript);

	$this->didApplyHeraldRules($object, $adapter, $xscript);
	}

	protected function didApplyHeraldRules(
	PhabricatorLiskDAO $object,
	HeraldAdapter $adapter,
	HeraldTranscript $transcript) {

	}


	/* -( Custom Fields )------------------------------------------------------ */


	/**
	* @task customfield
	*/
	private function getCustomFieldForTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$field_key = $xaction->getMetadataValue('customfield:key');
	if (!$field_key) {
	throw new Exception(
	"Custom field transaction has no 'customfield:key'!");
	}

	$field = PhabricatorCustomField::getObjectField(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS,
	$field_key);

	if (!$field) {
	throw new Exception(
	"Custom field transaction has invalid 'customfield:key'; field ".
	"'{$field_key}' is disabled or does not exist.");
	}

	if (!$field->shouldAppearInApplicationTransactions()) {
	throw new Exception(
	"Custom field transaction '{$field_key}' does not implement ".
	"integration for ApplicationTransactions.");
	}

	return $field;
	}


	/* -( Files )-------------------------------------------------------------- */


	/**
	* Extract the PHIDs of any files which these transactions attach.
	*
	* @task files
	*/
	private function extractFilePHIDs(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$blocks = array();
	foreach ($xactions as $xaction) {
	$blocks[] = $this->getRemarkupBlocksFromTransaction($xaction);
	}
	$blocks = array_mergev($blocks);


	$phids = array();
	if ($blocks) {
	$phids[] = PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
	$blocks);
	}

	foreach ($xactions as $xaction) {
	$phids[] = $this->extractFilePHIDsFromCustomTransaction(
	$object,
	$xaction);
	}

	$phids = array_unique(array_filter(array_mergev($phids)));
	if (!$phids) {
	return array();
	}

	// Only let a user attach files they can actually see, since this would
	// otherwise let you access any file by attaching it to an object you have
	// view permission on.

	$files = id(new PhabricatorFileQuery())
	->setViewer($this->getActor())
	->withPHIDs($phids)
	->execute();

	return mpull($files, 'getPHID');
	}

	/**
	* @task files
	*/
	protected function extractFilePHIDsFromCustomTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	return array();
	}


	/**
	* @task files
	*/
	private function attachFiles(
	PhabricatorLiskDAO $object,
	array $file_phids) {

	if (!$file_phids) {
	return;
	}

	$editor = id(new PhabricatorEdgeEditor())
	->setActor($this->getActor());

	// TODO: Edge-based events were almost certainly a terrible idea. If we
	// don't suppress this event, the Maniphest listener reenters and adds
	// more transactions. Just suppress it until that can get cleaned up.
	$editor->setSuppressEvents(true);

	$src = $object->getPHID();
	$type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_FILE;
	foreach ($file_phids as $dst) {
	$editor->addEdge($src, $type, $dst);
	}

	$editor->save();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 19:20 (1 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1127914
Default Alt Text: (85 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions