No OneTemporary
Actions

Size

300 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/applications/audit/editor/PhabricatorAuditEditor.php b/src/applications/audit/editor/PhabricatorAuditEditor.php
	index 049733f777..c39be75366 100644
	--- a/src/applications/audit/editor/PhabricatorAuditEditor.php
	+++ b/src/applications/audit/editor/PhabricatorAuditEditor.php
	@@ -1,851 +1,848 @@
	<?php

	final class PhabricatorAuditEditor
	extends PhabricatorApplicationTransactionEditor {

	const MAX_FILES_SHOWN_IN_EMAIL = 1000;

	private $affectedFiles;
	private $rawPatch;
	private $auditorPHIDs = array();

	private $didExpandInlineState = false;
	private $oldAuditStatus = null;

	public function setRawPatch($patch) {
	$this->rawPatch = $patch;
	return $this;
	}

	public function getRawPatch() {
	return $this->rawPatch;
	}

	public function getEditorApplicationClass() {
	return 'PhabricatorDiffusionApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Audits');
	}

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

	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = PhabricatorTransactions::TYPE_INLINESTATE;

	$types[] = PhabricatorAuditTransaction::TYPE_COMMIT;

	// TODO: These will get modernized eventually, but that can happen one
	// at a time later on.
	$types[] = PhabricatorAuditActionConstants::INLINE;

	return $types;
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	$this->didExpandInlineState = true;
	break;
	}
	}

	$this->oldAuditStatus = $object->getAuditStatus();

	$object->loadAndAttachAuditAuthority(
	$this->getActor(),
	$this->getActingAsPHID());

	return parent::expandTransactions($object, $xactions);
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	return $xaction->hasComment();
	}

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

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return null;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return $xaction->getNewValue();
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditActionConstants::INLINE:
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	return;
	case PhabricatorAuditActionConstants::INLINE:
	$reply = $xaction->getComment()->getReplyToComment();
	if ($reply && !$reply->getHasReplies()) {
	$reply->setHasReplies(1)->save();
	}
	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	$table = new PhabricatorAuditTransactionComment();
	$conn_w = $table->establishConnection('w');
	foreach ($xaction->getNewValue() as $phid => $state) {
	queryfx(
	$conn_w,
	'UPDATE %T SET fixedState = %s WHERE phid = %s',
	$table->getTableName(),
	$state,
	$phid);
	}
	break;
	}

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

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

	// Load auditors explicitly; we may not have them if the caller was a
	// generic piece of infrastructure.

	$commit = id(new DiffusionCommitQuery())
	->setViewer($this->requireActor())
	->withIDs(array($object->getID()))
	->needAuditRequests(true)
	->executeOne();
	if (!$commit) {
	throw new Exception(
	pht('Failed to load commit during transaction finalization!'));
	}
	$object->attachAudits($commit->getAudits());

	$status_concerned = PhabricatorAuditStatusConstants::CONCERNED;
	$status_closed = PhabricatorAuditStatusConstants::CLOSED;
	$status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
	$status_accepted = PhabricatorAuditStatusConstants::ACCEPTED;
	$status_concerned = PhabricatorAuditStatusConstants::CONCERNED;

	$actor_phid = $this->getActingAsPHID();
	$actor_is_author = ($object->getAuthorPHID()) &&
	($actor_phid == $object->getAuthorPHID());

	$import_status_flag = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$import_status_flag = PhabricatorRepositoryCommit::IMPORTED_HERALD;
	break;
	}
	}

	$old_status = $this->oldAuditStatus;

	$requests = $object->getAudits();
	$object->updateAuditStatus($requests);

	$new_status = $object->getAuditStatus();

	$object->save();

	if ($import_status_flag) {
	$object->writeImportStatusFlag($import_status_flag);
	}

	$partial_status = PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED;

	// If the commit has changed state after this edit, add an informational
	// transaction about the state change.
	if ($old_status != $new_status) {
	if ($new_status == $partial_status) {
	// This state isn't interesting enough to get a transaction. The
	// best way we could lead the user forward is something like "This
	// commit still requires additional audits." but that's redundant and
	// probably not very useful.
	} else {
	$xaction = $object->getApplicationTransactionTemplate()
	->setTransactionType(DiffusionCommitStateTransaction::TRANSACTIONTYPE)
	->setOldValue($old_status)
	->setNewValue($new_status);

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

	$xaction->save();
	}
	}

	// Collect auditor PHIDs for building mail.
	$this->auditorPHIDs = mpull($object->getAudits(), 'getAuditorPHID');

	return $xactions;
	}

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

	$xactions = parent::expandTransaction($object, $xaction);
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$request = $this->createAuditRequestTransactionFromCommitMessage(
	$object);
	if ($request) {
	$xactions[] = $request;
	$this->setUnmentionablePHIDMap($request->getNewValue());
	}
	break;
	default:
	break;
	}

	if (!$this->didExpandInlineState) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	$this->didExpandInlineState = true;

	$actor_phid = $this->getActingAsPHID();
	$actor_is_author = ($object->getAuthorPHID() == $actor_phid);
	if (!$actor_is_author) {
	break;
	}

	$state_map = PhabricatorTransactions::getInlineStateMap();

	$inlines = id(new DiffusionDiffInlineCommentQuery())
	->setViewer($this->getActor())
	->withCommitPHIDs(array($object->getPHID()))
	->withFixedStates(array_keys($state_map))
	->execute();

	if (!$inlines) {
	break;
	}

	$old_value = mpull($inlines, 'getFixedState', 'getPHID');
	$new_value = array();
	foreach ($old_value as $key => $state) {
	$new_value[$key] = $state_map[$state];
	}

	$xactions[] = id(new PhabricatorAuditTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_INLINESTATE)
	->setIgnoreOnNoEffect(true)
	->setOldValue($old_value)
	->setNewValue($new_value);
	break;
	}
	}

	return $xactions;
	}

	private function createAuditRequestTransactionFromCommitMessage(
	PhabricatorRepositoryCommit $commit) {

	$actor = $this->getActor();
	$data = $commit->getCommitData();
	$message = $data->getCommitMessage();

	$result = DifferentialCommitMessageParser::newStandardParser($actor)
	->setRaiseMissingFieldErrors(false)
	->parseFields($message);

	$field_key = DifferentialAuditorsCommitMessageField::FIELDKEY;
	$phids = idx($result, $field_key, null);

	if (!$phids) {
	return array();
	}

	// If a commit lists its author as an auditor, just pretend it does not.
	foreach ($phids as $key => $phid) {
	if ($phid == $commit->getAuthorPHID()) {
	unset($phids[$key]);
	}
	}

	if (!$phids) {
	return array();
	}

	return $commit->getApplicationTransactionTemplate()
	->setTransactionType(DiffusionCommitAuditorsTransaction::TRANSACTIONTYPE)
	->setNewValue(
	array(
	'+' => array_fuse($phids),
	));
	}

	protected function sortTransactions(array $xactions) {
	$xactions = parent::sortTransactions($xactions);

	$head = array();
	$tail = array();

	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	if ($type == PhabricatorAuditActionConstants::INLINE) {
	$tail[] = $xaction;
	} else {
	$head[] = $xaction;
	}
	}

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

	protected function supportsSearch() {
	return true;
	}

	protected function expandCustomRemarkupBlockTransactions(
	PhabricatorLiskDAO $object,
	array $xactions,
	array $changes,
	PhutilMarkupEngine $engine) {

	$actor = $this->getActor();
	$result = array();

	// Some interactions (like "Fixes Txxx" interacting with Maniphest) have
	// already been processed, so we're only re-parsing them here to avoid
	// generating an extra redundant mention. Other interactions are being
	// processed for the first time.

	// We're only recognizing magic in the commit message itself, not in
	// audit comments.

	$is_commit = false;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$is_commit = true;
	break;
	}
	}

	if (!$is_commit) {
	return $result;
	}

	$flat_blocks = mpull($changes, 'getNewValue');
	$huge_block = implode("\n\n", $flat_blocks);
	$phid_map = array();
	$phid_map[] = $this->getUnmentionablePHIDMap();
	$monograms = array();

	$task_refs = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($huge_block);
	foreach ($task_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$monograms[] = $monogram;
	}
	}

	$rev_refs = id(new DifferentialCustomFieldDependsOnParser())
	->parseCorpus($huge_block);
	foreach ($rev_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$monograms[] = $monogram;
	}
	}

	$objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getActor())
	->withNames($monograms)
	->execute();
	$phid_map[] = mpull($objects, 'getPHID', 'getPHID');


	$reverts_refs = id(new DifferentialCustomFieldRevertsParser())
	->parseCorpus($huge_block);
	$reverts = array_mergev(ipull($reverts_refs, 'monograms'));
	if ($reverts) {
	// Only allow commits to revert other commits in the same repository.
	$reverted_commits = id(new DiffusionCommitQuery())
	->setViewer($actor)
	->withRepository($object->getRepository())
	->withIdentifiers($reverts)
	->execute();

	$reverted_revisions = id(new PhabricatorObjectQuery())
	->setViewer($actor)
	->withNames($reverts)
	->withTypes(
	array(
	DifferentialRevisionPHIDType::TYPECONST,
	))
	->execute();

	$reverted_phids =
	mpull($reverted_commits, 'getPHID', 'getPHID') +
	mpull($reverted_revisions, 'getPHID', 'getPHID');

	// NOTE: Skip any write attempts if a user cleverly implies a commit
	// reverts itself, although this would be exceptionally clever in Git
	// or Mercurial.
	unset($reverted_phids[$object->getPHID()]);

	$reverts_edge = DiffusionCommitRevertsCommitEdgeType::EDGECONST;
	$result[] = id(new PhabricatorAuditTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $reverts_edge)
	->setNewValue(array('+' => $reverted_phids));

	$phid_map[] = $reverted_phids;
	}

	$phid_map = array_mergev($phid_map);
	$this->setUnmentionablePHIDMap($phid_map);

	return $result;
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	$reply_handler = new PhabricatorAuditReplyHandler();
	$reply_handler->setMailReceiver($object);
	return $reply_handler;
	}

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

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	// For backward compatibility, use this legacy thread ID.
	return 'diffusion-audit-'.$object->getPHID();
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$identifier = $object->getCommitIdentifier();
	$repository = $object->getRepository();
	- $monogram = $repository->getMonogram();

	$summary = $object->getSummary();
	$name = $repository->formatCommitName($identifier);

	$subject = "{$name}: {$summary}";
	- $thread_topic = "Commit {$monogram}{$identifier}";

	$template = id(new PhabricatorMetaMTAMail())
	- ->setSubject($subject)
	- ->addHeader('Thread-Topic', $thread_topic);
	+ ->setSubject($subject);

	$this->attachPatch(
	$template,
	$object);

	return $template;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();

	if ($object->getAuthorPHID()) {
	$phids[] = $object->getAuthorPHID();
	}

	$status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
	foreach ($object->getAudits() as $audit) {
	if (!$audit->isInteresting()) {
	// Don't send mail to uninteresting auditors, like packages which
	// own this code but which audits have not triggered for.
	continue;
	}

	if ($audit->getAuditStatus() != $status_resigned) {
	$phids[] = $audit->getAuditorPHID();
	}
	}

	$phids[] = $this->getActingAsPHID();

	return $phids;
	}

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

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

	$type_inline = PhabricatorAuditActionConstants::INLINE;
	$type_push = PhabricatorAuditTransaction::TYPE_COMMIT;

	$is_commit = false;
	$inlines = array();
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_inline) {
	$inlines[] = $xaction;
	}
	if ($xaction->getTransactionType() == $type_push) {
	$is_commit = true;
	}
	}

	if ($inlines) {
	$body->addTextSection(
	pht('INLINE COMMENTS'),
	$this->renderInlineCommentsForMail($object, $inlines));
	}

	if ($is_commit) {
	$data = $object->getCommitData();
	$body->addTextSection(pht('AFFECTED FILES'), $this->affectedFiles);
	$this->inlinePatch(
	$body,
	$object);
	}

	$data = $object->getCommitData();

	$user_phids = array();

	$author_phid = $object->getAuthorPHID();
	if ($author_phid) {
	$user_phids[$author_phid][] = pht('Author');
	}

	$committer_phid = $data->getCommitDetail('committerPHID');
	if ($committer_phid && ($committer_phid != $author_phid)) {
	$user_phids[$committer_phid][] = pht('Committer');
	}

	foreach ($this->auditorPHIDs as $auditor_phid) {
	$user_phids[$auditor_phid][] = pht('Auditor');
	}

	// TODO: It would be nice to show pusher here too, but that information
	// is a little tricky to get at right now.

	if ($user_phids) {
	$handle_phids = array_keys($user_phids);
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireActor())
	->withPHIDs($handle_phids)
	->execute();

	$user_info = array();
	foreach ($user_phids as $phid => $roles) {
	$user_info[] = pht(
	'%s (%s)',
	$handles[$phid]->getName(),
	implode(', ', $roles));
	}

	$body->addTextSection(
	pht('USERS'),
	implode("\n", $user_info));
	}

	$monogram = $object->getRepository()->formatCommitName(
	$object->getCommitIdentifier());

	$body->addLinkSection(
	pht('COMMIT'),
	PhabricatorEnv::getProductionURI('/'.$monogram));

	return $body;
	}

	private function attachPatch(
	PhabricatorMetaMTAMail $template,
	PhabricatorRepositoryCommit $commit) {

	if (!$this->getRawPatch()) {
	return;
	}

	$attach_key = 'metamta.diffusion.attach-patches';
	$attach_patches = PhabricatorEnv::getEnvConfig($attach_key);
	if (!$attach_patches) {
	return;
	}

	$repository = $commit->getRepository();
	$encoding = $repository->getDetail('encoding', 'UTF-8');

	$raw_patch = $this->getRawPatch();
	$commit_name = $repository->formatCommitName(
	$commit->getCommitIdentifier());

	$template->addAttachment(
	new PhabricatorMetaMTAAttachment(
	$raw_patch,
	$commit_name.'.patch',
	'text/x-patch; charset='.$encoding));
	}

	private function inlinePatch(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorRepositoryCommit $commit) {

	if (!$this->getRawPatch()) {
	return;
	}

	$inline_key = 'metamta.diffusion.inline-patches';
	$inline_patches = PhabricatorEnv::getEnvConfig($inline_key);
	if (!$inline_patches) {
	return;
	}

	$repository = $commit->getRepository();
	$raw_patch = $this->getRawPatch();
	$result = null;
	$len = substr_count($raw_patch, "\n");
	if ($len <= $inline_patches) {
	// We send email as utf8, so we need to convert the text to utf8 if
	// we can.
	$encoding = $repository->getDetail('encoding', 'UTF-8');
	if ($encoding) {
	$raw_patch = phutil_utf8_convert($raw_patch, 'UTF-8', $encoding);
	}
	$result = phutil_utf8ize($raw_patch);
	}

	if ($result) {
	$result = "PATCH\n\n{$result}\n";
	}
	$body->addRawSection($result);
	}

	private function renderInlineCommentsForMail(
	PhabricatorLiskDAO $object,
	array $inline_xactions) {

	$inlines = mpull($inline_xactions, 'getComment');

	$block = array();

	$path_map = id(new DiffusionPathQuery())
	->withPathIDs(mpull($inlines, 'getPathID'))
	->execute();
	$path_map = ipull($path_map, 'path', 'id');

	foreach ($inlines as $inline) {
	$path = idx($path_map, $inline->getPathID());
	if ($path === null) {
	continue;
	}

	$start = $inline->getLineNumber();
	$len = $inline->getLineLength();
	if ($len) {
	$range = $start.'-'.($start + $len);
	} else {
	$range = $start;
	}

	$content = $inline->getContent();
	$block[] = "{$path}:{$range} {$content}";
	}

	return implode("\n", $block);
	}

	public function getMailTagsMap() {
	return array(
	PhabricatorAuditTransaction::MAILTAG_COMMIT =>
	pht('A commit is created.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_CONCERN =>
	pht('A commit has a concerned raised against it.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_ACCEPT =>
	pht('A commit is accepted.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_RESIGN =>
	pht('A commit has an auditor resign.'),
	PhabricatorAuditTransaction::MAILTAG_ACTION_CLOSE =>
	pht('A commit is closed.'),
	PhabricatorAuditTransaction::MAILTAG_ADD_AUDITORS =>
	pht('A commit has auditors added.'),
	PhabricatorAuditTransaction::MAILTAG_ADD_CCS =>
	pht("A commit's subscribers change."),
	PhabricatorAuditTransaction::MAILTAG_PROJECTS =>
	pht("A commit's projects change."),
	PhabricatorAuditTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a commit.'),
	PhabricatorAuditTransaction::MAILTAG_OTHER =>
	pht('Other commit activity not listed above occurs.'),
	);
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuditTransaction::TYPE_COMMIT:
	$repository = $object->getRepository();
	if (!$repository->shouldPublish()) {
	return false;
	}
	return true;
	default:
	break;
	}
	}
	return parent::shouldApplyHeraldRules($object, $xactions);
	}

	protected function buildHeraldAdapter(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return id(new HeraldCommitAdapter())
	->setObject($object);
	}

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

	$limit = self::MAX_FILES_SHOWN_IN_EMAIL;
	$files = $adapter->loadAffectedPaths();
	sort($files);
	if (count($files) > $limit) {
	array_splice($files, $limit);
	$files[] = pht(
	'(This commit affected more than %d files. Only %d are shown here '.
	'and additional ones are truncated.)',
	$limit,
	$limit);
	}
	$this->affectedFiles = implode("\n", $files);

	return array();
	}

	private function isCommitMostlyImported(PhabricatorLiskDAO $object) {
	$has_message = PhabricatorRepositoryCommit::IMPORTED_MESSAGE;
	$has_changes = PhabricatorRepositoryCommit::IMPORTED_CHANGE;

	// Don't publish feed stories or email about events which occur during
	// import. In particular, this affects tasks being attached when they are
	// closed by "Fixes Txxxx" in a commit message. See T5851.

	$mask = ($has_message \| $has_changes);

	return $object->isPartiallyImported($mask);
	}


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

	// not every code path loads the repository so tread carefully
	// TODO: They should, and then we should simplify this.
	$repository = $object->getRepository($assert_attached = false);
	if ($repository != PhabricatorLiskDAO::ATTACHABLE) {
	if (!$repository->shouldPublish()) {
	return false;
	}
	}

	return $this->isCommitMostlyImported($object);
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

	protected function shouldEnableMentions(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldPublishRepositoryActivity($object, $xactions);
	}

	protected function getCustomWorkerState() {
	return array(
	'rawPatch' => $this->rawPatch,
	'affectedFiles' => $this->affectedFiles,
	'auditorPHIDs' => $this->auditorPHIDs,
	);
	}

	protected function getCustomWorkerStateEncoding() {
	return array(
	'rawPatch' => self::STORAGE_ENCODING_BINARY,
	);
	}

	protected function loadCustomWorkerState(array $state) {
	$this->rawPatch = idx($state, 'rawPatch');
	$this->affectedFiles = idx($state, 'affectedFiles');
	$this->auditorPHIDs = idx($state, 'auditorPHIDs');
	return $this;
	}

	protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
	return id(new DiffusionCommitQuery())
	->setViewer($this->requireActor())
	->withIDs(array($object->getID()))
	->needAuditRequests(true)
	->needCommitData(true)
	->executeOne();
	}

	}
	diff --git a/src/applications/auth/editor/PhabricatorAuthSSHKeyEditor.php b/src/applications/auth/editor/PhabricatorAuthSSHKeyEditor.php
	index 569c37403b..3f178c9855 100644
	--- a/src/applications/auth/editor/PhabricatorAuthSSHKeyEditor.php
	+++ b/src/applications/auth/editor/PhabricatorAuthSSHKeyEditor.php
	@@ -1,307 +1,305 @@
	<?php

	final class PhabricatorAuthSSHKeyEditor
	extends PhabricatorApplicationTransactionEditor {

	private $isAdministrativeEdit;

	public function setIsAdministrativeEdit($is_administrative_edit) {
	$this->isAdministrativeEdit = $is_administrative_edit;
	return $this;
	}

	public function getIsAdministrativeEdit() {
	return $this->isAdministrativeEdit;
	}

	public function getEditorApplicationClass() {
	return 'PhabricatorAuthApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('SSH Keys');
	}

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

	$types[] = PhabricatorAuthSSHKeyTransaction::TYPE_NAME;
	$types[] = PhabricatorAuthSSHKeyTransaction::TYPE_KEY;
	$types[] = PhabricatorAuthSSHKeyTransaction::TYPE_DEACTIVATE;

	return $types;
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuthSSHKeyTransaction::TYPE_NAME:
	return $object->getName();
	case PhabricatorAuthSSHKeyTransaction::TYPE_KEY:
	return $object->getEntireKey();
	case PhabricatorAuthSSHKeyTransaction::TYPE_DEACTIVATE:
	return !$object->getIsActive();
	}

	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorAuthSSHKeyTransaction::TYPE_NAME:
	case PhabricatorAuthSSHKeyTransaction::TYPE_KEY:
	return $xaction->getNewValue();
	case PhabricatorAuthSSHKeyTransaction::TYPE_DEACTIVATE:
	return (bool)$xaction->getNewValue();
	}
	}

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

	$value = $xaction->getNewValue();
	switch ($xaction->getTransactionType()) {
	case PhabricatorAuthSSHKeyTransaction::TYPE_NAME:
	$object->setName($value);
	return;
	case PhabricatorAuthSSHKeyTransaction::TYPE_KEY:
	$public_key = PhabricatorAuthSSHPublicKey::newFromRawKey($value);

	$type = $public_key->getType();
	$body = $public_key->getBody();
	$comment = $public_key->getComment();

	$object->setKeyType($type);
	$object->setKeyBody($body);
	$object->setKeyComment($comment);
	return;
	case PhabricatorAuthSSHKeyTransaction::TYPE_DEACTIVATE:
	if ($value) {
	$new = null;
	} else {
	$new = 1;
	}

	$object->setIsActive($new);
	return;
	}
	}

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

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

	$errors = parent::validateTransaction($object, $type, $xactions);
	$viewer = $this->requireActor();

	switch ($type) {
	case PhabricatorAuthSSHKeyTransaction::TYPE_NAME:
	$missing = $this->validateIsEmptyTextField(
	$object->getName(),
	$xactions);

	if ($missing) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Required'),
	pht('SSH key name is required.'),
	nonempty(last($xactions), null));

	$error->setIsMissingFieldError(true);
	$errors[] = $error;
	}
	break;

	case PhabricatorAuthSSHKeyTransaction::TYPE_KEY;
	$missing = $this->validateIsEmptyTextField(
	$object->getName(),
	$xactions);

	if ($missing) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Required'),
	pht('SSH key material is required.'),
	nonempty(last($xactions), null));

	$error->setIsMissingFieldError(true);
	$errors[] = $error;
	} else {
	foreach ($xactions as $xaction) {
	$new = $xaction->getNewValue();

	try {
	$public_key = PhabricatorAuthSSHPublicKey::newFromRawKey($new);
	} catch (Exception $ex) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	$ex->getMessage(),
	$xaction);
	continue;
	}

	// The database does not have a unique key on just the <keyBody>
	// column because we allow multiple accounts to revoke the same
	// key, so we can't rely on database constraints to prevent users
	// from adding keys that are on the revocation list back to their
	// accounts. Explicitly check for a revoked copy of the key.

	$revoked_keys = id(new PhabricatorAuthSSHKeyQuery())
	->setViewer($viewer)
	->withObjectPHIDs(array($object->getObjectPHID()))
	->withIsActive(0)
	->withKeys(array($public_key))
	->execute();
	if ($revoked_keys) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Revoked'),
	pht(
	'This key has been revoked. Choose or generate a new, '.
	'unique key.'),
	$xaction);
	continue;
	}
	}
	}
	break;

	case PhabricatorAuthSSHKeyTransaction::TYPE_DEACTIVATE:
	foreach ($xactions as $xaction) {
	if (!$xaction->getNewValue()) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('SSH keys can not be reactivated.'),
	$xaction);
	}
	}
	break;
	}

	return $errors;
	}

	protected function didCatchDuplicateKeyException(
	PhabricatorLiskDAO $object,
	array $xactions,
	Exception $ex) {

	$errors = array();
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	PhabricatorAuthSSHKeyTransaction::TYPE_KEY,
	pht('Duplicate'),
	pht(
	'This public key is already associated with another user or device. '.
	'Each key must unambiguously identify a single unique owner.'),
	null);

	throw new PhabricatorApplicationTransactionValidationException($errors);
	}


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

	protected function getMailSubjectPrefix() {
	return pht('[SSH Key]');
	}

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	return 'ssh-key-'.$object->getPHID();
	}

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

	// After making any change to an SSH key, drop the authfile cache so it
	// is regenerated the next time anyone authenticates.
	PhabricatorAuthSSHKeyQuery::deleteSSHKeyCache();

	return $xactions;
	}


	protected function getMailTo(PhabricatorLiskDAO $object) {
	return $object->getObject()->getSSHKeyNotifyPHIDs();
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	return array();
	}

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$name = $object->getName();
	- $phid = $object->getPHID();

	$mail = id(new PhabricatorMetaMTAMail())
	- ->setSubject(pht('SSH Key %d: %s', $id, $name))
	- ->addHeader('Thread-Topic', $phid);
	+ ->setSubject(pht('SSH Key %d: %s', $id, $name));

	// The primary value of this mail is alerting users to account compromises,
	// so force delivery. In particular, this mail should still be delivered
	// even if "self mail" is disabled.
	$mail->setForceDelivery(true);

	return $mail;
	}

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

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

	if (!$this->getIsAdministrativeEdit()) {
	$body->addTextSection(
	pht('SECURITY WARNING'),
	pht(
	'If you do not recognize this change, it may indicate your account '.
	'has been compromised.'));
	}

	$detail_uri = $object->getURI();
	$detail_uri = PhabricatorEnv::getProductionURI($detail_uri);

	$body->addLinkSection(pht('SSH KEY DETAIL'), $detail_uri);

	return $body;
	}


	protected function getCustomWorkerState() {
	return array(
	'isAdministrativeEdit' => $this->isAdministrativeEdit,
	);
	}

	protected function loadCustomWorkerState(array $state) {
	$this->isAdministrativeEdit = idx($state, 'isAdministrativeEdit');
	return $this;
	}


	}
	diff --git a/src/applications/badges/editor/PhabricatorBadgesEditor.php b/src/applications/badges/editor/PhabricatorBadgesEditor.php
	index fddc55747c..785d8c989b 100644
	--- a/src/applications/badges/editor/PhabricatorBadgesEditor.php
	+++ b/src/applications/badges/editor/PhabricatorBadgesEditor.php
	@@ -1,162 +1,160 @@
	<?php

	final class PhabricatorBadgesEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorBadgesApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Badges');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this badge.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

	protected function supportsSearch() {
	return true;
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();
	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;

	return $types;
	}

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

	public function getMailTagsMap() {
	return array(
	PhabricatorBadgesTransaction::MAILTAG_DETAILS =>
	pht('Someone changes the badge\'s details.'),
	PhabricatorBadgesTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a badge.'),
	PhabricatorBadgesTransaction::MAILTAG_OTHER =>
	pht('Other badge activity not listed above occurs.'),
	);
	}

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

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

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

	$results = parent::expandTransactions($object, $xactions);

	// Automatically subscribe the author when they create a badge.
	if ($this->getIsNewObject()) {
	if ($actor_phid) {
	$results[] = id(new PhabricatorBadgesTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(
	array(
	'+' => array($actor_phid => $actor_phid),
	));
	}
	}

	return $results;
	}

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$name = $object->getName();
	$id = $object->getID();
	- $topic = pht('Badge %d', $id);
	$subject = pht('Badge %d: %s', $id, $name);

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

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getCreatorPHID(),
	$this->requireActor()->getPHID(),
	);
	}

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

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

	$body->addLinkSection(
	pht('BADGE DETAIL'),
	PhabricatorEnv::getProductionURI('/badges/view/'.$object->getID().'/'));
	return $body;
	}

	protected function getMailSubjectPrefix() {
	return pht('[Badge]');
	}

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

	$badge_phid = $object->getPHID();
	$user_phids = array();
	$clear_everything = false;

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorBadgesBadgeAwardTransaction::TRANSACTIONTYPE:
	case PhabricatorBadgesBadgeRevokeTransaction::TRANSACTIONTYPE:
	foreach ($xaction->getNewValue() as $user_phid) {
	$user_phids[] = $user_phid;
	}
	break;
	default:
	$clear_everything = true;
	break;
	}
	}

	if ($clear_everything) {
	$awards = id(new PhabricatorBadgesAwardQuery())
	->setViewer($this->getActor())
	->withBadgePHIDs(array($badge_phid))
	->execute();
	foreach ($awards as $award) {
	$user_phids[] = $award->getRecipientPHID();
	}
	}

	if ($user_phids) {
	PhabricatorUserCache::clearCaches(
	PhabricatorUserBadgesCacheType::KEY_BADGES,
	$user_phids);
	}

	return $xactions;
	}

	}
	diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	index 4ab13fd360..f1b72dc0ea 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	@@ -1,377 +1,375 @@
	<?php

	final class PhabricatorCalendarEventEditor
	extends PhabricatorApplicationTransactionEditor {

	private $oldIsAllDay;
	private $newIsAllDay;

	public function getEditorApplicationClass() {
	return 'PhabricatorCalendarApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Calendar');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this event.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

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

	public function getOldIsAllDay() {
	return $this->oldIsAllDay;
	}

	public function getNewIsAllDay() {
	return $this->newIsAllDay;
	}

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

	$actor = $this->requireActor();
	if ($object->getIsStub()) {
	$this->materializeStub($object);
	}

	// Before doing anything, figure out if the event will be an all day event
	// or not after the edit. This affects how we store datetime values, and
	// whether we render times or not.
	$old_allday = $object->getIsAllDay();
	$new_allday = $old_allday;
	$type_allday = PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() != $type_allday) {
	continue;
	}
	$new_allday = (bool)$xaction->getNewValue();
	}

	$this->oldIsAllDay = $old_allday;
	$this->newIsAllDay = $new_allday;
	}

	private function materializeStub(PhabricatorCalendarEvent $event) {
	if (!$event->getIsStub()) {
	throw new Exception(
	pht('Can not materialize an event stub: this event is not a stub.'));
	}

	$actor = $this->getActor();

	$invitees = $event->getInvitees();

	$event->copyFromParent($actor);
	$event->setIsStub(0);

	$event->openTransaction();
	$event->save();
	foreach ($invitees as $invitee) {
	$invitee
	->setEventPHID($event->getPHID())
	->save();
	}
	$event->saveTransaction();

	$event->attachInvitees($invitees);
	}

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

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

	return $types;
	}

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

	$copy = parent::adjustObjectForPolicyChecks($object, $xactions);
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventHostTransaction::TRANSACTIONTYPE:
	$copy->setHostPHID($xaction->getNewValue());
	break;
	case PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE:
	PhabricatorPolicyRule::passTransactionHintToRule(
	$copy,
	new PhabricatorCalendarEventInviteesPolicyRule(),
	array_fuse($xaction->getNewValue()));
	break;
	}
	}

	return $copy;
	}


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

	// Clear the availability caches for users whose availability is affected
	// by this edit.

	$phids = mpull($object->getInvitees(), 'getInviteePHID');
	$phids = array_fuse($phids);

	$invalidate_all = false;
	$invalidate_phids = array();
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventCancelTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE:
	// For these kinds of changes, we need to invalidate the availabilty
	// caches for all attendees.
	$invalidate_all = true;
	break;
	case PhabricatorCalendarEventAcceptTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventDeclineTransaction::TRANSACTIONTYPE:
	$acting_phid = $this->getActingAsPHID();
	$invalidate_phids[$acting_phid] = $acting_phid;
	break;
	case PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE:
	foreach ($xaction->getOldValue() as $phid) {
	// Add the possibly un-invited user to the list of potentially
	// affected users if they are't already present.
	$phids[$phid] = $phid;

	$invalidate_phids[$phid] = $phid;
	}

	foreach ($xaction->getNewValue() as $phid) {
	$invalidate_phids[$phid] = $phid;
	}
	break;
	}
	}

	if (!$invalidate_all) {
	$phids = array_select_keys($phids, $invalidate_phids);
	}

	if ($phids) {
	$object->applyViewerTimezone($this->getActor());

	$user = new PhabricatorUser();
	$conn_w = $user->establishConnection('w');
	queryfx(
	$conn_w,
	'UPDATE %T SET availabilityCacheTTL = NULL
	WHERE phid IN (%Ls)',
	$user->getTableName(),
	$phids);
	}

	return $xactions;
	}


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

	$start_date_xaction =
	PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE;
	$end_date_xaction =
	PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE;
	$is_recurrence_xaction =
	PhabricatorCalendarEventRecurringTransaction::TRANSACTIONTYPE;
	$recurrence_end_xaction =
	PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE;

	$start_date = $object->getStartDateTimeEpoch();
	$end_date = $object->getEndDateTimeEpoch();
	$recurrence_end = $object->getUntilDateTimeEpoch();
	$is_recurring = $object->getIsRecurring();

	$errors = array();

	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $start_date_xaction) {
	$start_date = $xaction->getNewValue()->getEpoch();
	} else if ($xaction->getTransactionType() == $end_date_xaction) {
	$end_date = $xaction->getNewValue()->getEpoch();
	} else if ($xaction->getTransactionType() == $recurrence_end_xaction) {
	$recurrence_end = $xaction->getNewValue()->getEpoch();
	} else if ($xaction->getTransactionType() == $is_recurrence_xaction) {
	$is_recurring = $xaction->getNewValue();
	}
	}

	if ($start_date > $end_date) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$end_date_xaction,
	pht('Invalid'),
	pht('End date must be after start date.'),
	null);
	}

	if ($recurrence_end && !$is_recurring) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$recurrence_end_xaction,
	pht('Invalid'),
	pht('Event must be recurring to have a recurrence end date.').
	null);
	}

	return $errors;
	}

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

	if ($object->isImportedEvent()) {
	return false;
	}

	return true;
	}

	protected function supportsSearch() {
	return true;
	}

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

	if ($object->isImportedEvent()) {
	return false;
	}

	return true;
	}

	protected function getMailSubjectPrefix() {
	return pht('[Calendar]');
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();

	if ($object->getHostPHID()) {
	$phids[] = $object->getHostPHID();
	}
	$phids[] = $this->getActingAsPHID();

	$invitees = $object->getInvitees();
	foreach ($invitees as $invitee) {
	$status = $invitee->getStatus();
	if ($status === PhabricatorCalendarEventInvitee::STATUS_ATTENDING
	\|\| $status === PhabricatorCalendarEventInvitee::STATUS_INVITED) {
	$phids[] = $invitee->getInviteePHID();
	}
	}

	$phids = array_unique($phids);

	return $phids;
	}

	public function getMailTagsMap() {
	return array(
	PhabricatorCalendarEventTransaction::MAILTAG_CONTENT =>
	pht(
	"An event's name, status, invite list, ".
	"icon, and description changes."),
	PhabricatorCalendarEventTransaction::MAILTAG_RESCHEDULE =>
	pht(
	"An event's start and end date ".
	"and cancellation status changes."),
	PhabricatorCalendarEventTransaction::MAILTAG_OTHER =>
	pht('Other event activity not listed above occurs.'),
	);
	}

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	- $id = $object->getID();
	$name = $object->getName();
	$monogram = $object->getMonogram();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("{$monogram}: {$name}")
	- ->addHeader('Thread-Topic', $monogram);
	+ ->setSubject("{$monogram}: {$name}");
	}

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

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

	$description = $object->getDescription();
	if ($this->getIsNewObject()) {
	if (strlen($description)) {
	$body->addRemarkupSection(
	pht('EVENT DESCRIPTION'),
	$description);
	}
	}

	$body->addLinkSection(
	pht('EVENT DETAIL'),
	PhabricatorEnv::getProductionURI($object->getURI()));

	$ics_attachment = $this->newICSAttachment($object);
	$body->addAttachment($ics_attachment);

	return $body;
	}

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

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

	return id(new PhabricatorCalendarEventHeraldAdapter())
	->setObject($object);
	}

	private function newICSAttachment(
	PhabricatorCalendarEvent $event) {
	$actor = $this->getActor();

	$ics_data = id(new PhabricatorCalendarICSWriter())
	->setViewer($actor)
	->setEvents(array($event))
	->writeICSDocument();

	$ics_attachment = new PhabricatorMetaMTAAttachment(
	$ics_data,
	$event->getICSFilename(),
	'text/calendar');

	return $ics_attachment;
	}

	}
	diff --git a/src/applications/conpherence/editor/ConpherenceEditor.php b/src/applications/conpherence/editor/ConpherenceEditor.php
	index 29ffc22251..7896055f64 100644
	--- a/src/applications/conpherence/editor/ConpherenceEditor.php
	+++ b/src/applications/conpherence/editor/ConpherenceEditor.php
	@@ -1,312 +1,310 @@
	<?php

	final class ConpherenceEditor extends PhabricatorApplicationTransactionEditor {

	const ERROR_EMPTY_PARTICIPANTS = 'error-empty-participants';
	const ERROR_EMPTY_MESSAGE = 'error-empty-message';

	public function getEditorApplicationClass() {
	return 'PhabricatorConpherenceApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Conpherence Rooms');
	}

	public static function createThread(
	PhabricatorUser $creator,
	array $participant_phids,
	$title,
	$message,
	PhabricatorContentSource $source,
	$topic) {

	$conpherence = ConpherenceThread::initializeNewRoom($creator);
	$errors = array();
	if (empty($participant_phids)) {
	$errors[] = self::ERROR_EMPTY_PARTICIPANTS;
	} else {
	$participant_phids[] = $creator->getPHID();
	$participant_phids = array_unique($participant_phids);
	}

	if (empty($message)) {
	$errors[] = self::ERROR_EMPTY_MESSAGE;
	}

	if (!$errors) {
	$xactions = array();
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(
	ConpherenceThreadParticipantsTransaction::TRANSACTIONTYPE)
	->setNewValue(array('+' => $participant_phids));
	if ($title) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(
	ConpherenceThreadTitleTransaction::TRANSACTIONTYPE)
	->setNewValue($title);
	}
	if (strlen($topic)) {
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(
	ConpherenceThreadTopicTransaction::TRANSACTIONTYPE)
	->setNewValue($topic);
	}

	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new ConpherenceTransactionComment())
	->setContent($message)
	->setConpherencePHID($conpherence->getPHID()));

	id(new ConpherenceEditor())
	->setActor($creator)
	->setContentSource($source)
	->setContinueOnNoEffect(true)
	->applyTransactions($conpherence, $xactions);
	}

	return array($errors, $conpherence);
	}

	public function generateTransactionsFromText(
	PhabricatorUser $viewer,
	ConpherenceThread $conpherence,
	$text) {

	$xactions = array();
	$xactions[] = id(new ConpherenceTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
	->attachComment(
	id(new ConpherenceTransactionComment())
	->setContent($text)
	->setConpherencePHID($conpherence->getPHID()));
	return $xactions;
	}

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

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

	return $types;
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this room.', $author);
	}

	/**
	* We really only need a read lock if we have a comment. In that case, we
	* must update the messagesCount field on the conpherence and
	* seenMessagesCount(s) for the participant(s).
	*/
	protected function shouldReadLock(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$lock = false;
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	$lock = true;
	break;
	}

	return $lock;
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	$object->setMessageCount((int)$object->getMessageCount() + 1);
	break;
	}

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


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

	$acting_phid = $this->getActingAsPHID();
	$participants = $object->getParticipants();
	foreach ($participants as $participant) {
	if ($participant->getParticipantPHID() == $acting_phid) {
	$participant->markUpToDate($object);
	}
	}

	if ($participants) {
	PhabricatorUserCache::clearCaches(
	PhabricatorUserMessageCountCacheType::KEY_COUNT,
	array_keys($participants));
	}

	if ($xactions) {
	$data = array(
	'type' => 'message',
	'threadPHID' => $object->getPHID(),
	'messageID' => last($xactions)->getID(),
	'subscribers' => array($object->getPHID()),
	);

	PhabricatorNotificationClient::tryToPostMessage($data);
	}

	return $xactions;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case ConpherenceThreadParticipantsTransaction::TRANSACTIONTYPE:
	$old_map = array_fuse($xaction->getOldValue());
	$new_map = array_fuse($xaction->getNewValue());

	$add = array_keys(array_diff_key($new_map, $old_map));
	$rem = array_keys(array_diff_key($old_map, $new_map));

	$actor_phid = $this->getActingAsPHID();

	$is_join = (($add === array($actor_phid)) && !$rem);
	$is_leave = (($rem === array($actor_phid)) && !$add);

	if ($is_join) {
	// Anyone can join a thread they can see.
	} else if ($is_leave) {
	// Anyone can leave a thread.
	} else {
	// You need CAN_EDIT to add or remove participants. For additional
	// discussion, see D17696 and T4411.
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	}
	break;

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

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

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	return id(new ConpherenceReplyHandler())
	->setActor($this->getActor())
	->setMailReceiver($object);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$title = $object->getTitle();
	if (!$title) {
	$title = pht(
	'%s sent you a message.',
	$this->getActor()->getUserName());
	}
	- $phid = $object->getPHID();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("Z{$id}: {$title}")
	- ->addHeader('Thread-Topic', "Z{$id}: {$phid}");
	+ ->setSubject("Z{$id}: {$title}");
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$to_phids = array();

	$participants = $object->getParticipants();
	if (!$participants) {
	return $to_phids;
	}

	$participant_phids = mpull($participants, 'getParticipantPHID');

	$users = id(new PhabricatorPeopleQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($participant_phids)
	->needUserSettings(true)
	->execute();
	$users = mpull($users, null, 'getPHID');

	$notification_key = PhabricatorConpherenceNotificationsSetting::SETTINGKEY;
	$notification_email =
	PhabricatorConpherenceNotificationsSetting::VALUE_CONPHERENCE_EMAIL;

	foreach ($participants as $phid => $participant) {
	$user = idx($users, $phid);
	if ($user) {
	$default = $user->getUserSetting($notification_key);
	} else {
	$default = $notification_email;
	}

	$settings = $participant->getSettings();
	$notifications = idx($settings, 'notifications', $default);

	if ($notifications == $notification_email) {
	$to_phids[] = $phid;
	}
	}

	return $to_phids;
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	return array();
	}

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

	$body = parent::buildMailBody($object, $xactions);
	$body->addLinkSection(
	pht('CONPHERENCE DETAIL'),
	PhabricatorEnv::getProductionURI('/'.$object->getMonogram()));

	return $body;
	}

	protected function addEmailPreferenceSectionToMailBody(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorLiskDAO $object,
	array $xactions) {

	$href = PhabricatorEnv::getProductionURI(
	'/'.$object->getMonogram().'?settings');
	$label = pht('EMAIL PREFERENCES FOR THIS ROOM');
	$body->addLinkSection($label, $href);
	}

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

	protected function supportsSearch() {
	return true;
	}

	}
	diff --git a/src/applications/countdown/editor/PhabricatorCountdownEditor.php b/src/applications/countdown/editor/PhabricatorCountdownEditor.php
	index 322b2ee2c3..2102b3785b 100644
	--- a/src/applications/countdown/editor/PhabricatorCountdownEditor.php
	+++ b/src/applications/countdown/editor/PhabricatorCountdownEditor.php
	@@ -1,97 +1,96 @@
	<?php

	final class PhabricatorCountdownEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorCountdownApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Countdown');
	}

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

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

	return $types;
	}

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

	public function getMailTagsMap() {
	return array(
	PhabricatorCountdownTransaction::MAILTAG_DETAILS =>
	pht('Someone changes the countdown details.'),
	PhabricatorCountdownTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a countdown.'),
	PhabricatorCountdownTransaction::MAILTAG_OTHER =>
	pht('Other countdown activity not listed above occurs.'),
	);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$monogram = $object->getMonogram();
	$name = $object->getTitle();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("{$monogram}: {$name}")
	- ->addHeader('Thread-Topic', $monogram);
	+ ->setSubject("{$monogram}: {$name}");
	}

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

	$body = parent::buildMailBody($object, $xactions);
	$description = $object->getDescription();

	if (strlen($description)) {
	$body->addRemarkupSection(
	pht('COUNTDOWN DESCRIPTION'),
	$object->getDescription());
	}

	$body->addLinkSection(
	pht('COUNTDOWN DETAIL'),
	PhabricatorEnv::getProductionURI('/'.$object->getMonogram()));

	return $body;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getAuthorPHID(),
	$this->requireActor()->getPHID(),
	);
	}
	protected function getMailSubjectPrefix() {
	return '[Countdown]';
	}

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

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

	protected function supportsSearch() {
	return true;
	}

	}
	diff --git a/src/applications/differential/editor/DifferentialTransactionEditor.php b/src/applications/differential/editor/DifferentialTransactionEditor.php
	index 3a1537b01d..f3583438c8 100644
	--- a/src/applications/differential/editor/DifferentialTransactionEditor.php
	+++ b/src/applications/differential/editor/DifferentialTransactionEditor.php
	@@ -1,1733 +1,1728 @@
	<?php

	final class DifferentialTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	private $changedPriorToCommitURI;
	private $isCloseByCommit;
	private $repositoryPHIDOverride = false;
	private $didExpandInlineState = false;
	private $hasReviewTransaction = false;
	private $affectedPaths;
	private $firstBroadcast = false;
	private $wasDraft = false;

	public function getEditorApplicationClass() {
	return 'PhabricatorDifferentialApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Differential Revisions');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this revision.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

	public function isFirstBroadcast() {
	return $this->firstBroadcast;
	}

	public function getDiffUpdateTransaction(array $xactions) {
	$type_update = DifferentialTransaction::TYPE_UPDATE;

	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_update) {
	return $xaction;
	}
	}

	return null;
	}

	public function setIsCloseByCommit($is_close_by_commit) {
	$this->isCloseByCommit = $is_close_by_commit;
	return $this;
	}

	public function getIsCloseByCommit() {
	return $this->isCloseByCommit;
	}

	public function setChangedPriorToCommitURI($uri) {
	$this->changedPriorToCommitURI = $uri;
	return $this;
	}

	public function getChangedPriorToCommitURI() {
	return $this->changedPriorToCommitURI;
	}

	public function setRepositoryPHIDOverride($phid_or_null) {
	$this->repositoryPHIDOverride = $phid_or_null;
	return $this;
	}

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

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

	$types[] = DifferentialTransaction::TYPE_INLINE;
	$types[] = DifferentialTransaction::TYPE_UPDATE;

	return $types;
	}

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

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	return null;
	case DifferentialTransaction::TYPE_UPDATE:
	if ($this->getIsNewObject()) {
	return null;
	} else {
	return $object->getActiveDiff()->getPHID();
	}
	}

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

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

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	return $xaction->getNewValue();
	case DifferentialTransaction::TYPE_INLINE:
	return null;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	return;
	case DifferentialTransaction::TYPE_UPDATE:
	if (!$this->getIsCloseByCommit()) {
	if ($object->isNeedsRevision() \|\|
	$object->isChangePlanned() \|\|
	$object->isAbandoned()) {
	$object->setModernRevisionStatus(
	DifferentialRevisionStatus::NEEDS_REVIEW);
	}
	}

	$diff = $this->requireDiff($xaction->getNewValue());

	$this->updateRevisionLineCounts($object, $diff);

	if ($this->repositoryPHIDOverride !== false) {
	$object->setRepositoryPHID($this->repositoryPHIDOverride);
	} else {
	$object->setRepositoryPHID($diff->getRepositoryPHID());
	}

	$object->attachActiveDiff($diff);
	$object->setActiveDiffPHID($diff->getPHID());
	return;
	}

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

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	// If we have an "Inline State" transaction already, the caller
	// built it for us so we don't need to expand it again.
	$this->didExpandInlineState = true;
	break;
	case DifferentialRevisionAcceptTransaction::TRANSACTIONTYPE:
	case DifferentialRevisionRejectTransaction::TRANSACTIONTYPE:
	case DifferentialRevisionResignTransaction::TRANSACTIONTYPE:
	// If we have a review transaction, we'll skip marking the user
	// as "Commented" later. This should get cleaner after T10967.
	$this->hasReviewTransaction = true;
	break;
	}
	}

	$this->wasDraft = $object->isDraft();

	return parent::expandTransactions($object, $xactions);
	}

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

	$results = parent::expandTransaction($object, $xaction);

	$actor = $this->getActor();
	$actor_phid = $this->getActingAsPHID();
	$type_edge = PhabricatorTransactions::TYPE_EDGE;

	$edge_ref_task = DifferentialRevisionHasTaskEdgeType::EDGECONST;

	$is_sticky_accept = PhabricatorEnv::getEnvConfig(
	'differential.sticky-accept');

	$downgrade_rejects = false;
	$downgrade_accepts = false;
	if ($this->getIsCloseByCommit()) {
	// Never downgrade reviewers when we're closing a revision after a
	// commit.
	} else {
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	$downgrade_rejects = true;
	if (!$is_sticky_accept) {
	// If "sticky accept" is disabled, also downgrade the accepts.
	$downgrade_accepts = true;
	}
	break;
	case DifferentialRevisionRequestReviewTransaction::TRANSACTIONTYPE:
	$downgrade_rejects = true;
	if ((!$is_sticky_accept) \|\|
	(!$object->isChangePlanned())) {
	// If the old state isn't "changes planned", downgrade the accepts.
	// This exception allows an accepted revision to go through
	// "Plan Changes" -> "Request Review" and return to "accepted" if
	// the author didn't update the revision, essentially undoing the
	// "Plan Changes".
	$downgrade_accepts = true;
	}
	break;
	}
	}

	$new_accept = DifferentialReviewerStatus::STATUS_ACCEPTED;
	$new_reject = DifferentialReviewerStatus::STATUS_REJECTED;
	$old_accept = DifferentialReviewerStatus::STATUS_ACCEPTED_OLDER;
	$old_reject = DifferentialReviewerStatus::STATUS_REJECTED_OLDER;

	$downgrade = array();
	if ($downgrade_accepts) {
	$downgrade[] = DifferentialReviewerStatus::STATUS_ACCEPTED;
	}

	if ($downgrade_rejects) {
	$downgrade[] = DifferentialReviewerStatus::STATUS_REJECTED;
	}

	if ($downgrade) {
	$void_type = DifferentialRevisionVoidTransaction::TRANSACTIONTYPE;

	$results[] = id(new DifferentialTransaction())
	->setTransactionType($void_type)
	->setIgnoreOnNoEffect(true)
	->setNewValue($downgrade);
	}

	$is_commandeer = false;
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	if ($this->getIsCloseByCommit()) {
	// Don't bother with any of this if this update is a side effect of
	// commit detection.
	break;
	}

	// When a revision is updated and the diff comes from a branch named
	// "T123" or similar, automatically associate the commit with the
	// task that the branch names.

	$maniphest = 'PhabricatorManiphestApplication';
	if (PhabricatorApplication::isClassInstalled($maniphest)) {
	$diff = $this->requireDiff($xaction->getNewValue());
	$branch = $diff->getBranch();

	// No "$", to allow for branches like T123_demo.
	$match = null;
	if (preg_match('/^T(\d+)/i', $branch, $match)) {
	$task_id = $match[1];
	$tasks = id(new ManiphestTaskQuery())
	->setViewer($this->getActor())
	->withIDs(array($task_id))
	->execute();
	if ($tasks) {
	$task = head($tasks);
	$task_phid = $task->getPHID();

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

	case DifferentialRevisionCommandeerTransaction::TRANSACTIONTYPE:
	$is_commandeer = true;
	break;
	}

	if ($is_commandeer) {
	$results[] = $this->newCommandeerReviewerTransaction($object);
	}

	if (!$this->didExpandInlineState) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COMMENT:
	case DifferentialTransaction::TYPE_UPDATE:
	case DifferentialTransaction::TYPE_INLINE:
	$this->didExpandInlineState = true;

	$actor_phid = $this->getActingAsPHID();
	$actor_is_author = ($object->getAuthorPHID() == $actor_phid);
	if (!$actor_is_author) {
	break;
	}

	$state_map = PhabricatorTransactions::getInlineStateMap();

	$inlines = id(new DifferentialDiffInlineCommentQuery())
	->setViewer($this->getActor())
	->withRevisionPHIDs(array($object->getPHID()))
	->withFixedStates(array_keys($state_map))
	->execute();

	if (!$inlines) {
	break;
	}

	$old_value = mpull($inlines, 'getFixedState', 'getPHID');
	$new_value = array();
	foreach ($old_value as $key => $state) {
	$new_value[$key] = $state_map[$state];
	}

	$results[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_INLINESTATE)
	->setIgnoreOnNoEffect(true)
	->setOldValue($old_value)
	->setNewValue($new_value);
	break;
	}
	}

	return $results;
	}

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

	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_INLINE:
	$reply = $xaction->getComment()->getReplyToComment();
	if ($reply && !$reply->getHasReplies()) {
	$reply->setHasReplies(1)->save();
	}
	return;
	case DifferentialTransaction::TYPE_UPDATE:
	// Now that we're inside the transaction, do a final check.
	$diff = $this->requireDiff($xaction->getNewValue());

	// TODO: It would be slightly cleaner to just revalidate this
	// transaction somehow using the same validation code, but that's
	// not easy to do at the moment.

	$revision_id = $diff->getRevisionID();
	if ($revision_id && ($revision_id != $object->getID())) {
	throw new Exception(
	pht(
	'Diff is already attached to another revision. You lost '.
	'a race?'));
	}

	// TODO: This can race with diff updates, particularly those from
	// Harbormaster. See discussion in T8650.
	$diff->setRevisionID($object->getID());
	$diff->save();

	// Update Harbormaster to set the containerPHID correctly for any
	// existing buildables. We may otherwise have buildables stuck with
	// the old (`null`) container.

	// TODO: This is a bit iffy, maybe we can find a cleaner approach?
	// In particular, this could (rarely) be overwritten by Harbormaster
	// workers.
	$table = new HarbormasterBuildable();
	$conn_w = $table->establishConnection('w');
	queryfx(
	$conn_w,
	'UPDATE %T SET containerPHID = %s WHERE buildablePHID = %s',
	$table->getTableName(),
	$object->getPHID(),
	$diff->getPHID());

	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_INLINESTATE:
	$table = new DifferentialTransactionComment();
	$conn_w = $table->establishConnection('w');
	foreach ($xaction->getNewValue() as $phid => $state) {
	queryfx(
	$conn_w,
	'UPDATE %T SET fixedState = %s WHERE phid = %s',
	$table->getTableName(),
	$state,
	$phid);
	}
	break;
	}

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

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

	// 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. Then, update the reviewers
	// on the object to make sure we're acting on the current reviewer set
	// (and, for example, sending mail to the right people).

	$new_revision = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->needReviewers(true)
	->needActiveDiffs(true)
	->withIDs(array($object->getID()))
	->executeOne();
	if (!$new_revision) {
	throw new Exception(
	pht('Failed to load revision from transaction finalization.'));
	}

	$object->attachReviewers($new_revision->getReviewers());
	$object->attachActiveDiff($new_revision->getActiveDiff());
	$object->attachRepository($new_revision->getRepository());

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	$diff = $this->requireDiff($xaction->getNewValue(), true);

	// Update these denormalized index tables when we attach a new
	// diff to a revision.

	$this->updateRevisionHashTable($object, $diff);
	$this->updateAffectedPathTable($object, $diff);
	break;
	}
	}

	$xactions = $this->updateReviewStatus($object, $xactions);
	$this->markReviewerComments($object, $xactions);

	return $xactions;
	}

	private function updateReviewStatus(
	DifferentialRevision $revision,
	array $xactions) {

	$was_accepted = $revision->isAccepted();
	$was_revision = $revision->isNeedsRevision();
	$was_review = $revision->isNeedsReview();
	if (!$was_accepted && !$was_revision && !$was_review) {
	// Revisions can't transition out of other statuses (like closed or
	// abandoned) as a side effect of reviewer status changes.
	return $xactions;
	}

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

	$has_accepting_user = false;
	$has_rejecting_reviewer = false;
	$has_rejecting_older_reviewer = false;
	$has_blocking_reviewer = false;

	$active_diff = $revision->getActiveDiff();
	foreach ($revision->getReviewers() as $reviewer) {
	$reviewer_status = $reviewer->getReviewerStatus();
	switch ($reviewer_status) {
	case DifferentialReviewerStatus::STATUS_REJECTED:
	$active_phid = $active_diff->getPHID();
	if ($reviewer->isRejected($active_phid)) {
	$has_rejecting_reviewer = true;
	} else {
	$has_rejecting_older_reviewer = true;
	}
	break;
	case DifferentialReviewerStatus::STATUS_REJECTED_OLDER:
	$has_rejecting_older_reviewer = true;
	break;
	case DifferentialReviewerStatus::STATUS_BLOCKING:
	$has_blocking_reviewer = true;
	break;
	case DifferentialReviewerStatus::STATUS_ACCEPTED:
	if ($reviewer->isUser()) {
	$active_phid = $active_diff->getPHID();
	if ($reviewer->isAccepted($active_phid)) {
	$has_accepting_user = true;
	}
	}
	break;
	}
	}

	$new_status = null;
	if ($has_accepting_user &&
	!$has_rejecting_reviewer &&
	!$has_rejecting_older_reviewer &&
	!$has_blocking_reviewer) {
	$new_status = DifferentialRevisionStatus::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 = DifferentialRevisionStatus::NEEDS_REVISION;
	} else if ($was_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 = DifferentialRevisionStatus::NEEDS_REVIEW;
	}

	if ($new_status === null) {
	return $xactions;
	}

	$old_status = $revision->getModernRevisionStatus();
	if ($new_status == $old_status) {
	return $xactions;
	}

	$xaction = id(new DifferentialTransaction())
	->setTransactionType(
	DifferentialRevisionStatusTransaction::TRANSACTIONTYPE)
	->setOldValue($old_status)
	->setNewValue($new_status);

	$xaction = $this->populateTransaction($revision, $xaction)
	->save();
	$xactions[] = $xaction;

	// Save the status adjustment we made earlier.
	$revision
	->setModernRevisionStatus($new_status)
	->save();

	return $xactions;
	}


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

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

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

	foreach ($xactions as $xaction) {
	switch ($type) {
	case DifferentialTransaction::TYPE_UPDATE:
	$diff = $this->loadDiff($xaction->getNewValue());
	if (!$diff) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('The specified diff does not exist.'),
	$xaction);
	} else if (($diff->getRevisionID()) &&
	($diff->getRevisionID() != $object->getID())) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'You can not update this revision to the specified diff, '.
	'because the diff is already attached to another revision.'),
	$xaction);
	}
	break;
	}
	}

	return $errors;
	}

	protected function sortTransactions(array $xactions) {
	$xactions = parent::sortTransactions($xactions);

	$head = array();
	$tail = array();

	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 shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {

	if (!$object->shouldBroadcast()) {
	return false;
	}

	return true;
	}

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

	if (!$object->shouldBroadcast()) {
	return false;
	}

	return true;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();
	$phids[] = $object->getAuthorPHID();
	foreach ($object->getReviewers() as $reviewer) {
	if ($reviewer->isResigned()) {
	continue;
	}

	$phids[] = $reviewer->getReviewerPHID();
	}
	return $phids;
	}

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

	$show_lines = false;
	if ($this->isFirstBroadcast()) {
	$action = pht('Request');

	$show_lines = true;
	} else {
	$action = parent::getMailAction($object, $xactions);

	$strongest = $this->getStrongestAction($object, $xactions);
	$type_update = DifferentialTransaction::TYPE_UPDATE;
	if ($strongest->getTransactionType() == $type_update) {
	$show_lines = true;
	}
	}

	if ($show_lines) {
	$count = new PhutilNumber($object->getLineCount());
	$action = pht('%s, %s line(s)', $action, $count);
	}

	return $action;
	}

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

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	// This is nonstandard, but retains threading with older messages.
	$phid = $object->getPHID();
	return "differential-rev-{$phid}-req";
	}

	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);
	+ ->setSubject($subject);
	}

	protected function getTransactionsForMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	// If this is the first time we're sending mail about this revision, we
	// generate mail for all prior transactions, not just whatever is being
	// applied now. This gets the "added reviewers" lines and other relevant
	// information into the mail.
	if ($this->isFirstBroadcast()) {
	return $this->loadUnbroadcastTransactions($object);
	}

	return $xactions;
	}

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

	$viewer = $this->requireActor();

	$body = new PhabricatorMetaMTAMailBody();
	$body->setViewer($this->requireActor());

	$revision_uri = PhabricatorEnv::getProductionURI('/D'.$object->getID());

	$this->addHeadersAndCommentsToMailBody(
	$body,
	$xactions,
	pht('View Revision'),
	$revision_uri);

	$type_inline = DifferentialTransaction::TYPE_INLINE;

	$inlines = array();
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_inline) {
	$inlines[] = $xaction;
	}
	}

	if ($inlines) {
	$this->appendInlineCommentsForMail($object, $inlines, $body);
	}

	$changed_uri = $this->getChangedPriorToCommitURI();
	if ($changed_uri) {
	$body->addLinkSection(
	pht('CHANGED PRIOR TO COMMIT'),
	$changed_uri);
	}

	$this->addCustomFieldsToMailBody($body, $object, $xactions);

	$body->addLinkSection(
	pht('REVISION DETAIL'),
	$revision_uri);

	$update_xaction = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case DifferentialTransaction::TYPE_UPDATE:
	$update_xaction = $xaction;
	break;
	}
	}

	if ($update_xaction) {
	$diff = $this->requireDiff($update_xaction->getNewValue(), true);

	$body->addTextSection(
	pht('AFFECTED FILES'),
	$this->renderAffectedFilesForMail($diff));

	$config_key_inline = 'metamta.differential.inline-patches';
	$config_inline = PhabricatorEnv::getEnvConfig($config_key_inline);

	$config_key_attach = 'metamta.differential.attach-patches';
	$config_attach = PhabricatorEnv::getEnvConfig($config_key_attach);

	if ($config_inline \|\| $config_attach) {
	$body_limit = PhabricatorEnv::getEnvConfig('metamta.email-body-limit');

	$patch = $this->buildPatchForMail($diff);
	if ($config_inline) {
	$lines = substr_count($patch, "\n");
	$bytes = strlen($patch);

	// Limit the patch size to the smaller of 256 bytes per line or
	// the mail body limit. This prevents degenerate behavior for patches
	// with one line that is 10MB long. See T11748.
	$byte_limits = array();
	$byte_limits[] = (256 * $config_inline);
	$byte_limits[] = $body_limit;
	$byte_limit = min($byte_limits);

	$lines_ok = ($lines <= $config_inline);
	$bytes_ok = ($bytes <= $byte_limit);

	if ($lines_ok && $bytes_ok) {
	$this->appendChangeDetailsForMail($object, $diff, $patch, $body);
	} else {
	// TODO: Provide a helpful message about the patch being too
	// large or lengthy here.
	}
	}

	if ($config_attach) {
	// See T12033, T11767, and PHI55. This is a crude fix to stop the
	// major concrete problems that lackluster email size limits cause.
	if (strlen($patch) < $body_limit) {
	$name = pht('D%s.%s.patch', $object->getID(), $diff->getID());
	$mime_type = 'text/x-patch; charset=utf-8';
	$body->addAttachment(
	new PhabricatorMetaMTAAttachment($patch, $name, $mime_type));
	}
	}
	}
	}

	return $body;
	}

	public function getMailTagsMap() {
	return array(
	DifferentialTransaction::MAILTAG_REVIEW_REQUEST =>
	pht('A revision is created.'),
	DifferentialTransaction::MAILTAG_UPDATED =>
	pht('A revision is updated.'),
	DifferentialTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a revision.'),
	DifferentialTransaction::MAILTAG_CLOSED =>
	pht('A revision is closed.'),
	DifferentialTransaction::MAILTAG_REVIEWERS =>
	pht("A revision's reviewers change."),
	DifferentialTransaction::MAILTAG_CC =>
	pht("A revision's CCs change."),
	DifferentialTransaction::MAILTAG_OTHER =>
	pht('Other revision activity not listed above occurs.'),
	);
	}

	protected function supportsSearch() {
	return true;
	}

	protected function expandCustomRemarkupBlockTransactions(
	PhabricatorLiskDAO $object,
	array $xactions,
	array $changes,
	PhutilMarkupEngine $engine) {

	// For "Fixes ..." and "Depends on ...", we're only going to look at
	// content blocks which are part of the revision itself (like "Summary"
	// and "Test Plan"), not comments.
	$content_parts = array();
	foreach ($changes as $change) {
	if ($change->getTransaction()->isCommentTransaction()) {
	continue;
	}
	$content_parts[] = $change->getNewValue();
	}
	if (!$content_parts) {
	return array();
	}
	$content_block = implode("\n\n", $content_parts);
	$task_map = array();
	$task_refs = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($content_block);
	foreach ($task_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$task_id = (int)trim($monogram, 'tT');
	$task_map[$task_id] = true;
	}
	}

	$rev_map = array();
	$rev_refs = id(new DifferentialCustomFieldDependsOnParser())
	->parseCorpus($content_block);
	foreach ($rev_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$rev_id = (int)trim($monogram, 'dD');
	$rev_map[$rev_id] = true;
	}
	}

	$edges = array();
	$task_phids = array();
	$rev_phids = array();

	if ($task_map) {
	$tasks = id(new ManiphestTaskQuery())
	->setViewer($this->getActor())
	->withIDs(array_keys($task_map))
	->execute();

	if ($tasks) {
	$task_phids = mpull($tasks, 'getPHID', 'getPHID');
	$edge_related = DifferentialRevisionHasTaskEdgeType::EDGECONST;
	$edges[$edge_related] = $task_phids;
	}
	}

	if ($rev_map) {
	$revs = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->withIDs(array_keys($rev_map))
	->execute();
	$rev_phids = mpull($revs, 'getPHID', 'getPHID');

	// NOTE: Skip any write attempts if a user cleverly implies a revision
	// depends upon itself.
	unset($rev_phids[$object->getPHID()]);

	if ($revs) {
	$depends = DifferentialRevisionDependsOnRevisionEdgeType::EDGECONST;
	$edges[$depends] = $rev_phids;
	}
	}

	$revert_refs = id(new DifferentialCustomFieldRevertsParser())
	->parseCorpus($content_block);

	$revert_monograms = array();
	foreach ($revert_refs as $match) {
	foreach ($match['monograms'] as $monogram) {
	$revert_monograms[] = $monogram;
	}
	}

	if ($revert_monograms) {
	$revert_objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getActor())
	->withNames($revert_monograms)
	->withTypes(
	array(
	DifferentialRevisionPHIDType::TYPECONST,
	PhabricatorRepositoryCommitPHIDType::TYPECONST,
	))
	->execute();

	$revert_phids = mpull($revert_objects, 'getPHID', 'getPHID');

	// Don't let an object revert itself, although other silly stuff like
	// cycles of objects reverting each other is not prevented.
	unset($revert_phids[$object->getPHID()]);

	$revert_type = DiffusionCommitRevertsCommitEdgeType::EDGECONST;
	$edges[$revert_type] = $revert_phids;
	} else {
	$revert_phids = array();
	}

	$this->setUnmentionablePHIDMap(
	array_merge(
	$task_phids,
	$rev_phids,
	$revert_phids));

	$result = array();
	foreach ($edges as $type => $specs) {
	$result[] = id(new DifferentialTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $type)
	->setNewValue(array('+' => $specs));
	}

	return $result;
	}

	private function appendInlineCommentsForMail(
	PhabricatorLiskDAO $object,
	array $inlines,
	PhabricatorMetaMTAMailBody $body) {

	$section = id(new DifferentialInlineCommentMailView())
	->setViewer($this->getActor())
	->setInlines($inlines)
	->buildMailSection();

	$header = pht('INLINE COMMENTS');

	$section_text = "\n".$section->getPlaintext();

	$style = array(
	'margin: 6px 0 12px 0;',
	);

	$section_html = phutil_tag(
	'div',
	array(
	'style' => implode(' ', $style),
	),
	$section->getHTML());

	$body->addPlaintextSection($header, $section_text, false);
	$body->addHTMLSection($header, $section_html);
	}

	private function appendChangeDetailsForMail(
	PhabricatorLiskDAO $object,
	DifferentialDiff $diff,
	$patch,
	PhabricatorMetaMTAMailBody $body) {

	$section = id(new DifferentialChangeDetailMailView())
	->setViewer($this->getActor())
	->setDiff($diff)
	->setPatch($patch)
	->buildMailSection();

	$header = pht('CHANGE DETAILS');

	$section_text = "\n".$section->getPlaintext();

	$style = array(
	'margin: 6px 0 12px 0;',
	);

	$section_html = phutil_tag(
	'div',
	array(
	'style' => implode(' ', $style),
	),
	$section->getHTML());

	$body->addPlaintextSection($header, $section_text, false);
	$body->addHTMLSection($header, $section_html);
	}

	private function loadDiff($phid, $need_changesets = false) {
	$query = id(new DifferentialDiffQuery())
	->withPHIDs(array($phid))
	->setViewer($this->getActor());

	if ($need_changesets) {
	$query->needChangesets(true);
	}

	return $query->executeOne();
	}

	private function requireDiff($phid, $need_changesets = false) {
	$diff = $this->loadDiff($phid, $need_changesets);
	if (!$diff) {
	throw new Exception(pht('Diff "%s" does not exist!', $phid));
	}

	return $diff;
	}

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

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

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

	$repository = $object->getRepository();
	if (!$repository) {
	return array();
	}

	if (!$this->affectedPaths) {
	return array();
	}

	$packages = PhabricatorOwnersPackage::loadAffectedPackages(
	$repository,
	$this->affectedPaths);
	if (!$packages) {
	return array();
	}

	// Remove packages that the revision author is an owner of. If you own
	// code, you don't need another owner to review it.
	$authority = id(new PhabricatorOwnersPackageQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(mpull($packages, 'getPHID'))
	->withAuthorityPHIDs(array($object->getAuthorPHID()))
	->execute();
	$authority = mpull($authority, null, 'getPHID');

	foreach ($packages as $key => $package) {
	$package_phid = $package->getPHID();
	if (isset($authority[$package_phid])) {
	unset($packages[$key]);
	continue;
	}
	}

	if (!$packages) {
	return array();
	}

	$auto_subscribe = array();
	$auto_review = array();
	$auto_block = array();

	foreach ($packages as $package) {
	switch ($package->getAutoReview()) {
	case PhabricatorOwnersPackage::AUTOREVIEW_SUBSCRIBE:
	$auto_subscribe[] = $package;
	break;
	case PhabricatorOwnersPackage::AUTOREVIEW_REVIEW:
	$auto_review[] = $package;
	break;
	case PhabricatorOwnersPackage::AUTOREVIEW_BLOCK:
	$auto_block[] = $package;
	break;
	case PhabricatorOwnersPackage::AUTOREVIEW_NONE:
	default:
	break;
	}
	}

	$owners_phid = id(new PhabricatorOwnersApplication())
	->getPHID();

	$xactions = array();
	if ($auto_subscribe) {
	$xactions[] = $object->getApplicationTransactionTemplate()
	->setAuthorPHID($owners_phid)
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(
	array(
	'+' => mpull($auto_subscribe, 'getPHID'),
	));
	}

	$specs = array(
	array($auto_review, false),
	array($auto_block, true),
	);

	foreach ($specs as $spec) {
	list($reviewers, $blocking) = $spec;
	if (!$reviewers) {
	continue;
	}

	$phids = mpull($reviewers, 'getPHID');
	$xaction = $this->newAutoReviewTransaction($object, $phids, $blocking);
	if ($xaction) {
	$xactions[] = $xaction;
	}
	}

	return $xactions;
	}

	private function newAutoReviewTransaction(
	PhabricatorLiskDAO $object,
	array $phids,
	$is_blocking) {

	// TODO: This is substantially similar to DifferentialReviewersHeraldAction
	// and both are needlessly complex. This logic should live in the normal
	// transaction application pipeline. See T10967.

	$reviewers = $object->getReviewers();
	$reviewers = mpull($reviewers, null, 'getReviewerPHID');

	if ($is_blocking) {
	$new_status = DifferentialReviewerStatus::STATUS_BLOCKING;
	} else {
	$new_status = DifferentialReviewerStatus::STATUS_ADDED;
	}

	$new_strength = DifferentialReviewerStatus::getStatusStrength(
	$new_status);

	$current = array();
	foreach ($phids as $phid) {
	if (!isset($reviewers[$phid])) {
	continue;
	}

	// If we're applying a stronger status (usually, upgrading a reviewer
	// into a blocking reviewer), skip this check so we apply the change.
	$old_strength = DifferentialReviewerStatus::getStatusStrength(
	$reviewers[$phid]->getReviewerStatus());
	if ($old_strength <= $new_strength) {
	continue;
	}

	$current[] = $phid;
	}

	$phids = array_diff($phids, $current);

	if (!$phids) {
	return null;
	}

	$phids = array_fuse($phids);

	$value = array();
	foreach ($phids as $phid) {
	if ($is_blocking) {
	$value[] = 'blocking('.$phid.')';
	} else {
	$value[] = $phid;
	}
	}

	$owners_phid = id(new PhabricatorOwnersApplication())
	->getPHID();

	$reviewers_type = DifferentialRevisionReviewersTransaction::TRANSACTIONTYPE;

	return $object->getApplicationTransactionTemplate()
	->setAuthorPHID($owners_phid)
	->setTransactionType($reviewers_type)
	->setNewValue(
	array(
	'+' => $value,
	));
	}

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

	$revision = id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($object->getPHID()))
	->needActiveDiffs(true)
	->needReviewers(true)
	->executeOne();
	if (!$revision) {
	throw new Exception(
	pht('Failed to load revision for Herald adapter construction!'));
	}

	$adapter = HeraldDifferentialRevisionAdapter::newLegacyAdapter(
	$revision,
	$revision->getActiveDiff());

	// If the object is still a draft, prevent "Send me an email" and other
	// similar rules from acting yet.
	if (!$object->shouldBroadcast()) {
	$adapter->setForbiddenAction(
	HeraldMailableState::STATECONST,
	DifferentialHeraldStateReasons::REASON_DRAFT);
	}

	// If this edit didn't actually change the diff (for example, a user
	// edited the title or changed subscribers), prevent "Run build plan"
	// and other similar rules from acting yet, since the build results will
	// not (or, at least, should not) change unless the actual source changes.
	// We also don't run Differential builds if the update was caused by
	// discovering a commit, as the expectation is that Diffusion builds take
	// over once things land.
	$has_update = false;
	$has_commit = false;

	$type_update = DifferentialTransaction::TYPE_UPDATE;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() != $type_update) {
	continue;
	}

	if ($xaction->getMetadataValue('isCommitUpdate')) {
	$has_commit = true;
	} else {
	$has_update = true;
	}

	break;
	}

	if ($has_commit) {
	$adapter->setForbiddenAction(
	HeraldBuildableState::STATECONST,
	DifferentialHeraldStateReasons::REASON_LANDED);
	} else if (!$has_update) {
	$adapter->setForbiddenAction(
	HeraldBuildableState::STATECONST,
	DifferentialHeraldStateReasons::REASON_UNCHANGED);
	}

	return $adapter;
	}

	/**
	* Update the table which links Differential revisions to paths they affect,
	* so Diffusion can efficiently find pending revisions for a given file.
	*/
	private function updateAffectedPathTable(
	DifferentialRevision $revision,
	DifferentialDiff $diff) {

	$repository = $revision->getRepository();
	if (!$repository) {
	// The repository where the code lives is untracked.
	return;
	}

	$path_prefix = null;

	$local_root = $diff->getSourceControlPath();
	if ($local_root) {
	// We're in a working copy which supports subdirectory checkouts (e.g.,
	// SVN) so we need to figure out what prefix we should add to each path
	// (e.g., trunk/projects/example/) to get the absolute path from the
	// root of the repository. DVCS systems like Git and Mercurial are not
	// affected.

	// Normalize both paths and check if the repository root is a prefix of
	// the local root. If so, throw it away. Note that this correctly handles
	// the case where the remote path is "/".
	$local_root = id(new PhutilURI($local_root))->getPath();
	$local_root = rtrim($local_root, '/');

	$repo_root = id(new PhutilURI($repository->getRemoteURI()))->getPath();
	$repo_root = rtrim($repo_root, '/');

	if (!strncmp($repo_root, $local_root, strlen($repo_root))) {
	$path_prefix = substr($local_root, strlen($repo_root));
	}
	}

	$changesets = $diff->getChangesets();
	$paths = array();
	foreach ($changesets as $changeset) {
	$paths[] = $path_prefix.'/'.$changeset->getFilename();
	}

	// Save the affected paths; we'll use them later to query Owners. This
	// uses the un-expanded paths.
	$this->affectedPaths = $paths;

	// Mark this as also touching all parent paths, so you can see all pending
	// changes to any file within a directory.
	$all_paths = array();
	foreach ($paths as $local) {
	foreach (DiffusionPathIDQuery::expandPathToRoot($local) as $path) {
	$all_paths[$path] = true;
	}
	}
	$all_paths = array_keys($all_paths);

	$path_ids =
	PhabricatorRepositoryCommitChangeParserWorker::lookupOrCreatePaths(
	$all_paths);

	$table = new DifferentialAffectedPath();
	$conn_w = $table->establishConnection('w');

	$sql = array();
	foreach ($path_ids as $path_id) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %d, %d, %d)',
	$repository->getID(),
	$path_id,
	time(),
	$revision->getID());
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	$table->getTableName(),
	$revision->getID());
	foreach (array_chunk($sql, 256) as $chunk) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (repositoryID, pathID, epoch, revisionID) VALUES %Q',
	$table->getTableName(),
	implode(', ', $chunk));
	}
	}

	/**
	* Update the table connecting revisions to DVCS local hashes, so we can
	* identify revisions by commit/tree hashes.
	*/
	private function updateRevisionHashTable(
	DifferentialRevision $revision,
	DifferentialDiff $diff) {

	$vcs = $diff->getSourceControlSystem();
	if ($vcs == DifferentialRevisionControlSystem::SVN) {
	// Subversion has no local commit or tree hash information, so we don't
	// have to do anything.
	return;
	}

	$property = id(new DifferentialDiffProperty())->loadOneWhere(
	'diffID = %d AND name = %s',
	$diff->getID(),
	'local:commits');
	if (!$property) {
	return;
	}

	$hashes = array();

	$data = $property->getData();
	switch ($vcs) {
	case DifferentialRevisionControlSystem::GIT:
	foreach ($data as $commit) {
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT,
	$commit['commit'],
	);
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_GIT_TREE,
	$commit['tree'],
	);
	}
	break;
	case DifferentialRevisionControlSystem::MERCURIAL:
	foreach ($data as $commit) {
	$hashes[] = array(
	ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT,
	$commit['rev'],
	);
	}
	break;
	}

	$conn_w = $revision->establishConnection('w');

	$sql = array();
	foreach ($hashes as $info) {
	list($type, $hash) = $info;
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s, %s)',
	$revision->getID(),
	$type,
	$hash);
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	ArcanistDifferentialRevisionHash::TABLE_NAME,
	$revision->getID());

	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (revisionID, type, hash) VALUES %Q',
	ArcanistDifferentialRevisionHash::TABLE_NAME,
	implode(', ', $sql));
	}
	}

	private function renderAffectedFilesForMail(DifferentialDiff $diff) {
	$changesets = $diff->getChangesets();

	$filenames = mpull($changesets, 'getDisplayFilename');
	sort($filenames);

	$count = count($filenames);
	$max = 250;
	if ($count > $max) {
	$filenames = array_slice($filenames, 0, $max);
	$filenames[] = pht('(%d more files...)', ($count - $max));
	}

	return implode("\n", $filenames);
	}

	private function renderPatchHTMLForMail($patch) {
	return phutil_tag('pre',
	array('style' => 'font-family: monospace;'), $patch);
	}

	private function buildPatchForMail(DifferentialDiff $diff) {
	$format = PhabricatorEnv::getEnvConfig('metamta.differential.patch-format');

	return id(new DifferentialRawDiffRenderer())
	->setViewer($this->getActor())
	->setFormat($format)
	->setChangesets($diff->getChangesets())
	->buildPatch();
	}

	protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
	// Reload to pick up the active diff and reviewer status.
	return id(new DifferentialRevisionQuery())
	->setViewer($this->getActor())
	->needReviewers(true)
	->needActiveDiffs(true)
	->withIDs(array($object->getID()))
	->executeOne();
	}

	protected function getCustomWorkerState() {
	return array(
	'changedPriorToCommitURI' => $this->changedPriorToCommitURI,
	'firstBroadcast' => $this->firstBroadcast,
	);
	}

	protected function loadCustomWorkerState(array $state) {
	$this->changedPriorToCommitURI = idx($state, 'changedPriorToCommitURI');
	$this->firstBroadcast = idx($state, 'firstBroadcast');
	return $this;
	}

	private function newCommandeerReviewerTransaction(
	DifferentialRevision $revision) {

	$actor_phid = $this->getActingAsPHID();
	$owner_phid = $revision->getAuthorPHID();

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

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

	// NOTE: We're setting setIsCommandeerSideEffect() on this because normally
	// you can't add a revision's author as a reviewer, but this action swaps
	// them after validation executes.

	$xaction_type = DifferentialRevisionReviewersTransaction::TRANSACTIONTYPE;

	return id(new DifferentialTransaction())
	->setTransactionType($xaction_type)
	->setIgnoreOnNoEffect(true)
	->setIsCommandeerSideEffect(true)
	->setNewValue($edits);
	}

	public function getActiveDiff($object) {
	if ($this->getIsNewObject()) {
	return null;
	} else {
	return $object->getActiveDiff();
	}
	}

	/**
	* When a reviewer makes a comment, mark the last revision they commented
	* on.
	*
	* This allows us to show a hint to help authors and other reviewers quickly
	* distinguish between reviewers who have participated in the discussion and
	* reviewers who haven't been part of it.
	*/
	private function markReviewerComments($object, array $xactions) {
	$acting_phid = $this->getActingAsPHID();
	if (!$acting_phid) {
	return;
	}

	$diff = $this->getActiveDiff($object);
	if (!$diff) {
	return;
	}

	$has_comment = false;
	foreach ($xactions as $xaction) {
	if ($xaction->hasComment()) {
	$has_comment = true;
	break;
	}
	}

	if (!$has_comment) {
	return;
	}

	$reviewer_table = new DifferentialReviewer();
	$conn = $reviewer_table->establishConnection('w');

	queryfx(
	$conn,
	'UPDATE %T SET lastCommentDiffPHID = %s
	WHERE revisionPHID = %s
	AND reviewerPHID = %s',
	$reviewer_table->getTableName(),
	$diff->getPHID(),
	$object->getPHID(),
	$acting_phid);
	}

	private function loadUnbroadcastTransactions($object) {
	$viewer = $this->requireActor();

	$xactions = id(new DifferentialTransactionQuery())
	->setViewer($viewer)
	->withObjectPHIDs(array($object->getPHID()))
	->execute();

	return array_reverse($xactions);
	}


	protected function didApplyTransactions($object, array $xactions) {
	// In a moment, we're going to try to publish draft revisions which have
	// completed all their builds. However, we only want to do that if the
	// actor is either the revision author or an omnipotent user (generally,
	// the Harbormaster application).

	// If we let any actor publish the revision as a side effect of other
	// changes then an unlucky third party who innocently comments on the draft
	// can end up racing Harbormaster and promoting the revision. At best, this
	// is confusing. It can also run into validation problems with the "Request
	// Review" transaction. See PHI309 for some discussion.
	$author_phid = $object->getAuthorPHID();
	$viewer = $this->requireActor();
	$can_undraft =
	($this->getActingAsPHID() === $author_phid) \|\|
	($viewer->isOmnipotent());

	// If a draft revision has no outstanding builds and we're automatically
	// making drafts public after builds finish, make the revision public.
	if ($can_undraft) {
	$auto_undraft = !$object->getHoldAsDraft();
	} else {
	$auto_undraft = false;
	}

	if ($object->isDraft() && $auto_undraft) {
	$active_builds = $this->hasActiveBuilds($object);
	if (!$active_builds) {
	// When Harbormaster moves a revision out of the draft state, we
	// attribute the action to the revision author since this is more
	// natural and more useful.

	// Additionally, we change the acting PHID for the transaction set
	// to the author if it isn't already a user so that mail comes from
	// the natural author.
	$acting_phid = $this->getActingAsPHID();
	$user_type = PhabricatorPeopleUserPHIDType::TYPECONST;
	if (phid_get_type($acting_phid) != $user_type) {
	$this->setActingAsPHID($author_phid);
	}

	$xaction = $object->getApplicationTransactionTemplate()
	->setAuthorPHID($author_phid)
	->setTransactionType(
	DifferentialRevisionRequestReviewTransaction::TRANSACTIONTYPE)
	->setNewValue(true);

	// If we're creating this revision and immediately moving it out of
	// the draft state, mark this as a create transaction so it gets
	// hidden in the timeline and mail, since it isn't interesting: it
	// is as though the draft phase never happened.
	if ($this->getIsNewObject()) {
	$xaction->setIsCreateTransaction(true);
	}

	// Queue this transaction and apply it separately after the current
	// batch of transactions finishes so that Herald can fire on the new
	// revision state. See T13027 for discussion.
	$this->queueTransaction($xaction);
	}
	}

	// If the revision is new or was a draft, and is no longer a draft, we
	// might be sending the first email about it.

	// This might mean it was created directly into a non-draft state, or
	// it just automatically undrafted after builds finished, or a user
	// explicitly promoted it out of the draft state with an action like
	// "Request Review".

	// If we haven't sent any email about it yet, mark this email as the first
	// email so the mail gets enriched with "SUMMARY" and "TEST PLAN".

	$is_new = $this->getIsNewObject();
	$was_draft = $this->wasDraft;

	if (!$object->isDraft() && ($was_draft \|\| $is_new)) {
	if (!$object->getHasBroadcast()) {
	// Mark this as the first broadcast we're sending about the revision
	// so mail can generate specially.
	$this->firstBroadcast = true;

	$object
	->setHasBroadcast(true)
	->save();
	}
	}

	return $xactions;
	}

	private function hasActiveBuilds($object) {
	$viewer = $this->requireActor();

	$builds = $object->loadActiveBuilds($viewer);
	if (!$builds) {
	return false;
	}

	return true;
	}

	private function updateRevisionLineCounts(
	DifferentialRevision $revision,
	DifferentialDiff $diff) {

	$revision->setLineCount($diff->getLineCount());

	$conn = $revision->establishConnection('r');

	$row = queryfx_one(
	$conn,
	'SELECT SUM(addLines) A, SUM(delLines) D FROM %T
	WHERE diffID = %d',
	id(new DifferentialChangeset())->getTableName(),
	$diff->getID());

	if ($row) {
	$revision->setAddedLineCount((int)$row['A']);
	$revision->setRemovedLineCount((int)$row['D']);
	}
	}

	}
	diff --git a/src/applications/files/editor/PhabricatorFileEditor.php b/src/applications/files/editor/PhabricatorFileEditor.php
	index 6a2b797b40..db974cec65 100644
	--- a/src/applications/files/editor/PhabricatorFileEditor.php
	+++ b/src/applications/files/editor/PhabricatorFileEditor.php
	@@ -1,77 +1,76 @@
	<?php

	final class PhabricatorFileEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorFilesApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Files');
	}

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

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

	return $types;
	}

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

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

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getAuthorPHID(),
	$this->requireActor()->getPHID(),
	);
	}

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$name = $object->getName();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("F{$id}: {$name}")
	- ->addHeader('Thread-Topic', "F{$id}");
	+ ->setSubject("F{$id}: {$name}");
	}

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

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

	$body->addTextSection(
	pht('FILE DETAIL'),
	PhabricatorEnv::getProductionURI($object->getInfoURI()));

	return $body;
	}

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

	protected function supportsSearch() {
	return true;
	}

	}
	diff --git a/src/applications/fund/editor/FundInitiativeEditor.php b/src/applications/fund/editor/FundInitiativeEditor.php
	index e5c372fd12..9175156ffd 100644
	--- a/src/applications/fund/editor/FundInitiativeEditor.php
	+++ b/src/applications/fund/editor/FundInitiativeEditor.php
	@@ -1,93 +1,92 @@
	<?php

	final class FundInitiativeEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorFundApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Fund Initiatives');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this initiative.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
	$types[] = PhabricatorTransactions::TYPE_COMMENT;

	return $types;
	}

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

	public function getMailTagsMap() {
	return array(
	FundInitiativeTransaction::MAILTAG_BACKER =>
	pht('Someone backs an initiative.'),
	FundInitiativeTransaction::MAILTAG_STATUS =>
	pht("An initiative's status changes."),
	FundInitiativeTransaction::MAILTAG_OTHER =>
	pht('Other initiative activity not listed above occurs.'),
	);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$monogram = $object->getMonogram();
	$name = $object->getName();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("{$monogram}: {$name}")
	- ->addHeader('Thread-Topic', $monogram);
	+ ->setSubject("{$monogram}: {$name}");
	}

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

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

	$body->addLinkSection(
	pht('INITIATIVE DETAIL'),
	PhabricatorEnv::getProductionURI('/'.$object->getMonogram()));

	return $body;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array($object->getOwnerPHID());
	}

	protected function getMailSubjectPrefix() {
	return 'Fund';
	}

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

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

	protected function supportsSearch() {
	return true;
	}

	}
	diff --git a/src/applications/legalpad/editor/LegalpadDocumentEditor.php b/src/applications/legalpad/editor/LegalpadDocumentEditor.php
	index 35f2487a81..e4b43186ee 100644
	--- a/src/applications/legalpad/editor/LegalpadDocumentEditor.php
	+++ b/src/applications/legalpad/editor/LegalpadDocumentEditor.php
	@@ -1,185 +1,183 @@
	<?php

	final class LegalpadDocumentEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorLegalpadApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Legalpad Documents');
	}

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

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

	return $types;
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this document.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

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

	$is_contribution = false;

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case LegalpadDocumentTitleTransaction::TRANSACTIONTYPE:
	case LegalpadDocumentTextTransaction::TRANSACTIONTYPE:
	$is_contribution = true;
	break;
	}
	}

	if ($is_contribution) {
	$text = $object->getDocumentBody()->getText();
	$title = $object->getDocumentBody()->getTitle();
	$object->setVersions($object->getVersions() + 1);

	$body = new LegalpadDocumentBody();
	$body->setCreatorPHID($this->getActingAsPHID());
	$body->setText($text);
	$body->setTitle($title);
	$body->setVersion($object->getVersions());
	$body->setDocumentPHID($object->getPHID());
	$body->save();

	$object->setDocumentBodyPHID($body->getPHID());

	$type = PhabricatorContributedToObjectEdgeType::EDGECONST;
	id(new PhabricatorEdgeEditor())
	->addEdge($this->getActingAsPHID(), $type, $object->getPHID())
	->save();

	$type = PhabricatorObjectHasContributorEdgeType::EDGECONST;
	$contributors = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object->getPHID(),
	$type);
	$object->setRecentContributorPHIDs(array_slice($contributors, 0, 3));
	$object->setContributorCount(count($contributors));

	$object->save();
	}

	return $xactions;
	}

	protected function validateAllTransactions(PhabricatorLiskDAO $object,
	array $xactions) {
	$errors = array();

	$is_required = (bool)$object->getRequireSignature();
	$document_type = $object->getSignatureType();
	$individual = LegalpadDocument::SIGNATURE_TYPE_INDIVIDUAL;

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case LegalpadDocumentRequireSignatureTransaction::TRANSACTIONTYPE:
	$is_required = (bool)$xaction->getNewValue();
	break;
	case LegalpadDocumentSignatureTypeTransaction::TRANSACTIONTYPE:
	$document_type = $xaction->getNewValue();
	break;
	}
	}

	if ($is_required && ($document_type != $individual)) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	LegalpadDocumentRequireSignatureTransaction::TRANSACTIONTYPE,
	pht('Invalid'),
	pht('Only documents with signature type "individual" may '.
	'require signing to use Phabricator.'),
	null);
	}

	return $errors;
	}


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

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

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

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

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("L{$id}: {$title}")
	- ->addHeader('Thread-Topic', "L{$id}: {$phid}");
	+ ->setSubject("L{$id}: {$title}");
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getCreatorPHID(),
	$this->requireActor()->getPHID(),
	);
	}

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

	switch ($xaction->getTransactionType()) {
	case LegalpadDocumentTextTransaction::TRANSACTIONTYPE:
	case LegalpadDocumentTitleTransaction::TRANSACTIONTYPE:
	case LegalpadDocumentPreambleTransaction::TRANSACTIONTYPE:
	case LegalpadDocumentRequireSignatureTransaction::TRANSACTIONTYPE:
	return true;
	}

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

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

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

	$body->addLinkSection(
	pht('DOCUMENT DETAIL'),
	PhabricatorEnv::getProductionURI('/legalpad/view/'.$object->getID().'/'));

	return $body;
	}

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


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

	protected function supportsSearch() {
	return false;
	}

	}
	diff --git a/src/applications/macro/editor/PhabricatorMacroEditor.php b/src/applications/macro/editor/PhabricatorMacroEditor.php
	index 5d28b78f5f..f59c29b426 100644
	--- a/src/applications/macro/editor/PhabricatorMacroEditor.php
	+++ b/src/applications/macro/editor/PhabricatorMacroEditor.php
	@@ -1,69 +1,68 @@
	<?php

	final class PhabricatorMacroEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorMacroApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Macros');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this macro.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

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

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$name = $object->getName();
	$name = 'Image Macro "'.$name.'"';

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

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$this->requireActor()->getPHID(),
	);
	}

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

	$body = parent::buildMailBody($object, $xactions);
	$body->addLinkSection(
	pht('MACRO DETAIL'),
	PhabricatorEnv::getProductionURI('/macro/view/'.$object->getID().'/'));

	return $body;
	}

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

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return true;
	}
	}
	diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	index caf70b8f3c..9c8e3869dc 100644
	--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	@@ -1,1061 +1,1060 @@
	<?php

	final class ManiphestTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	private $moreValidationErrors = array();

	public function getEditorApplicationClass() {
	return 'PhabricatorManiphestApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Maniphest Tasks');
	}

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

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

	return $types;
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this task.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return null;
	}
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return $xaction->getNewValue();
	}
	}

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

	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return (bool)$new;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return;
	}
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	foreach ($xaction->getNewValue() as $move) {
	$this->applyBoardMove($object, $move);
	}
	break;
	}
	}

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

	// When we change the status of a task, update tasks this tasks blocks
	// with a message to the effect of "alincoln resolved blocking task Txxx."
	$unblock_xaction = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTaskStatusTransaction::TRANSACTIONTYPE:
	$unblock_xaction = $xaction;
	break;
	}
	}

	if ($unblock_xaction !== null) {
	$blocked_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object->getPHID(),
	ManiphestTaskDependedOnByTaskEdgeType::EDGECONST);
	if ($blocked_phids) {
	// In theory we could apply these through policies, but that seems a
	// little bit surprising. For now, use the actor's vision.
	$blocked_tasks = id(new ManiphestTaskQuery())
	->setViewer($this->getActor())
	->withPHIDs($blocked_phids)
	->needSubscriberPHIDs(true)
	->needProjectPHIDs(true)
	->execute();

	$old = $unblock_xaction->getOldValue();
	$new = $unblock_xaction->getNewValue();

	foreach ($blocked_tasks as $blocked_task) {
	$parent_xaction = id(new ManiphestTransaction())
	->setTransactionType(
	ManiphestTaskUnblockTransaction::TRANSACTIONTYPE)
	->setOldValue(array($object->getPHID() => $old))
	->setNewValue(array($object->getPHID() => $new));

	if ($this->getIsNewObject()) {
	$parent_xaction->setMetadataValue('blocker.new', true);
	}

	id(new ManiphestTransactionEditor())
	->setActor($this->getActor())
	->setActingAsPHID($this->getActingAsPHID())
	->setContentSource($this->getContentSource())
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->applyTransactions($blocked_task, array($parent_xaction));
	}
	}
	}

	return $xactions;
	}

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

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

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	return 'maniphest-task-'.$object->getPHID();
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();

	if ($object->getOwnerPHID()) {
	$phids[] = $object->getOwnerPHID();
	}
	$phids[] = $this->getActingAsPHID();

	return $phids;
	}

	public function getMailTagsMap() {
	return array(
	ManiphestTransaction::MAILTAG_STATUS =>
	pht("A task's status changes."),
	ManiphestTransaction::MAILTAG_OWNER =>
	pht("A task's owner changes."),
	ManiphestTransaction::MAILTAG_PRIORITY =>
	pht("A task's priority changes."),
	ManiphestTransaction::MAILTAG_CC =>
	pht("A task's subscribers change."),
	ManiphestTransaction::MAILTAG_PROJECTS =>
	pht("A task's associated projects change."),
	ManiphestTransaction::MAILTAG_UNBLOCK =>
	pht("One of a task's subtasks changes status."),
	ManiphestTransaction::MAILTAG_COLUMN =>
	pht('A task is moved between columns on a workboard.'),
	ManiphestTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a task.'),
	ManiphestTransaction::MAILTAG_OTHER =>
	pht('Other task activity not listed above occurs.'),
	);
	}

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

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

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("T{$id}: {$title}")
	- ->addHeader('Thread-Topic', "T{$id}: ".$object->getOriginalTitle());
	+ ->setSubject("T{$id}: {$title}");
	}

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

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

	if ($this->getIsNewObject()) {
	$body->addRemarkupSection(
	pht('TASK DESCRIPTION'),
	$object->getDescription());
	}

	$body->addLinkSection(
	pht('TASK DETAIL'),
	PhabricatorEnv::getProductionURI('/T'.$object->getID()));


	$board_phids = array();
	$type_columns = PhabricatorTransactions::TYPE_COLUMNS;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_columns) {
	$moves = $xaction->getNewValue();
	foreach ($moves as $move) {
	$board_phids[] = $move['boardPHID'];
	}
	}
	}

	if ($board_phids) {
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->requireActor())
	->withPHIDs($board_phids)
	->execute();

	foreach ($projects as $project) {
	$body->addLinkSection(
	pht('WORKBOARD'),
	PhabricatorEnv::getProductionURI(
	'/project/board/'.$project->getID().'/'));
	}
	}


	return $body;
	}

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

	protected function supportsSearch() {
	return true;
	}

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

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

	return id(new HeraldManiphestTaskAdapter())
	->setTask($object);
	}

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

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

	$app_capability_map = array(
	ManiphestTaskPriorityTransaction::TRANSACTIONTYPE =>
	ManiphestEditPriorityCapability::CAPABILITY,
	ManiphestTaskStatusTransaction::TRANSACTIONTYPE =>
	ManiphestEditStatusCapability::CAPABILITY,
	ManiphestTaskOwnerTransaction::TRANSACTIONTYPE =>
	ManiphestEditAssignCapability::CAPABILITY,
	PhabricatorTransactions::TYPE_EDIT_POLICY =>
	ManiphestEditPoliciesCapability::CAPABILITY,
	PhabricatorTransactions::TYPE_VIEW_POLICY =>
	ManiphestEditPoliciesCapability::CAPABILITY,
	);


	$transaction_type = $xaction->getTransactionType();

	$app_capability = null;
	if ($transaction_type == PhabricatorTransactions::TYPE_EDGE) {
	switch ($xaction->getMetadataValue('edge:type')) {
	case PhabricatorProjectObjectHasProjectEdgeType::EDGECONST:
	$app_capability = ManiphestEditProjectsCapability::CAPABILITY;
	break;
	}
	} else {
	$app_capability = idx($app_capability_map, $transaction_type);
	}

	if ($app_capability) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($this->getActor())
	->withClasses(array('PhabricatorManiphestApplication'))
	->executeOne();
	PhabricatorPolicyFilter::requireCapability(
	$this->getActor(),
	$app,
	$app_capability);
	}
	}

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

	$copy = parent::adjustObjectForPolicyChecks($object, $xactions);
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTaskOwnerTransaction::TRANSACTIONTYPE:
	$copy->setOwnerPHID($xaction->getNewValue());
	break;
	default:
	continue;
	}
	}

	return $copy;
	}

	/**
	* Get priorities for moving a task to a new priority.
	*/
	public static function getEdgeSubpriority(
	$priority,
	$is_end) {

	$query = id(new ManiphestTaskQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPriorities(array($priority))
	->setLimit(1);

	if ($is_end) {
	$query->setOrderVector(array('-priority', '-subpriority', '-id'));
	} else {
	$query->setOrderVector(array('priority', 'subpriority', 'id'));
	}

	$result = $query->executeOne();
	$step = (double)(2 << 32);

	if ($result) {
	$base = $result->getSubpriority();
	if ($is_end) {
	$sub = ($base - $step);
	} else {
	$sub = ($base + $step);
	}
	} else {
	$sub = 0;
	}

	return array($priority, $sub);
	}


	/**
	* Get priorities for moving a task before or after another task.
	*/
	public static function getAdjacentSubpriority(
	ManiphestTask $dst,
	$is_after) {

	$query = id(new ManiphestTaskQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->setOrder(ManiphestTaskQuery::ORDER_PRIORITY)
	->withPriorities(array($dst->getPriority()))
	->setLimit(1);

	if ($is_after) {
	$query->setAfterID($dst->getID());
	} else {
	$query->setBeforeID($dst->getID());
	}

	$adjacent = $query->executeOne();

	$base = $dst->getSubpriority();
	$step = (double)(2 << 32);

	// If we find an adjacent task, we average the two subpriorities and
	// return the result.
	if ($adjacent) {
	$epsilon = 1.0;

	// If the adjacent task has a subpriority that is identical or very
	// close to the task we're looking at, we're going to spread out all
	// the nearby tasks.

	$adjacent_sub = $adjacent->getSubpriority();
	if ((abs($adjacent_sub - $base) < $epsilon)) {
	$base = self::disperseBlock(
	$dst,
	$epsilon * 2);
	if ($is_after) {
	$sub = $base - $epsilon;
	} else {
	$sub = $base + $epsilon;
	}
	} else {
	$sub = ($adjacent_sub + $base) / 2;
	}
	} else {
	// Otherwise, we take a step away from the target's subpriority and
	// use that.
	if ($is_after) {
	$sub = ($base - $step);
	} else {
	$sub = ($base + $step);
	}
	}

	return array($dst->getPriority(), $sub);
	}

	/**
	* Distribute a cluster of tasks with similar subpriorities.
	*/
	private static function disperseBlock(
	ManiphestTask $task,
	$spacing) {

	$conn = $task->establishConnection('w');

	// Find a block of subpriority space which is, on average, sparse enough
	// to hold all the tasks that are inside it with a reasonable level of
	// separation between them.

	// We'll start by looking near the target task for a range of numbers
	// which has more space available than tasks. For example, if the target
	// task has subpriority 33 and we want to separate each task by at least 1,
	// we might start by looking in the range [23, 43].

	// If we find fewer than 20 tasks there, we have room to reassign them
	// with the desired level of separation. We space them out, then we're
	// done.

	// However: if we find more than 20 tasks, we don't have enough room to
	// distribute them. We'll widen our search and look in a bigger range,
	// maybe [13, 53]. This range has more space, so if we find fewer than
	// 40 tasks in this range we can spread them out. If we still find too
	// many tasks, we keep widening the search.

	$base = $task->getSubpriority();

	$scale = 4.0;
	while (true) {
	$range = ($spacing * $scale) / 2.0;
	$min = ($base - $range);
	$max = ($base + $range);

	$result = queryfx_one(
	$conn,
	'SELECT COUNT(*) N FROM %T WHERE priority = %d AND
	subpriority BETWEEN %f AND %f',
	$task->getTableName(),
	$task->getPriority(),
	$min,
	$max);

	$count = $result['N'];
	if ($count < $scale) {
	// We have found a block which we can make sparse enough, so bail and
	// continue below with our selection.
	break;
	}

	// This block had too many tasks for its size, so try again with a
	// bigger block.
	$scale *= 2.0;
	}

	$rows = queryfx_all(
	$conn,
	'SELECT id FROM %T WHERE priority = %d AND
	subpriority BETWEEN %f AND %f
	ORDER BY priority, subpriority, id',
	$task->getTableName(),
	$task->getPriority(),
	$min,
	$max);

	$task_id = $task->getID();
	$result = null;

	// NOTE: In strict mode (which we encourage enabling) we can't structure
	// this bulk update as an "INSERT ... ON DUPLICATE KEY UPDATE" unless we
	// provide default values for ALL of the columns that don't have defaults.

	// This is gross, but we may be moving enough rows that individual
	// queries are unreasonably slow. An alternate construction which might
	// be worth evaluating is to use "CASE". Another approach is to disable
	// strict mode for this query.

	$extra_columns = array(
	'phid' => '""',
	'authorPHID' => '""',
	'status' => '""',
	'priority' => 0,
	'title' => '""',
	'originalTitle' => '""',
	'description' => '""',
	'dateCreated' => 0,
	'dateModified' => 0,
	'mailKey' => '""',
	'viewPolicy' => '""',
	'editPolicy' => '""',
	'ownerOrdering' => '""',
	'spacePHID' => '""',
	'bridgedObjectPHID' => '""',
	'properties' => '""',
	'points' => 0,
	'subtype' => '""',
	);

	$defaults = implode(', ', $extra_columns);

	$sql = array();
	$offset = 0;

	// Often, we'll have more room than we need in the range. Distribute the
	// tasks evenly over the whole range so that we're less likely to end up
	// with tasks spaced exactly the minimum distance apart, which may
	// get shifted again later. We have one fewer space to distribute than we
	// have tasks.
	$divisor = (double)(count($rows) - 1.0);
	if ($divisor > 0) {
	$available_distance = (($max - $min) / $divisor);
	} else {
	$available_distance = 0.0;
	}

	foreach ($rows as $row) {
	$subpriority = $min + ($offset * $available_distance);

	// If this is the task that we're spreading out relative to, keep track
	// of where it is ending up so we can return the new subpriority.
	$id = $row['id'];
	if ($id == $task_id) {
	$result = $subpriority;
	}

	$sql[] = qsprintf(
	$conn,
	'(%d, %Q, %f)',
	$id,
	$defaults,
	$subpriority);

	$offset++;
	}

	foreach (PhabricatorLiskDAO::chunkSQL($sql) as $chunk) {
	queryfx(
	$conn,
	'INSERT INTO %T (id, %Q, subpriority) VALUES %Q
	ON DUPLICATE KEY UPDATE subpriority = VALUES(subpriority)',
	$task->getTableName(),
	implode(', ', array_keys($extra_columns)),
	$chunk);
	}

	return $result;
	}

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

	$errors = parent::validateAllTransactions($object, $xactions);

	if ($this->moreValidationErrors) {
	$errors = array_merge($errors, $this->moreValidationErrors);
	}

	return $errors;
	}

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

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

	$results = parent::expandTransactions($object, $xactions);

	$is_unassigned = ($object->getOwnerPHID() === null);

	$any_assign = false;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() ==
	ManiphestTaskOwnerTransaction::TRANSACTIONTYPE) {
	$any_assign = true;
	break;
	}
	}

	$is_open = !$object->isClosed();

	$new_status = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTaskStatusTransaction::TRANSACTIONTYPE:
	$new_status = $xaction->getNewValue();
	break;
	}
	}

	if ($new_status === null) {
	$is_closing = false;
	} else {
	$is_closing = ManiphestTaskStatus::isClosedStatus($new_status);
	}

	// If the task is not assigned, not being assigned, currently open, and
	// being closed, try to assign the actor as the owner.
	if ($is_unassigned && !$any_assign && $is_open && $is_closing) {
	$is_claim = ManiphestTaskStatus::isClaimStatus($new_status);

	// Don't assign the actor if they aren't a real user.
	// Don't claim the task if the status is configured to not claim.
	if ($actor_phid && $is_claim) {
	$results[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTaskOwnerTransaction::TRANSACTIONTYPE)
	->setNewValue($actor_phid);
	}
	}

	// Automatically subscribe the author when they create a task.
	if ($this->getIsNewObject()) {
	if ($actor_phid) {
	$results[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(
	array(
	'+' => array($actor_phid => $actor_phid),
	));
	}
	}

	return $results;
	}

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

	$results = parent::expandTransaction($object, $xaction);

	$type = $xaction->getTransactionType();
	switch ($type) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	try {
	$more_xactions = $this->buildMoveTransaction($object, $xaction);
	foreach ($more_xactions as $more_xaction) {
	$results[] = $more_xaction;
	}
	} catch (Exception $ex) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	$ex->getMessage(),
	$xaction);
	$this->moreValidationErrors[] = $error;
	}
	break;
	case ManiphestTaskOwnerTransaction::TRANSACTIONTYPE:
	// If this is a no-op update, don't expand it.
	$old_value = $object->getOwnerPHID();
	$new_value = $xaction->getNewValue();
	if ($old_value === $new_value) {
	continue;
	}

	// When a task is reassigned, move the old owner to the subscriber
	// list so they're still in the loop.
	if ($old_value) {
	$results[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setIgnoreOnNoEffect(true)
	->setNewValue(
	array(
	'+' => array($old_value => $old_value),
	));
	}
	break;
	}

	return $results;
	}

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

	$new = $xaction->getNewValue();
	if (!is_array($new)) {
	$this->validateColumnPHID($new);
	$new = array($new);
	}

	$nearby_phids = array();
	foreach ($new as $key => $value) {
	if (!is_array($value)) {
	$this->validateColumnPHID($value);
	$value = array(
	'columnPHID' => $value,
	);
	}

	PhutilTypeSpec::checkMap(
	$value,
	array(
	'columnPHID' => 'string',
	'beforePHID' => 'optional string',
	'afterPHID' => 'optional string',
	));

	$new[$key] = $value;

	if (!empty($value['beforePHID'])) {
	$nearby_phids[] = $value['beforePHID'];
	}

	if (!empty($value['afterPHID'])) {
	$nearby_phids[] = $value['afterPHID'];
	}
	}

	if ($nearby_phids) {
	$nearby_objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getActor())
	->withPHIDs($nearby_phids)
	->execute();
	$nearby_objects = mpull($nearby_objects, null, 'getPHID');
	} else {
	$nearby_objects = array();
	}

	$column_phids = ipull($new, 'columnPHID');
	if ($column_phids) {
	$columns = id(new PhabricatorProjectColumnQuery())
	->setViewer($this->getActor())
	->withPHIDs($column_phids)
	->execute();
	$columns = mpull($columns, null, 'getPHID');
	} else {
	$columns = array();
	}

	$board_phids = mpull($columns, 'getProjectPHID');
	$object_phid = $object->getPHID();

	$object_phids = $nearby_phids;

	// Note that we may not have an object PHID if we're creating a new
	// object.
	if ($object_phid) {
	$object_phids[] = $object_phid;
	}

	if ($object_phids) {
	$layout_engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($this->getActor())
	->setBoardPHIDs($board_phids)
	->setObjectPHIDs($object_phids)
	->setFetchAllBoards(true)
	->executeLayout();
	}

	foreach ($new as $key => $spec) {
	$column_phid = $spec['columnPHID'];
	$column = idx($columns, $column_phid);
	if (!$column) {
	throw new Exception(
	pht(
	'Column move transaction specifies column PHID "%s", but there '.
	'is no corresponding column with this PHID.',
	$column_phid));
	}

	$board_phid = $column->getProjectPHID();

	$nearby = array();

	if (!empty($spec['beforePHID'])) {
	$nearby['beforePHID'] = $spec['beforePHID'];
	}

	if (!empty($spec['afterPHID'])) {
	$nearby['afterPHID'] = $spec['afterPHID'];
	}

	if (count($nearby) > 1) {
	throw new Exception(
	pht(
	'Column move transaction moves object to multiple positions. '.
	'Specify only "beforePHID" or "afterPHID", not both.'));
	}

	foreach ($nearby as $where => $nearby_phid) {
	if (empty($nearby_objects[$nearby_phid])) {
	throw new Exception(
	pht(
	'Column move transaction specifies object "%s" as "%s", but '.
	'there is no corresponding object with this PHID.',
	$object_phid,
	$where));
	}

	$nearby_columns = $layout_engine->getObjectColumns(
	$board_phid,
	$nearby_phid);
	$nearby_columns = mpull($nearby_columns, null, 'getPHID');

	if (empty($nearby_columns[$column_phid])) {
	throw new Exception(
	pht(
	'Column move transaction specifies object "%s" as "%s" in '.
	'column "%s", but this object is not in that column!',
	$nearby_phid,
	$where,
	$column_phid));
	}
	}

	if ($object_phid) {
	$old_columns = $layout_engine->getObjectColumns(
	$board_phid,
	$object_phid);
	$old_column_phids = mpull($old_columns, 'getPHID');
	} else {
	$old_column_phids = array();
	}

	$spec += array(
	'boardPHID' => $board_phid,
	'fromColumnPHIDs' => $old_column_phids,
	);

	// Check if the object is already in this column, and isn't being moved.
	// We can just drop this column change if it has no effect.
	$from_map = array_fuse($spec['fromColumnPHIDs']);
	$already_here = isset($from_map[$column_phid]);
	$is_reordering = (bool)$nearby;

	if ($already_here && !$is_reordering) {
	unset($new[$key]);
	} else {
	$new[$key] = $spec;
	}
	}

	$new = array_values($new);
	$xaction->setNewValue($new);


	$more = array();

	// If we're moving the object into a column and it does not already belong
	// in the column, add the appropriate board. For normal columns, this
	// is the board PHID. For proxy columns, it is the proxy PHID, unless the
	// object is already a member of some descendant of the proxy PHID.

	// The major case where this can happen is moves via the API, but it also
	// happens when a user drags a task from the "Backlog" to a milestone
	// column.

	if ($object_phid) {
	$current_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object_phid,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	$current_phids = array_fuse($current_phids);
	} else {
	$current_phids = array();
	}

	$add_boards = array();
	foreach ($new as $move) {
	$column_phid = $move['columnPHID'];
	$board_phid = $move['boardPHID'];
	$column = $columns[$column_phid];
	$proxy_phid = $column->getProxyPHID();

	// If this is a normal column, add the board if the object isn't already
	// associated.
	if (!$proxy_phid) {
	if (!isset($current_phids[$board_phid])) {
	$add_boards[] = $board_phid;
	}
	continue;
	}

	// If this is a proxy column but the object is already associated with
	// the proxy board, we don't need to do anything.
	if (isset($current_phids[$proxy_phid])) {
	continue;
	}

	// If this a proxy column and the object is already associated with some
	// descendant of the proxy board, we also don't need to do anything.
	$descendants = id(new PhabricatorProjectQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withAncestorProjectPHIDs(array($proxy_phid))
	->execute();

	$found_descendant = false;
	foreach ($descendants as $descendant) {
	if (isset($current_phids[$descendant->getPHID()])) {
	$found_descendant = true;
	break;
	}
	}

	if ($found_descendant) {
	continue;
	}

	// Otherwise, we're moving the object to a proxy column which it is not
	// a member of yet, so add an association to the column's proxy board.

	$add_boards[] = $proxy_phid;
	}

	if ($add_boards) {
	$more[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue(
	'edge:type',
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST)
	->setIgnoreOnNoEffect(true)
	->setNewValue(
	array(
	'+' => array_fuse($add_boards),
	));
	}

	return $more;
	}

	private function applyBoardMove($object, array $move) {
	$board_phid = $move['boardPHID'];
	$column_phid = $move['columnPHID'];
	$before_phid = idx($move, 'beforePHID');
	$after_phid = idx($move, 'afterPHID');

	$object_phid = $object->getPHID();

	// We're doing layout with the omnipotent viewer to make sure we don't
	// remove positions in columns that exist, but which the actual actor
	// can't see.
	$omnipotent_viewer = PhabricatorUser::getOmnipotentUser();

	$select_phids = array($board_phid);

	$descendants = id(new PhabricatorProjectQuery())
	->setViewer($omnipotent_viewer)
	->withAncestorProjectPHIDs($select_phids)
	->execute();
	foreach ($descendants as $descendant) {
	$select_phids[] = $descendant->getPHID();
	}

	$board_tasks = id(new ManiphestTaskQuery())
	->setViewer($omnipotent_viewer)
	->withEdgeLogicPHIDs(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	PhabricatorQueryConstraint::OPERATOR_ANCESTOR,
	array($select_phids))
	->execute();

	$board_tasks = mpull($board_tasks, null, 'getPHID');
	$board_tasks[$object_phid] = $object;

	// Make sure tasks are sorted by ID, so we lay out new positions in
	// a consistent way.
	$board_tasks = msort($board_tasks, 'getID');

	$object_phids = array_keys($board_tasks);

	$engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($omnipotent_viewer)
	->setBoardPHIDs(array($board_phid))
	->setObjectPHIDs($object_phids)
	->executeLayout();

	// TODO: This logic needs to be revised when we legitimately support
	// multiple column positions.
	$columns = $engine->getObjectColumns($board_phid, $object_phid);
	foreach ($columns as $column) {
	$engine->queueRemovePosition(
	$board_phid,
	$column->getPHID(),
	$object_phid);
	}

	if ($before_phid) {
	$engine->queueAddPositionBefore(
	$board_phid,
	$column_phid,
	$object_phid,
	$before_phid);
	} else if ($after_phid) {
	$engine->queueAddPositionAfter(
	$board_phid,
	$column_phid,
	$object_phid,
	$after_phid);
	} else {
	$engine->queueAddPosition(
	$board_phid,
	$column_phid,
	$object_phid);
	}

	$engine->applyPositionUpdates();
	}


	private function validateColumnPHID($value) {
	if (phid_get_type($value) == PhabricatorProjectColumnPHIDType::TYPECONST) {
	return;
	}

	throw new Exception(
	pht(
	'When moving objects between columns on a board, columns must '.
	'be identified by PHIDs. This transaction uses "%s" to identify '.
	'a column, but that is not a valid column PHID.',
	$value));
	}



	}
	diff --git a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	index 83cdc7c40f..f2c8939132 100644
	--- a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	+++ b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	@@ -1,1501 +1,1507 @@
	<?php

	/**
	* @task recipients Managing Recipients
	*/
	final class PhabricatorMetaMTAMail
	extends PhabricatorMetaMTADAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorDestructibleInterface {

	const RETRY_DELAY = 5;

	protected $actorPHID;
	protected $parameters = array();
	protected $status;
	protected $message;
	protected $relatedPHID;

	private $recipientExpansionMap;
	private $routingMap;

	public function __construct() {

	$this->status = PhabricatorMailOutboundStatus::STATUS_QUEUE;
	$this->parameters = array(
	'sensitive' => true,
	'mustEncrypt' => false,
	);

	parent::__construct();
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'parameters' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'actorPHID' => 'phid?',
	'status' => 'text32',
	'relatedPHID' => 'phid?',

	// T6203/NULLABILITY
	// This should just be empty if there's no body.
	'message' => 'text?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'status' => array(
	'columns' => array('status'),
	),
	'key_actorPHID' => array(
	'columns' => array('actorPHID'),
	),
	'relatedPHID' => array(
	'columns' => array('relatedPHID'),
	),
	'key_created' => array(
	'columns' => array('dateCreated'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorMetaMTAMailPHIDType::TYPECONST);
	}

	protected function setParam($param, $value) {
	$this->parameters[$param] = $value;
	return $this;
	}

	protected function getParam($param, $default = null) {
	// Some old mail was saved without parameters because no parameters were
	// set or encoding failed. Recover in these cases so we can perform
	// mail migrations, see T9251.
	if (!is_array($this->parameters)) {
	$this->parameters = array();
	}

	return idx($this->parameters, $param, $default);
	}

	/**
	* These tags are used to allow users to opt out of receiving certain types
	* of mail, like updates when a task's projects change.
	*
	* @param list<const>
	* @return this
	*/
	public function setMailTags(array $tags) {
	$this->setParam('mailtags', array_unique($tags));
	return $this;
	}

	public function getMailTags() {
	return $this->getParam('mailtags', array());
	}

	/**
	* In Gmail, conversations will be broken if you reply to a thread and the
	* server sends back a response without referencing your Message-ID, even if
	* it references a Message-ID earlier in the thread. To avoid this, use the
	* parent email's message ID explicitly if it's available. This overwrites the
	* "In-Reply-To" and "References" headers we would otherwise generate. This
	* needs to be set whenever an action is triggered by an email message. See
	* T251 for more details.
	*
	* @param string The "Message-ID" of the email which precedes this one.
	* @return this
	*/
	public function setParentMessageID($id) {
	$this->setParam('parent-message-id', $id);
	return $this;
	}

	public function getParentMessageID() {
	return $this->getParam('parent-message-id');
	}

	public function getSubject() {
	return $this->getParam('subject');
	}

	public function addTos(array $phids) {
	$phids = array_unique($phids);
	$this->setParam('to', $phids);
	return $this;
	}

	public function addRawTos(array $raw_email) {

	// Strip addresses down to bare emails, since the MailAdapter API currently
	// requires we pass it just the address (like `alincoln@logcabin.org`), not
	// a full string like `"Abraham Lincoln" <alincoln@logcabin.org>`.
	foreach ($raw_email as $key => $email) {
	$object = new PhutilEmailAddress($email);
	$raw_email[$key] = $object->getAddress();
	}

	$this->setParam('raw-to', $raw_email);
	return $this;
	}

	public function addCCs(array $phids) {
	$phids = array_unique($phids);
	$this->setParam('cc', $phids);
	return $this;
	}

	public function setExcludeMailRecipientPHIDs(array $exclude) {
	$this->setParam('exclude', $exclude);
	return $this;
	}

	private function getExcludeMailRecipientPHIDs() {
	return $this->getParam('exclude', array());
	}

	public function setForceHeraldMailRecipientPHIDs(array $force) {
	$this->setParam('herald-force-recipients', $force);
	return $this;
	}

	private function getForceHeraldMailRecipientPHIDs() {
	return $this->getParam('herald-force-recipients', array());
	}

	public function addPHIDHeaders($name, array $phids) {
	$phids = array_unique($phids);
	foreach ($phids as $phid) {
	$this->addHeader($name, '<'.$phid.'>');
	}
	return $this;
	}

	public function addHeader($name, $value) {
	$this->parameters['headers'][] = array($name, $value);
	return $this;
	}

	public function addAttachment(PhabricatorMetaMTAAttachment $attachment) {
	$this->parameters['attachments'][] = $attachment->toDictionary();
	return $this;
	}

	public function getAttachments() {
	$dicts = $this->getParam('attachments');

	$result = array();
	foreach ($dicts as $dict) {
	$result[] = PhabricatorMetaMTAAttachment::newFromDictionary($dict);
	}
	return $result;
	}

	public function getAttachmentFilePHIDs() {
	$file_phids = array();

	$dictionaries = $this->getParam('attachments');
	if ($dictionaries) {
	foreach ($dictionaries as $dictionary) {
	$file_phid = idx($dictionary, 'filePHID');
	if ($file_phid) {
	$file_phids[] = $file_phid;
	}
	}
	}

	return $file_phids;
	}

	public function loadAttachedFiles(PhabricatorUser $viewer) {
	$file_phids = $this->getAttachmentFilePHIDs();

	if (!$file_phids) {
	return array();
	}

	return id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs($file_phids)
	->execute();
	}

	public function setAttachments(array $attachments) {
	assert_instances_of($attachments, 'PhabricatorMetaMTAAttachment');
	$this->setParam('attachments', mpull($attachments, 'toDictionary'));
	return $this;
	}

	public function setFrom($from) {
	$this->setParam('from', $from);
	$this->setActorPHID($from);
	return $this;
	}

	public function getFrom() {
	return $this->getParam('from');
	}

	public function setRawFrom($raw_email, $raw_name) {
	$this->setParam('raw-from', array($raw_email, $raw_name));
	return $this;
	}

	public function setReplyTo($reply_to) {
	$this->setParam('reply-to', $reply_to);
	return $this;
	}

	public function setSubject($subject) {
	$this->setParam('subject', $subject);
	return $this;
	}

	public function setSubjectPrefix($prefix) {
	$this->setParam('subject-prefix', $prefix);
	return $this;
	}

	public function setVarySubjectPrefix($prefix) {
	$this->setParam('vary-subject-prefix', $prefix);
	return $this;
	}

	public function setBody($body) {
	$this->setParam('body', $body);
	return $this;
	}

	public function setSensitiveContent($bool) {
	$this->setParam('sensitive', $bool);
	return $this;
	}

	public function hasSensitiveContent() {
	return $this->getParam('sensitive', true);
	}

	public function setMustEncrypt($bool) {
	$this->setParam('mustEncrypt', $bool);
	return $this;
	}

	public function getMustEncrypt() {
	return $this->getParam('mustEncrypt', false);
	}

	public function setMustEncryptReasons(array $reasons) {
	$this->setParam('mustEncryptReasons', $reasons);
	return $this;
	}

	public function getMustEncryptReasons() {
	return $this->getParam('mustEncryptReasons', array());
	}

	public function setMailStamps(array $stamps) {
	return $this->setParam('stamps', $stamps);
	}

	public function getMailStamps() {
	return $this->getParam('stamps', array());
	}

	public function setMailStampMetadata($metadata) {
	return $this->setParam('stampMetadata', $metadata);
	}

	public function getMailStampMetadata() {
	return $this->getParam('stampMetadata', array());
	}

	public function getMailerKey() {
	return $this->getParam('mailer.key');
	}

	public function setTryMailers(array $mailers) {
	return $this->setParam('mailers.try', $mailers);
	}

	public function setHTMLBody($html) {
	$this->setParam('html-body', $html);
	return $this;
	}

	public function getBody() {
	return $this->getParam('body');
	}

	public function getHTMLBody() {
	return $this->getParam('html-body');
	}

	public function setIsErrorEmail($is_error) {
	$this->setParam('is-error', $is_error);
	return $this;
	}

	public function getIsErrorEmail() {
	return $this->getParam('is-error', false);
	}

	public function getToPHIDs() {
	return $this->getParam('to', array());
	}

	public function getRawToAddresses() {
	return $this->getParam('raw-to', array());
	}

	public function getCcPHIDs() {
	return $this->getParam('cc', array());
	}

	/**
	* Force delivery of a message, even if recipients have preferences which
	* would otherwise drop the message.
	*
	* This is primarily intended to let users who don't want any email still
	* receive things like password resets.
	*
	* @param bool True to force delivery despite user preferences.
	* @return this
	*/
	public function setForceDelivery($force) {
	$this->setParam('force', $force);
	return $this;
	}

	public function getForceDelivery() {
	return $this->getParam('force', false);
	}

	/**
	* Flag that this is an auto-generated bulk message and should have bulk
	* headers added to it if appropriate. Broadly, this means some flavor of
	* "Precedence: bulk" or similar, but is implementation and configuration
	* dependent.
	*
	* @param bool True if the mail is automated bulk mail.
	* @return this
	*/
	public function setIsBulk($is_bulk) {
	$this->setParam('is-bulk', $is_bulk);
	return $this;
	}

	/**
	* Use this method to set an ID used for message threading. MetaMTA will
	* set appropriate headers (Message-ID, In-Reply-To, References and
	* Thread-Index) based on the capabilities of the underlying mailer.
	*
	* @param string Unique identifier, appropriate for use in a Message-ID,
	* In-Reply-To or References headers.
	* @param bool If true, indicates this is the first message in the thread.
	* @return this
	*/
	public function setThreadID($thread_id, $is_first_message = false) {
	$this->setParam('thread-id', $thread_id);
	$this->setParam('is-first-message', $is_first_message);
	return $this;
	}

	/**
	* Save a newly created mail to the database. The mail will eventually be
	* delivered by the MetaMTA daemon.
	*
	* @return this
	*/
	public function saveAndSend() {
	return $this->save();
	}

	/**
	* @return this
	*/
	public function save() {
	if ($this->getID()) {
	return parent::save();
	}

	// NOTE: When mail is sent from CLI scripts that run tasks in-process, we
	// may re-enter this method from within scheduleTask(). The implementation
	// is intended to avoid anything awkward if we end up reentering this
	// method.

	$this->openTransaction();
	// Save to generate a mail ID and PHID.
	$result = parent::save();

	// Write the recipient edges.
	$editor = new PhabricatorEdgeEditor();
	$edge_type = PhabricatorMetaMTAMailHasRecipientEdgeType::EDGECONST;
	$recipient_phids = array_merge(
	$this->getToPHIDs(),
	$this->getCcPHIDs());
	$expanded_phids = $this->expandRecipients($recipient_phids);
	$all_phids = array_unique(array_merge(
	$recipient_phids,
	$expanded_phids));
	foreach ($all_phids as $curr_phid) {
	$editor->addEdge($this->getPHID(), $edge_type, $curr_phid);
	}
	$editor->save();

	$this->saveTransaction();

	// Queue a task to send this mail.
	$mailer_task = PhabricatorWorker::scheduleTask(
	'PhabricatorMetaMTAWorker',
	$this->getID(),
	array(
	'priority' => PhabricatorWorker::PRIORITY_ALERTS,
	));

	return $result;
	}

	/**
	* Attempt to deliver an email immediately, in this process.
	*
	* @return void
	*/
	public function sendNow() {
	if ($this->getStatus() != PhabricatorMailOutboundStatus::STATUS_QUEUE) {
	throw new Exception(pht('Trying to send an already-sent mail!'));
	}

	$mailers = self::newMailers();

	$try_mailers = $this->getParam('mailers.try');
	if ($try_mailers) {
	$mailers = mpull($mailers, null, 'getKey');
	$mailers = array_select_keys($mailers, $try_mailers);
	}

	return $this->sendWithMailers($mailers);
	}

	public static function newMailers() {
	$mailers = array();

	$config = PhabricatorEnv::getEnvConfig('cluster.mailers');
	if ($config === null) {
	$mailer = PhabricatorEnv::newObjectFromConfig('metamta.mail-adapter');

	$defaults = $mailer->newDefaultOptions();
	$options = $mailer->newLegacyOptions();

	$options = $options + $defaults;

	$mailer
	->setKey('default')
	->setPriority(-1)
	->setOptions($options);

	$mailers[] = $mailer;
	} else {
	$adapters = PhabricatorMailImplementationAdapter::getAllAdapters();
	$next_priority = -1;

	foreach ($config as $spec) {
	$type = $spec['type'];
	if (!isset($adapters[$type])) {
	throw new Exception(
	pht(
	'Unknown mailer ("%s")!',
	$type));
	}

	$key = $spec['key'];
	$mailer = id(clone $adapters[$type])
	->setKey($key);

	$priority = idx($spec, 'priority');
	if (!$priority) {
	$priority = $next_priority;
	$next_priority--;
	}
	$mailer->setPriority($priority);

	$defaults = $mailer->newDefaultOptions();
	$options = idx($spec, 'options', array()) + $defaults;
	$mailer->setOptions($options);

	$mailers[] = $mailer;
	}
	}

	$sorted = array();
	$groups = mgroup($mailers, 'getPriority');
	krsort($groups);
	foreach ($groups as $group) {
	// Reorder services within the same priority group randomly.
	shuffle($group);
	foreach ($group as $mailer) {
	$sorted[] = $mailer;
	}
	}

	foreach ($sorted as $mailer) {
	$mailer->prepareForSend();
	}

	return $sorted;
	}

	public function sendWithMailers(array $mailers) {
	if (!$mailers) {
	return $this
	->setStatus(PhabricatorMailOutboundStatus::STATUS_VOID)
	->setMessage(pht('No mailers are configured.'))
	->save();
	}

	$exceptions = array();
	foreach ($mailers as $template_mailer) {
	$mailer = null;

	try {
	$mailer = $this->buildMailer($template_mailer);
	} catch (Exception $ex) {
	$exceptions[] = $ex;
	continue;
	}

	if (!$mailer) {
	// If we don't get a mailer back, that means the mail doesn't
	// actually need to be sent (for example, because recipients have
	// declined to receive the mail). Void it and return.
	return $this
	->setStatus(PhabricatorMailOutboundStatus::STATUS_VOID)
	->save();
	}

	try {
	$ok = $mailer->send();
	if (!$ok) {
	// TODO: At some point, we should clean this up and make all mailers
	// throw.
	throw new Exception(
	pht(
	'Mail adapter encountered an unexpected, unspecified '.
	'failure.'));
	}
	} catch (PhabricatorMetaMTAPermanentFailureException $ex) {
	// If any mailer raises a permanent failure, stop trying to send the
	// mail with other mailers.
	$this
	->setStatus(PhabricatorMailOutboundStatus::STATUS_FAIL)
	->setMessage($ex->getMessage())
	->save();

	throw $ex;
	} catch (Exception $ex) {
	$exceptions[] = $ex;
	continue;
	}

	// Keep track of which mailer actually ended up accepting the message.
	$mailer_key = $mailer->getKey();
	if ($mailer_key !== null) {
	$this->setParam('mailer.key', $mailer_key);
	}

	return $this
	->setStatus(PhabricatorMailOutboundStatus::STATUS_SENT)
	->save();
	}

	// If we make it here, no mailer could send the mail but no mailer failed
	// permanently either. We update the error message for the mail, but leave
	// it in the current status (usually, STATUS_QUEUE) and try again later.

	$messages = array();
	foreach ($exceptions as $ex) {
	$messages[] = $ex->getMessage();
	}
	$messages = implode("\n\n", $messages);

	$this
	->setMessage($messages)
	->save();

	if (count($exceptions) === 1) {
	throw head($exceptions);
	}

	throw new PhutilAggregateException(
	pht('Encountered multiple exceptions while transmitting mail.'),
	$exceptions);
	}

	private function buildMailer(PhabricatorMailImplementationAdapter $mailer) {
	$headers = $this->generateHeaders();

	$params = $this->parameters;

	$actors = $this->loadAllActors();
	$deliverable_actors = $this->filterDeliverableActors($actors);

	$default_from = PhabricatorEnv::getEnvConfig('metamta.default-address');
	if (empty($params['from'])) {
	$mailer->setFrom($default_from);
	}

	$is_first = idx($params, 'is-first-message');
	unset($params['is-first-message']);

	$is_threaded = (bool)idx($params, 'thread-id');
	$must_encrypt = $this->getMustEncrypt();

	$reply_to_name = idx($params, 'reply-to-name', '');
	unset($params['reply-to-name']);

	$add_cc = array();
	$add_to = array();

	// If we're sending one mail to everyone, some recipients will be in
	// "Cc" rather than "To". We'll move them to "To" later (or supply a
	// dummy "To") but need to look for the recipient in either the
	// "To" or "Cc" fields here.
	$target_phid = head(idx($params, 'to', array()));
	if (!$target_phid) {
	$target_phid = head(idx($params, 'cc', array()));
	}

	$preferences = $this->loadPreferences($target_phid);

	foreach ($params as $key => $value) {
	switch ($key) {
	case 'raw-from':
	list($from_email, $from_name) = $value;
	$mailer->setFrom($from_email, $from_name);
	break;
	case 'from':
	// If the mail content must be encrypted, disguise the sender.
	if ($must_encrypt) {
	$mailer->setFrom($default_from, pht('Phabricator'));
	break;
	}

	$from = $value;
	$actor_email = null;
	$actor_name = null;
	$actor = idx($actors, $from);
	if ($actor) {
	$actor_email = $actor->getEmailAddress();
	$actor_name = $actor->getName();
	}
	$can_send_as_user = $actor_email &&
	PhabricatorEnv::getEnvConfig('metamta.can-send-as-user');

	if ($can_send_as_user) {
	$mailer->setFrom($actor_email, $actor_name);
	} else {
	$from_email = coalesce($actor_email, $default_from);
	$from_name = coalesce($actor_name, pht('Phabricator'));

	if (empty($params['reply-to'])) {
	$params['reply-to'] = $from_email;
	$params['reply-to-name'] = $from_name;
	}

	$mailer->setFrom($default_from, $from_name);
	}
	break;
	case 'reply-to':
	$mailer->addReplyTo($value, $reply_to_name);
	break;
	case 'to':
	$to_phids = $this->expandRecipients($value);
	$to_actors = array_select_keys($deliverable_actors, $to_phids);
	$add_to = array_merge(
	$add_to,
	mpull($to_actors, 'getEmailAddress'));
	break;
	case 'raw-to':
	$add_to = array_merge($add_to, $value);
	break;
	case 'cc':
	$cc_phids = $this->expandRecipients($value);
	$cc_actors = array_select_keys($deliverable_actors, $cc_phids);
	$add_cc = array_merge(
	$add_cc,
	mpull($cc_actors, 'getEmailAddress'));
	break;
	case 'attachments':
	$attached_viewer = PhabricatorUser::getOmnipotentUser();
	$files = $this->loadAttachedFiles($attached_viewer);
	foreach ($files as $file) {
	$file->attachToObject($this->getPHID());
	}

	// If the mail content must be encrypted, don't add attachments.
	if ($must_encrypt) {
	break;
	}

	$value = $this->getAttachments();
	foreach ($value as $attachment) {
	$mailer->addAttachment(
	$attachment->getData(),
	$attachment->getFilename(),
	$attachment->getMimeType());
	}
	break;
	case 'subject':
	$subject = array();

	if ($is_threaded) {
	if ($this->shouldAddRePrefix($preferences)) {
	$subject[] = 'Re:';
	}
	}

	$subject[] = trim(idx($params, 'subject-prefix'));

	// If mail content must be encrypted, we replace the subject with
	// a generic one.
	if ($must_encrypt) {
	$subject[] = pht('Object Updated');
	} else {
	$vary_prefix = idx($params, 'vary-subject-prefix');
	if ($vary_prefix != '') {
	if ($this->shouldVarySubject($preferences)) {
	$subject[] = $vary_prefix;
	}
	}

	$subject[] = $value;
	}

	$mailer->setSubject(implode(' ', array_filter($subject)));
	break;
	case 'thread-id':

	// NOTE: Gmail freaks out about In-Reply-To and References which
	// aren't in the form "<string@domain.tld>"; this is also required
	// by RFC 2822, although some clients are more liberal in what they
	// accept.
	$domain = PhabricatorEnv::getEnvConfig('metamta.domain');
	$value = '<'.$value.'@'.$domain.'>';

	if ($is_first && $mailer->supportsMessageIDHeader()) {
	$headers[] = array('Message-ID', $value);
	} else {
	$in_reply_to = $value;
	$references = array($value);
	$parent_id = $this->getParentMessageID();
	if ($parent_id) {
	$in_reply_to = $parent_id;
	// By RFC 2822, the most immediate parent should appear last
	// in the "References" header, so this order is intentional.
	$references[] = $parent_id;
	}
	$references = implode(' ', $references);
	$headers[] = array('In-Reply-To', $in_reply_to);
	$headers[] = array('References', $references);
	}
	$thread_index = $this->generateThreadIndex($value, $is_first);
	$headers[] = array('Thread-Index', $thread_index);
	break;
	default:
	// Other parameters are handled elsewhere or are not relevant to
	// constructing the message.
	break;
	}
	}

	$stamps = $this->getMailStamps();
	if ($stamps) {
	$headers[] = array('X-Phabricator-Stamps', implode(', ', $stamps));
	}

	$raw_body = idx($params, 'body', '');
	$body = $raw_body;
	if ($must_encrypt) {
	$parts = array();
	$parts[] = pht(
	'The content for this message can only be transmitted over a '.
	'secure channel. To view the message content, follow this '.
	'link:');

	$parts[] = PhabricatorEnv::getProductionURI($this->getURI());

	$body = implode("\n\n", $parts);
	} else {
	$body = $raw_body;
	}

	$max = PhabricatorEnv::getEnvConfig('metamta.email-body-limit');
	if (strlen($body) > $max) {
	$body = id(new PhutilUTF8StringTruncator())
	->setMaximumBytes($max)
	->truncateString($body);
	$body .= "\n";
	$body .= pht('(This email was truncated at %d bytes.)', $max);
	}
	$mailer->setBody($body);

	// If we sent a different message body than we were asked to, record
	// what we actually sent to make debugging and diagnostics easier.
	if ($body !== $raw_body) {
	$this->setParam('body.sent', $body);
	}

	if ($must_encrypt) {
	$send_html = false;
	} else {
	$send_html = $this->shouldSendHTML($preferences);
	}

	if ($send_html && isset($params['html-body'])) {
	$mailer->setHTMLBody($params['html-body']);
	}

	// Pass the headers to the mailer, then save the state so we can show
	// them in the web UI. If the mail must be encrypted, we remove headers
	// which are not on a strict whitelist to avoid disclosing information.
	$filtered_headers = $this->filterHeaders($headers, $must_encrypt);
	foreach ($filtered_headers as $header) {
	list($header_key, $header_value) = $header;
	$mailer->addHeader($header_key, $header_value);
	}
	$this->setParam('headers.unfiltered', $headers);
	$this->setParam('headers.sent', $filtered_headers);

	// Save the final deliverability outcomes and reasoning so we can
	// explain why things happened the way they did.
	$actor_list = array();
	foreach ($actors as $actor) {
	$actor_list[$actor->getPHID()] = array(
	'deliverable' => $actor->isDeliverable(),
	'reasons' => $actor->getDeliverabilityReasons(),
	);
	}
	$this->setParam('actors.sent', $actor_list);

	$this->setParam('routing.sent', $this->getParam('routing'));
	$this->setParam('routingmap.sent', $this->getRoutingRuleMap());

	if (!$add_to && !$add_cc) {
	$this->setMessage(
	pht(
	'Message has no valid recipients: all To/Cc are disabled, '.
	'invalid, or configured not to receive this mail.'));

	return null;
	}

	if ($this->getIsErrorEmail()) {
	$all_recipients = array_merge($add_to, $add_cc);
	if ($this->shouldRateLimitMail($all_recipients)) {
	$this->setMessage(
	pht(
	'This is an error email, but one or more recipients have '.
	'exceeded the error email rate limit. Declining to deliver '.
	'message.'));

	return null;
	}
	}

	if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
	$this->setMessage(
	pht(
	'Phabricator is running in silent mode. See `%s` '.
	'in the configuration to change this setting.',
	'phabricator.silent'));

	return null;
	}

	// Some mailers require a valid "To:" in order to deliver mail. If we
	// don't have any "To:", try to fill it in with a placeholder "To:".
	// If that also fails, move the "Cc:" line to "To:".
	if (!$add_to) {
	$placeholder_key = 'metamta.placeholder-to-recipient';
	$placeholder = PhabricatorEnv::getEnvConfig($placeholder_key);
	if ($placeholder !== null) {
	$add_to = array($placeholder);
	} else {
	$add_to = $add_cc;
	$add_cc = array();
	}
	}

	$add_to = array_unique($add_to);
	$add_cc = array_diff(array_unique($add_cc), $add_to);

	$mailer->addTos($add_to);
	if ($add_cc) {
	$mailer->addCCs($add_cc);
	}

	return $mailer;
	}

	private function generateThreadIndex($seed, $is_first_mail) {
	// When threading, Outlook ignores the 'References' and 'In-Reply-To'
	// headers that most clients use. Instead, it uses a custom 'Thread-Index'
	// header. The format of this header is something like this (from
	// camel-exchange-folder.c in Evolution Exchange):

	/* A new post to a folder gets a 27-byte-long thread index. (The value
	* is apparently unique but meaningless.) Each reply to a post gets a
	* 32-byte-long thread index whose first 27 bytes are the same as the
	* parent's thread index. Each reply to any of those gets a
	* 37-byte-long thread index, etc. The Thread-Index header contains a
	* base64 representation of this value.
	*/

	// The specific implementation uses a 27-byte header for the first email
	// a recipient receives, and a random 5-byte suffix (32 bytes total)
	// thereafter. This means that all the replies are (incorrectly) siblings,
	// but it would be very difficult to keep track of the entire tree and this
	// gets us reasonable client behavior.

	$base = substr(md5($seed), 0, 27);
	if (!$is_first_mail) {
	// Not totally sure, but it seems like outlook orders replies by
	// thread-index rather than timestamp, so to get these to show up in the
	// right order we use the time as the last 4 bytes.
	$base .= ' '.pack('N', time());
	}

	return base64_encode($base);
	}

	public static function shouldMailEachRecipient() {
	return PhabricatorEnv::getEnvConfig('metamta.one-mail-per-recipient');
	}


	/* -( Managing Recipients )------------------------------------------------ */


	/**
	* Get all of the recipients for this mail, after preference filters are
	* applied. This list has all objects to whom delivery will be attempted.
	*
	* Note that this expands recipients into their members, because delivery
	* is never directly attempted to aggregate actors like projects.
	*
	* @return list<phid> A list of all recipients to whom delivery will be
	* attempted.
	* @task recipients
	*/
	public function buildRecipientList() {
	$actors = $this->loadAllActors();
	$actors = $this->filterDeliverableActors($actors);
	return mpull($actors, 'getPHID');
	}

	public function loadAllActors() {
	$actor_phids = $this->getExpandedRecipientPHIDs();
	return $this->loadActors($actor_phids);
	}

	public function getExpandedRecipientPHIDs() {
	$actor_phids = $this->getAllActorPHIDs();
	return $this->expandRecipients($actor_phids);
	}

	private function getAllActorPHIDs() {
	return array_merge(
	array($this->getParam('from')),
	$this->getToPHIDs(),
	$this->getCcPHIDs());
	}

	/**
	* Expand a list of recipient PHIDs (possibly including aggregate recipients
	* like projects) into a deaggregated list of individual recipient PHIDs.
	* For example, this will expand project PHIDs into a list of the project's
	* members.
	*
	* @param list<phid> List of recipient PHIDs, possibly including aggregate
	* recipients.
	* @return list<phid> Deaggregated list of mailable recipients.
	*/
	private function expandRecipients(array $phids) {
	if ($this->recipientExpansionMap === null) {
	$all_phids = $this->getAllActorPHIDs();
	$this->recipientExpansionMap = id(new PhabricatorMetaMTAMemberQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($all_phids)
	->execute();
	}

	$results = array();
	foreach ($phids as $phid) {
	foreach ($this->recipientExpansionMap[$phid] as $recipient_phid) {
	$results[$recipient_phid] = $recipient_phid;
	}
	}

	return array_keys($results);
	}

	private function filterDeliverableActors(array $actors) {
	assert_instances_of($actors, 'PhabricatorMetaMTAActor');
	$deliverable_actors = array();
	foreach ($actors as $phid => $actor) {
	if ($actor->isDeliverable()) {
	$deliverable_actors[$phid] = $actor;
	}
	}
	return $deliverable_actors;
	}

	private function loadActors(array $actor_phids) {
	$actor_phids = array_filter($actor_phids);
	$viewer = PhabricatorUser::getOmnipotentUser();

	$actors = id(new PhabricatorMetaMTAActorQuery())
	->setViewer($viewer)
	->withPHIDs($actor_phids)
	->execute();

	if (!$actors) {
	return array();
	}

	if ($this->getForceDelivery()) {
	// If we're forcing delivery, skip all the opt-out checks. We don't
	// bother annotating reasoning on the mail in this case because it should
	// always be obvious why the mail hit this rule (e.g., it is a password
	// reset mail).
	foreach ($actors as $actor) {
	$actor->setDeliverable(PhabricatorMetaMTAActor::REASON_FORCE);
	}
	return $actors;
	}

	// Exclude explicit recipients.
	foreach ($this->getExcludeMailRecipientPHIDs() as $phid) {
	$actor = idx($actors, $phid);
	if (!$actor) {
	continue;
	}
	$actor->setUndeliverable(PhabricatorMetaMTAActor::REASON_RESPONSE);
	}

	// Before running more rules, save a list of the actors who were
	// deliverable before we started running preference-based rules. This stops
	// us from trying to send mail to disabled users just because a Herald rule
	// added them, for example.
	$deliverable = array();
	foreach ($actors as $phid => $actor) {
	if ($actor->isDeliverable()) {
	$deliverable[] = $phid;
	}
	}

	// For the rest of the rules, order matters. We're going to run all the
	// possible rules in order from weakest to strongest, and let the strongest
	// matching rule win. The weaker rules leave annotations behind which help
	// users understand why the mail was routed the way it was.

	// Exclude the actor if their preferences are set.
	$from_phid = $this->getParam('from');
	$from_actor = idx($actors, $from_phid);
	if ($from_actor) {
	$from_user = id(new PhabricatorPeopleQuery())
	->setViewer($viewer)
	->withPHIDs(array($from_phid))
	->needUserSettings(true)
	->execute();
	$from_user = head($from_user);
	if ($from_user) {
	$pref_key = PhabricatorEmailSelfActionsSetting::SETTINGKEY;
	$exclude_self = $from_user->getUserSetting($pref_key);
	if ($exclude_self) {
	$from_actor->setUndeliverable(PhabricatorMetaMTAActor::REASON_SELF);
	}
	}
	}

	$all_prefs = id(new PhabricatorUserPreferencesQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withUserPHIDs($actor_phids)
	->needSyntheticPreferences(true)
	->execute();
	$all_prefs = mpull($all_prefs, null, 'getUserPHID');

	$value_email = PhabricatorEmailTagsSetting::VALUE_EMAIL;

	// Exclude all recipients who have set preferences to not receive this type
	// of email (for example, a user who says they don't want emails about task
	// CC changes).
	$tags = $this->getParam('mailtags');
	if ($tags) {
	foreach ($all_prefs as $phid => $prefs) {
	$user_mailtags = $prefs->getSettingValue(
	PhabricatorEmailTagsSetting::SETTINGKEY);

	// The user must have elected to receive mail for at least one
	// of the mailtags.
	$send = false;
	foreach ($tags as $tag) {
	if (((int)idx($user_mailtags, $tag, $value_email)) == $value_email) {
	$send = true;
	break;
	}
	}

	if (!$send) {
	$actors[$phid]->setUndeliverable(
	PhabricatorMetaMTAActor::REASON_MAILTAGS);
	}
	}
	}

	foreach ($deliverable as $phid) {
	switch ($this->getRoutingRule($phid)) {
	case PhabricatorMailRoutingRule::ROUTE_AS_NOTIFICATION:
	$actors[$phid]->setUndeliverable(
	PhabricatorMetaMTAActor::REASON_ROUTE_AS_NOTIFICATION);
	break;
	case PhabricatorMailRoutingRule::ROUTE_AS_MAIL:
	$actors[$phid]->setDeliverable(
	PhabricatorMetaMTAActor::REASON_ROUTE_AS_MAIL);
	break;
	default:
	// No change.
	break;
	}
	}

	// If recipients were initially deliverable and were added by "Send me an
	// email" Herald rules, annotate them as such and make them deliverable
	// again, overriding any changes made by the "self mail" and "mail tags"
	// settings.
	$force_recipients = $this->getForceHeraldMailRecipientPHIDs();
	$force_recipients = array_fuse($force_recipients);
	if ($force_recipients) {
	foreach ($deliverable as $phid) {
	if (isset($force_recipients[$phid])) {
	$actors[$phid]->setDeliverable(
	PhabricatorMetaMTAActor::REASON_FORCE_HERALD);
	}
	}
	}

	// Exclude recipients who don't want any mail. This rule is very strong
	// and runs last.
	foreach ($all_prefs as $phid => $prefs) {
	$exclude = $prefs->getSettingValue(
	PhabricatorEmailNotificationsSetting::SETTINGKEY);
	if ($exclude) {
	$actors[$phid]->setUndeliverable(
	PhabricatorMetaMTAActor::REASON_MAIL_DISABLED);
	}
	}

	// Unless delivery was forced earlier (password resets, confirmation mail),
	// never send mail to unverified addresses.
	foreach ($actors as $phid => $actor) {
	if ($actor->getIsVerified()) {
	continue;
	}

	$actor->setUndeliverable(PhabricatorMetaMTAActor::REASON_UNVERIFIED);
	}

	return $actors;
	}

	private function shouldRateLimitMail(array $all_recipients) {
	try {
	PhabricatorSystemActionEngine::willTakeAction(
	$all_recipients,
	new PhabricatorMetaMTAErrorMailAction(),
	1);
	return false;
	} catch (PhabricatorSystemActionRateLimitException $ex) {
	return true;
	}
	}

	public function generateHeaders() {
	$headers = array();

	$headers[] = array('X-Phabricator-Sent-This-Message', 'Yes');
	$headers[] = array('X-Mail-Transport-Agent', 'MetaMTA');

	// Some clients respect this to suppress OOF and other auto-responses.
	$headers[] = array('X-Auto-Response-Suppress', 'All');

	$mailtags = $this->getParam('mailtags');
	if ($mailtags) {
	$tag_header = array();
	foreach ($mailtags as $mailtag) {
	$tag_header[] = '<'.$mailtag.'>';
	}
	$tag_header = implode(', ', $tag_header);
	$headers[] = array('X-Phabricator-Mail-Tags', $tag_header);
	}

	$value = $this->getParam('headers', array());
	foreach ($value as $pair) {
	list($header_key, $header_value) = $pair;

	// NOTE: If we have \n in a header, SES rejects the email.
	$header_value = str_replace("\n", ' ', $header_value);
	$headers[] = array($header_key, $header_value);
	}

	$is_bulk = $this->getParam('is-bulk');
	if ($is_bulk) {
	$headers[] = array('Precedence', 'bulk');
	}

	if ($this->getMustEncrypt()) {
	$headers[] = array('X-Phabricator-Must-Encrypt', 'Yes');
	}

	+ $related_phid = $this->getRelatedPHID();
	+ if ($related_phid) {
	+ $headers[] = array('Thread-Topic', $related_phid);
	+ }
	+
	return $headers;
	}

	public function getDeliveredHeaders() {
	return $this->getParam('headers.sent');
	}

	public function getUnfilteredHeaders() {
	$unfiltered = $this->getParam('headers.unfiltered');

	if ($unfiltered === null) {
	// Older versions of Phabricator did not filter headers, and thus did
	// not record unfiltered headers. If we don't have unfiltered header
	// data just return the delivered headers for compatibility.
	return $this->getDeliveredHeaders();
	}

	return $unfiltered;
	}

	public function getDeliveredActors() {
	return $this->getParam('actors.sent');
	}

	public function getDeliveredRoutingRules() {
	return $this->getParam('routing.sent');
	}

	public function getDeliveredRoutingMap() {
	return $this->getParam('routingmap.sent');
	}

	public function getDeliveredBody() {
	return $this->getParam('body.sent');
	}

	private function filterHeaders(array $headers, $must_encrypt) {
	if (!$must_encrypt) {
	return $headers;
	}

	$whitelist = array(
	'In-Reply-To',
	'Message-ID',
	'Precedence',
	'References',
	'Thread-Index',
	+ 'Thread-Topic',

	'X-Mail-Transport-Agent',
	'X-Auto-Response-Suppress',

	'X-Phabricator-Sent-This-Message',
	'X-Phabricator-Must-Encrypt',
	);

	// NOTE: The major header we want to drop is "X-Phabricator-Mail-Tags".
	// This header contains a significant amount of meaningful information
	// about the object.

	$whitelist_map = array();
	foreach ($whitelist as $term) {
	$whitelist_map[phutil_utf8_strtolower($term)] = true;
	}

	foreach ($headers as $key => $header) {
	list($name, $value) = $header;
	$name = phutil_utf8_strtolower($name);

	if (!isset($whitelist_map[$name])) {
	unset($headers[$key]);
	}
	}

	return $headers;
	}

	public function getURI() {
	return '/mail/detail/'.$this->getID().'/';
	}


	/* -( Routing )------------------------------------------------------------ */


	public function addRoutingRule($routing_rule, $phids, $reason_phid) {
	$routing = $this->getParam('routing', array());
	$routing[] = array(
	'routingRule' => $routing_rule,
	'phids' => $phids,
	'reasonPHID' => $reason_phid,
	);
	$this->setParam('routing', $routing);

	// Throw the routing map away so we rebuild it.
	$this->routingMap = null;

	return $this;
	}

	private function getRoutingRule($phid) {
	$map = $this->getRoutingRuleMap();

	$info = idx($map, $phid, idx($map, 'default'));
	if ($info) {
	return idx($info, 'rule');
	}

	return null;
	}

	private function getRoutingRuleMap() {
	if ($this->routingMap === null) {
	$map = array();

	$routing = $this->getParam('routing', array());
	foreach ($routing as $route) {
	$phids = $route['phids'];
	if ($phids === null) {
	$phids = array('default');
	}

	foreach ($phids as $phid) {
	$new_rule = $route['routingRule'];

	$current_rule = idx($map, $phid);
	if ($current_rule === null) {
	$is_stronger = true;
	} else {
	$is_stronger = PhabricatorMailRoutingRule::isStrongerThan(
	$new_rule,
	$current_rule);
	}

	if ($is_stronger) {
	$map[$phid] = array(
	'rule' => $new_rule,
	'reason' => $route['reasonPHID'],
	);
	}
	}
	}

	$this->routingMap = $map;
	}

	return $this->routingMap;
	}

	/* -( Preferences )-------------------------------------------------------- */


	private function loadPreferences($target_phid) {
	$viewer = PhabricatorUser::getOmnipotentUser();

	if (self::shouldMailEachRecipient()) {
	$preferences = id(new PhabricatorUserPreferencesQuery())
	->setViewer($viewer)
	->withUserPHIDs(array($target_phid))
	->needSyntheticPreferences(true)
	->executeOne();
	if ($preferences) {
	return $preferences;
	}
	}

	return PhabricatorUserPreferences::loadGlobalPreferences($viewer);
	}

	private function shouldAddRePrefix(PhabricatorUserPreferences $preferences) {
	$value = $preferences->getSettingValue(
	PhabricatorEmailRePrefixSetting::SETTINGKEY);

	return ($value == PhabricatorEmailRePrefixSetting::VALUE_RE_PREFIX);
	}

	private function shouldVarySubject(PhabricatorUserPreferences $preferences) {
	$value = $preferences->getSettingValue(
	PhabricatorEmailVarySubjectsSetting::SETTINGKEY);

	return ($value == PhabricatorEmailVarySubjectsSetting::VALUE_VARY_SUBJECTS);
	}

	private function shouldSendHTML(PhabricatorUserPreferences $preferences) {
	$value = $preferences->getSettingValue(
	PhabricatorEmailFormatSetting::SETTINGKEY);

	return ($value == PhabricatorEmailFormatSetting::VALUE_HTML_EMAIL);
	}

	public function shouldRenderMailStampsInBody($viewer) {
	$preferences = $this->loadPreferences($viewer->getPHID());
	$value = $preferences->getSettingValue(
	PhabricatorEmailStampsSetting::SETTINGKEY);

	return ($value == PhabricatorEmailStampsSetting::VALUE_BODY_STAMPS);
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}

	public function getPolicy($capability) {
	return PhabricatorPolicies::POLICY_NOONE;
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	$actor_phids = $this->getExpandedRecipientPHIDs();
	return in_array($viewer->getPHID(), $actor_phids);
	}

	public function describeAutomaticCapability($capability) {
	return pht(
	'The mail sender and message recipients can always see the mail.');
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$files = $this->loadAttachedFiles($engine->getViewer());
	foreach ($files as $file) {
	$engine->destroyObject($file);
	}

	$this->delete();
	}

	}
	diff --git a/src/applications/owners/editor/PhabricatorOwnersPackageTransactionEditor.php b/src/applications/owners/editor/PhabricatorOwnersPackageTransactionEditor.php
	index 40657abd57..c6aad6e2bd 100644
	--- a/src/applications/owners/editor/PhabricatorOwnersPackageTransactionEditor.php
	+++ b/src/applications/owners/editor/PhabricatorOwnersPackageTransactionEditor.php
	@@ -1,76 +1,74 @@
	<?php

	final class PhabricatorOwnersPackageTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorOwnersApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Owners Packages');
	}

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

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

	return $types;
	}

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

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

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$this->requireActor()->getPHID(),
	);
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	return mpull($object->getOwners(), 'getUserPHID');
	}

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	- $id = $object->getID();
	$name = $object->getName();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject($name)
	- ->addHeader('Thread-Topic', $object->getPHID());
	+ ->setSubject($name);
	}

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

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

	$detail_uri = PhabricatorEnv::getProductionURI($object->getURI());

	$body->addLinkSection(
	pht('PACKAGE DETAIL'),
	$detail_uri);

	return $body;
	}

	protected function supportsSearch() {
	return true;
	}

	}
	diff --git a/src/applications/paste/editor/PhabricatorPasteEditor.php b/src/applications/paste/editor/PhabricatorPasteEditor.php
	index 063b72cfc0..c312915727 100644
	--- a/src/applications/paste/editor/PhabricatorPasteEditor.php
	+++ b/src/applications/paste/editor/PhabricatorPasteEditor.php
	@@ -1,98 +1,97 @@
	<?php

	final class PhabricatorPasteEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorPasteApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Pastes');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this paste.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

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

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

	return $types;
	}

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

	if ($this->getIsNewObject()) {
	return false;
	}

	return true;
	}

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

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getAuthorPHID(),
	$this->getActingAsPHID(),
	);
	}

	public function getMailTagsMap() {
	return array(
	PhabricatorPasteTransaction::MAILTAG_CONTENT =>
	pht('Paste title, language or text changes.'),
	PhabricatorPasteTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a paste.'),
	PhabricatorPasteTransaction::MAILTAG_OTHER =>
	pht('Other paste activity not listed above occurs.'),
	);
	}

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

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

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("P{$id}: {$name}")
	- ->addHeader('Thread-Topic', "P{$id}");
	+ ->setSubject("P{$id}: {$name}");
	}

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

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

	$body->addLinkSection(
	pht('PASTE DETAIL'),
	PhabricatorEnv::getProductionURI('/P'.$object->getID()));

	return $body;
	}

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

	}
	diff --git a/src/applications/phame/editor/PhameBlogEditor.php b/src/applications/phame/editor/PhameBlogEditor.php
	index f30a74065e..c122d8fa3b 100644
	--- a/src/applications/phame/editor/PhameBlogEditor.php
	+++ b/src/applications/phame/editor/PhameBlogEditor.php
	@@ -1,111 +1,109 @@
	<?php

	final class PhameBlogEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorPhameApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Phame Blogs');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this blog.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;

	return $types;
	}

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

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

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();
	$phids[] = $this->requireActor()->getPHID();
	$phids[] = $object->getCreatorPHID();

	return $phids;
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	- $phid = $object->getPHID();
	$name = $object->getName();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject($name)
	- ->addHeader('Thread-Topic', $phid);
	+ ->setSubject($name);
	}

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

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

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

	$body->addLinkSection(
	pht('BLOG DETAIL'),
	PhabricatorEnv::getProductionURI($object->getViewURI()));

	return $body;
	}

	public function getMailTagsMap() {
	return array(
	PhameBlogTransaction::MAILTAG_DETAILS =>
	pht("A blog's details change."),
	PhameBlogTransaction::MAILTAG_SUBSCRIBERS =>
	pht("A blog's subscribers change."),
	PhameBlogTransaction::MAILTAG_OTHER =>
	pht('Other blog activity not listed above occurs.'),
	);
	}

	protected function getMailSubjectPrefix() {
	return '[Phame]';
	}


	protected function supportsSearch() {
	return true;
	}

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

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

	return id(new HeraldPhameBlogAdapter())
	->setBlog($object);
	}

	}
	diff --git a/src/applications/phame/editor/PhamePostEditor.php b/src/applications/phame/editor/PhamePostEditor.php
	index 488d7a4938..d95389e549 100644
	--- a/src/applications/phame/editor/PhamePostEditor.php
	+++ b/src/applications/phame/editor/PhamePostEditor.php
	@@ -1,142 +1,140 @@
	<?php

	final class PhamePostEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorPhameApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Phame Posts');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this post.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();
	$types[] = PhabricatorTransactions::TYPE_COMMENT;

	return $types;
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	if ($object->isDraft() \|\| ($object->isArchived())) {
	return false;
	}
	return true;
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	if ($object->isDraft() \|\| $object->isArchived()) {
	return false;
	}
	return true;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();
	$phids[] = $object->getBloggerPHID();
	$phids[] = $this->requireActor()->getPHID();

	$blog_phid = $object->getBlogPHID();
	if ($blog_phid) {
	$cc_phids = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$blog_phid);
	foreach ($cc_phids as $cc) {
	$phids[] = $cc;
	}
	}
	return $phids;
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	- $phid = $object->getPHID();
	$title = $object->getTitle();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject($title)
	- ->addHeader('Thread-Topic', $phid);
	+ ->setSubject($title);
	}

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

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

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

	// We don't send mail if the object is a draft, and we only want
	// to include the full body of the post on the either the
	// first creation or if it was created as a draft, once it goes live.
	if ($this->getIsNewObject()) {
	$body->addRemarkupSection(null, $object->getBody());
	} else {
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhamePostVisibilityTransaction::TRANSACTIONTYPE:
	if (!$object->isDraft() && !$object->isArchived()) {
	$body->addRemarkupSection(null, $object->getBody());
	}
	break;
	}
	}
	}

	$body->addLinkSection(
	pht('POST DETAIL'),
	PhabricatorEnv::getProductionURI($object->getViewURI()));

	return $body;
	}

	public function getMailTagsMap() {
	return array(
	PhamePostTransaction::MAILTAG_CONTENT =>
	pht("A post's content changes."),
	PhamePostTransaction::MAILTAG_SUBSCRIBERS =>
	pht("A post's subscribers change."),
	PhamePostTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a post.'),
	PhamePostTransaction::MAILTAG_OTHER =>
	pht('Other post activity not listed above occurs.'),
	);
	}

	protected function getMailSubjectPrefix() {
	return '[Phame]';
	}

	protected function supportsSearch() {
	return true;
	}

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

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

	return id(new HeraldPhamePostAdapter())
	->setPost($object);
	}

	}
	diff --git a/src/applications/pholio/editor/PholioMockEditor.php b/src/applications/pholio/editor/PholioMockEditor.php
	index c0fcf31f83..6bd49d2e7b 100644
	--- a/src/applications/pholio/editor/PholioMockEditor.php
	+++ b/src/applications/pholio/editor/PholioMockEditor.php
	@@ -1,256 +1,254 @@
	<?php

	final class PholioMockEditor extends PhabricatorApplicationTransactionEditor {

	private $newImages = array();

	public function getEditorApplicationClass() {
	return 'PhabricatorPholioApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Pholio Mocks');
	}

	private function setNewImages(array $new_images) {
	assert_instances_of($new_images, 'PholioImage');
	$this->newImages = $new_images;
	return $this;
	}

	public function getNewImages() {
	return $this->newImages;
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this mock.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

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

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

	return $types;
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PholioImageFileTransaction::TRANSACTIONTYPE:
	case PholioImageReplaceTransaction::TRANSACTIONTYPE:
	return true;
	break;
	}
	}
	return false;
	}

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

	$new_images = array();
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PholioImageFileTransaction::TRANSACTIONTYPE:
	$new_value = $xaction->getNewValue();
	foreach ($new_value as $key => $txn_images) {
	if ($key != '+') {
	continue;
	}
	foreach ($txn_images as $image) {
	$image->save();
	$new_images[] = $image;
	}
	}
	break;
	case PholioImageReplaceTransaction::TRANSACTIONTYPE:
	$image = $xaction->getNewValue();
	$image->save();
	$new_images[] = $image;
	break;
	}
	}
	$this->setNewImages($new_images);
	}

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

	$images = $this->getNewImages();
	foreach ($images as $image) {
	$image->setMockID($object->getID());
	$image->save();
	}

	return $xactions;
	}

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

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$name = $object->getName();
	- $original_name = $object->getOriginalName();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("M{$id}: {$name}")
	- ->addHeader('Thread-Topic', "M{$id}: {$original_name}");
	+ ->setSubject("M{$id}: {$name}");
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getAuthorPHID(),
	$this->requireActor()->getPHID(),
	);
	}

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

	$body = new PhabricatorMetaMTAMailBody();
	$headers = array();
	$comments = array();
	$inline_comments = array();

	foreach ($xactions as $xaction) {
	if ($xaction->shouldHide()) {
	continue;
	}
	$comment = $xaction->getComment();
	switch ($xaction->getTransactionType()) {
	case PholioMockInlineTransaction::TRANSACTIONTYPE:
	if ($comment && strlen($comment->getContent())) {
	$inline_comments[] = $comment;
	}
	break;
	case PhabricatorTransactions::TYPE_COMMENT:
	if ($comment && strlen($comment->getContent())) {
	$comments[] = $comment->getContent();
	}
	// fallthrough
	default:
	$headers[] = id(clone $xaction)
	->setRenderingTarget('text')
	->getTitle();
	break;
	}
	}

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

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

	if ($inline_comments) {
	$body->addRawSection(pht('INLINE COMMENTS'));
	foreach ($inline_comments as $comment) {
	$text = pht(
	'Image %d: %s',
	$comment->getImageID(),
	$comment->getContent());
	$body->addRawSection($text);
	}
	}

	$body->addLinkSection(
	pht('MOCK DETAIL'),
	PhabricatorEnv::getProductionURI('/M'.$object->getID()));

	return $body;
	}

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

	public function getMailTagsMap() {
	return array(
	PholioTransaction::MAILTAG_STATUS =>
	pht("A mock's status changes."),
	PholioTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a mock.'),
	PholioTransaction::MAILTAG_UPDATED =>
	pht('Mock images or descriptions change.'),
	PholioTransaction::MAILTAG_OTHER =>
	pht('Other mock activity not listed above occurs.'),
	);
	}

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

	protected function supportsSearch() {
	return true;
	}

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

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

	return id(new HeraldPholioMockAdapter())
	->setMock($object);
	}

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

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

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

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

	switch ($xaction->getTransactionType()) {
	case PholioMockInlineTransaction::TRANSACTIONTYPE:
	return true;
	}

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

	}
	diff --git a/src/applications/phortune/editor/PhortuneCartEditor.php b/src/applications/phortune/editor/PhortuneCartEditor.php
	index 5196e12429..dcf1f2d0e0 100644
	--- a/src/applications/phortune/editor/PhortuneCartEditor.php
	+++ b/src/applications/phortune/editor/PhortuneCartEditor.php
	@@ -1,243 +1,242 @@
	<?php

	final class PhortuneCartEditor
	extends PhabricatorApplicationTransactionEditor {

	private $invoiceIssues;

	public function setInvoiceIssues(array $invoice_issues) {
	$this->invoiceIssues = $invoice_issues;
	return $this;
	}

	public function getInvoiceIssues() {
	return $this->invoiceIssues;
	}

	public function isInvoice() {
	return (bool)$this->invoiceIssues;
	}

	public function getEditorApplicationClass() {
	return 'PhabricatorPhortuneApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Phortune Carts');
	}

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

	$types[] = PhortuneCartTransaction::TYPE_CREATED;
	$types[] = PhortuneCartTransaction::TYPE_PURCHASED;
	$types[] = PhortuneCartTransaction::TYPE_HOLD;
	$types[] = PhortuneCartTransaction::TYPE_REVIEW;
	$types[] = PhortuneCartTransaction::TYPE_CANCEL;
	$types[] = PhortuneCartTransaction::TYPE_REFUND;
	$types[] = PhortuneCartTransaction::TYPE_INVOICED;

	return $types;
	}

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

	switch ($xaction->getTransactionType()) {
	case PhortuneCartTransaction::TYPE_CREATED:
	case PhortuneCartTransaction::TYPE_PURCHASED:
	case PhortuneCartTransaction::TYPE_HOLD:
	case PhortuneCartTransaction::TYPE_REVIEW:
	case PhortuneCartTransaction::TYPE_CANCEL:
	case PhortuneCartTransaction::TYPE_REFUND:
	case PhortuneCartTransaction::TYPE_INVOICED:
	return null;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhortuneCartTransaction::TYPE_CREATED:
	case PhortuneCartTransaction::TYPE_PURCHASED:
	case PhortuneCartTransaction::TYPE_HOLD:
	case PhortuneCartTransaction::TYPE_REVIEW:
	case PhortuneCartTransaction::TYPE_CANCEL:
	case PhortuneCartTransaction::TYPE_REFUND:
	case PhortuneCartTransaction::TYPE_INVOICED:
	return $xaction->getNewValue();
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhortuneCartTransaction::TYPE_CREATED:
	case PhortuneCartTransaction::TYPE_PURCHASED:
	case PhortuneCartTransaction::TYPE_HOLD:
	case PhortuneCartTransaction::TYPE_REVIEW:
	case PhortuneCartTransaction::TYPE_CANCEL:
	case PhortuneCartTransaction::TYPE_REFUND:
	case PhortuneCartTransaction::TYPE_INVOICED:
	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhortuneCartTransaction::TYPE_CREATED:
	case PhortuneCartTransaction::TYPE_PURCHASED:
	case PhortuneCartTransaction::TYPE_HOLD:
	case PhortuneCartTransaction::TYPE_REVIEW:
	case PhortuneCartTransaction::TYPE_CANCEL:
	case PhortuneCartTransaction::TYPE_REFUND:
	case PhortuneCartTransaction::TYPE_INVOICED:
	return;
	}

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

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$name = $object->getName();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject(pht('Order %d: %s', $id, $name))
	- ->addHeader('Thread-Topic', pht('Order %s', $id));
	+ ->setSubject(pht('Order %d: %s', $id, $name));
	}

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

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

	if ($this->isInvoice()) {
	$issues = $this->getInvoiceIssues();
	foreach ($issues as $key => $issue) {
	$issues[$key] = ' - '.$issue;
	}
	$issues = implode("\n", $issues);

	$overview = pht(
	"Payment for this invoice could not be processed automatically:\n\n".
	"%s",
	$issues);

	$body->addRemarkupSection(null, $overview);

	$body->addLinkSection(
	pht('PAY NOW'),
	PhabricatorEnv::getProductionURI($object->getCheckoutURI()));
	}

	$items = array();
	foreach ($object->getPurchases() as $purchase) {
	$name = $purchase->getFullDisplayName();
	$price = $purchase->getTotalPriceAsCurrency()->formatForDisplay();

	$items[] = "{$name} {$price}";
	}

	$body->addTextSection(pht('ORDER CONTENTS'), implode("\n", $items));

	if ($this->isInvoice()) {
	$subscription = id(new PhortuneSubscriptionQuery())
	->setViewer($this->requireActor())
	->withPHIDs(array($object->getSubscriptionPHID()))
	->executeOne();
	if ($subscription) {
	$body->addLinkSection(
	pht('SUBSCRIPTION'),
	PhabricatorEnv::getProductionURI($subscription->getURI()));
	}
	} else {
	$body->addLinkSection(
	pht('ORDER DETAIL'),
	PhabricatorEnv::getProductionURI($object->getDetailURI()));
	}

	$account_uri = '/phortune/'.$object->getAccount()->getID().'/';
	$body->addLinkSection(
	pht('ACCOUNT OVERVIEW'),
	PhabricatorEnv::getProductionURI($account_uri));

	return $body;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();

	// Reload the cart to pull merchant and account information, in case we
	// just created the object.
	$cart = id(new PhortuneCartQuery())
	->setViewer($this->requireActor())
	->withPHIDs(array($object->getPHID()))
	->executeOne();

	foreach ($cart->getAccount()->getMemberPHIDs() as $account_member) {
	$phids[] = $account_member;
	}

	foreach ($cart->getMerchant()->getMemberPHIDs() as $merchant_member) {
	$phids[] = $merchant_member;
	}

	return $phids;
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	return array();
	}

	protected function getMailSubjectPrefix() {
	return '[Phortune]';
	}

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

	protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
	// We need the purchases in order to build mail.
	return id(new PhortuneCartQuery())
	->setViewer($this->getActor())
	->withIDs(array($object->getID()))
	->needPurchases(true)
	->executeOne();
	}

	protected function getCustomWorkerState() {
	return array(
	'invoiceIssues' => $this->invoiceIssues,
	);
	}

	protected function loadCustomWorkerState(array $state) {
	$this->invoiceIssues = idx($state, 'invoiceIssues');
	return $this;
	}

	}
	diff --git a/src/applications/phriction/editor/PhrictionTransactionEditor.php b/src/applications/phriction/editor/PhrictionTransactionEditor.php
	index fcc9fe0474..73aee3fd4c 100644
	--- a/src/applications/phriction/editor/PhrictionTransactionEditor.php
	+++ b/src/applications/phriction/editor/PhrictionTransactionEditor.php
	@@ -1,621 +1,619 @@
	<?php

	final class PhrictionTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	const VALIDATE_CREATE_ANCESTRY = 'create';
	const VALIDATE_MOVE_ANCESTRY = 'move';

	private $description;
	private $oldContent;
	private $newContent;
	private $moveAwayDocument;
	private $skipAncestorCheck;
	private $contentVersion;
	private $processContentVersionError = true;
	private $contentDiffURI;

	public function setDescription($description) {
	$this->description = $description;
	return $this;
	}

	private function getDescription() {
	return $this->description;
	}

	private function setOldContent(PhrictionContent $content) {
	$this->oldContent = $content;
	return $this;
	}

	public function getOldContent() {
	return $this->oldContent;
	}

	private function setNewContent(PhrictionContent $content) {
	$this->newContent = $content;
	return $this;
	}

	public function getNewContent() {
	return $this->newContent;
	}

	public function setSkipAncestorCheck($bool) {
	$this->skipAncestorCheck = $bool;
	return $this;
	}

	public function getSkipAncestorCheck() {
	return $this->skipAncestorCheck;
	}

	public function setContentVersion($version) {
	$this->contentVersion = $version;
	return $this;
	}

	public function getContentVersion() {
	return $this->contentVersion;
	}

	public function setProcessContentVersionError($process) {
	$this->processContentVersionError = $process;
	return $this;
	}

	public function getProcessContentVersionError() {
	return $this->processContentVersionError;
	}

	public function setMoveAwayDocument(PhrictionDocument $document) {
	$this->moveAwayDocument = $document;
	return $this;
	}

	public function getEditorApplicationClass() {
	return 'PhabricatorPhrictionApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Phriction Documents');
	}

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

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

	return $types;
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhrictionDocumentTitleTransaction::TRANSACTIONTYPE:
	case PhrictionDocumentContentTransaction::TRANSACTIONTYPE:
	case PhrictionDocumentDeleteTransaction::TRANSACTIONTYPE:
	case PhrictionDocumentMoveToTransaction::TRANSACTIONTYPE:
	case PhrictionDocumentMoveAwayTransaction::TRANSACTIONTYPE:
	return true;
	}
	}
	return parent::shouldApplyInitialEffects($object, $xactions);
	}

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

	$this->setOldContent($object->getContent());
	$this->setNewContent($this->buildNewContentTemplate($object));
	}

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

	$xactions = parent::expandTransaction($object, $xaction);
	switch ($xaction->getTransactionType()) {
	case PhrictionDocumentContentTransaction::TRANSACTIONTYPE:
	if ($this->getIsNewObject()) {
	break;
	}
	$content = $xaction->getNewValue();
	if ($content === '') {
	$xactions[] = id(new PhrictionTransaction())
	->setTransactionType(
	PhrictionDocumentDeleteTransaction::TRANSACTIONTYPE)
	->setNewValue(true)
	->setMetadataValue('contentDelete', true);
	}
	break;
	case PhrictionDocumentMoveToTransaction::TRANSACTIONTYPE:
	$document = $xaction->getNewValue();
	$xactions[] = id(new PhrictionTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
	->setNewValue($document->getViewPolicy());
	$xactions[] = id(new PhrictionTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDIT_POLICY)
	->setNewValue($document->getEditPolicy());
	break;
	default:
	break;

	}

	return $xactions;
	}

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

	$save_content = false;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhrictionDocumentTitleTransaction::TRANSACTIONTYPE:
	case PhrictionDocumentMoveToTransaction::TRANSACTIONTYPE:
	case PhrictionDocumentMoveAwayTransaction::TRANSACTIONTYPE:
	case PhrictionDocumentDeleteTransaction::TRANSACTIONTYPE:
	case PhrictionDocumentContentTransaction::TRANSACTIONTYPE:
	$save_content = true;
	break;
	default:
	break;
	}
	}

	if ($save_content) {
	$content = $this->getNewContent();
	$content->setDocumentID($object->getID());
	$content->save();

	$object->setContentID($content->getID());
	$object->save();
	$object->attachContent($content);
	}

	if ($this->getIsNewObject() && !$this->getSkipAncestorCheck()) {
	// Stub out empty parent documents if they don't exist
	$ancestral_slugs = PhabricatorSlug::getAncestry($object->getSlug());
	if ($ancestral_slugs) {
	$ancestors = id(new PhrictionDocumentQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withSlugs($ancestral_slugs)
	->needContent(true)
	->execute();
	$ancestors = mpull($ancestors, null, 'getSlug');
	$stub_type = PhrictionChangeType::CHANGE_STUB;
	foreach ($ancestral_slugs as $slug) {
	$ancestor_doc = idx($ancestors, $slug);
	// We check for change type to prevent near-infinite recursion
	if (!$ancestor_doc && $content->getChangeType() != $stub_type) {
	$ancestor_doc = PhrictionDocument::initializeNewDocument(
	$this->getActor(),
	$slug);
	$stub_xactions = array();
	$stub_xactions[] = id(new PhrictionTransaction())
	->setTransactionType(
	PhrictionDocumentTitleTransaction::TRANSACTIONTYPE)
	->setNewValue(PhabricatorSlug::getDefaultTitle($slug))
	->setMetadataValue('stub:create:phid', $object->getPHID());
	$stub_xactions[] = id(new PhrictionTransaction())
	->setTransactionType(
	PhrictionDocumentContentTransaction::TRANSACTIONTYPE)
	->setNewValue('')
	->setMetadataValue('stub:create:phid', $object->getPHID());
	$stub_xactions[] = id(new PhrictionTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
	->setNewValue($object->getViewPolicy());
	$stub_xactions[] = id(new PhrictionTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDIT_POLICY)
	->setNewValue($object->getEditPolicy());
	$sub_editor = id(new PhrictionTransactionEditor())
	->setActor($this->getActor())
	->setContentSource($this->getContentSource())
	->setContinueOnNoEffect($this->getContinueOnNoEffect())
	->setSkipAncestorCheck(true)
	->setDescription(pht('Empty Parent Document'))
	->applyTransactions($ancestor_doc, $stub_xactions);
	}
	}
	}
	}

	if ($this->moveAwayDocument !== null) {
	$move_away_xactions = array();
	$move_away_xactions[] = id(new PhrictionTransaction())
	->setTransactionType(
	PhrictionDocumentMoveAwayTransaction::TRANSACTIONTYPE)
	->setNewValue($object);
	$sub_editor = id(new PhrictionTransactionEditor())
	->setActor($this->getActor())
	->setContentSource($this->getContentSource())
	->setContinueOnNoEffect($this->getContinueOnNoEffect())
	->setDescription($this->getDescription())
	->applyTransactions($this->moveAwayDocument, $move_away_xactions);
	}

	// Compute the content diff URI for the publishing phase.
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhrictionDocumentContentTransaction::TRANSACTIONTYPE:
	$uri = id(new PhutilURI('/phriction/diff/'.$object->getID().'/'))
	->alter('l', $this->getOldContent()->getVersion())
	->alter('r', $this->getNewContent()->getVersion());
	$this->contentDiffURI = (string)$uri;
	break 2;
	default:
	break;
	}
	}

	return $xactions;
	}

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

	protected function getMailSubjectPrefix() {
	return '[Phriction]';
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getContent()->getAuthorPHID(),
	$this->getActingAsPHID(),
	);
	}

	public function getMailTagsMap() {
	return array(
	PhrictionTransaction::MAILTAG_TITLE =>
	pht("A document's title changes."),
	PhrictionTransaction::MAILTAG_CONTENT =>
	pht("A document's content changes."),
	PhrictionTransaction::MAILTAG_DELETE =>
	pht('A document is deleted.'),
	PhrictionTransaction::MAILTAG_SUBSCRIBERS =>
	pht('A document\'s subscribers change.'),
	PhrictionTransaction::MAILTAG_OTHER =>
	pht('Other document activity not listed above occurs.'),
	);
	}

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

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

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject($title)
	- ->addHeader('Thread-Topic', $object->getPHID());
	+ ->setSubject($title);
	}

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

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

	if ($this->getIsNewObject()) {
	$body->addRemarkupSection(
	pht('DOCUMENT CONTENT'),
	$object->getContent()->getContent());
	} else if ($this->contentDiffURI) {
	$body->addLinkSection(
	pht('DOCUMENT DIFF'),
	PhabricatorEnv::getProductionURI($this->contentDiffURI));
	}

	$description = $object->getContent()->getDescription();
	if (strlen($description)) {
	$body->addTextSection(
	pht('EDIT NOTES'),
	$description);
	}

	$body->addLinkSection(
	pht('DOCUMENT DETAIL'),
	PhabricatorEnv::getProductionURI(
	PhrictionDocument::getSlugURI($object->getSlug())));

	return $body;
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldSendMail($object, $xactions);
	}

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

	$phids = parent::getFeedRelatedPHIDs($object, $xactions);

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhrictionDocumentMoveToTransaction::TRANSACTIONTYPE:
	$dict = $xaction->getNewValue();
	$phids[] = $dict['phid'];
	break;
	}
	}

	return $phids;
	}

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

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

	foreach ($xactions as $xaction) {
	switch ($type) {
	case PhrictionDocumentContentTransaction::TRANSACTIONTYPE:
	if ($xaction->getMetadataValue('stub:create:phid')) {
	continue;
	}

	if ($this->getProcessContentVersionError()) {
	$error = $this->validateContentVersion($object, $type, $xaction);
	if ($error) {
	$this->setProcessContentVersionError(false);
	$errors[] = $error;
	}
	}

	if ($this->getIsNewObject()) {
	$ancestry_errors = $this->validateAncestry(
	$object,
	$type,
	$xaction,
	self::VALIDATE_CREATE_ANCESTRY);
	if ($ancestry_errors) {
	$errors = array_merge($errors, $ancestry_errors);
	}
	}
	break;

	case PhrictionDocumentMoveToTransaction::TRANSACTIONTYPE:
	$source_document = $xaction->getNewValue();

	$ancestry_errors = $this->validateAncestry(
	$object,
	$type,
	$xaction,
	self::VALIDATE_MOVE_ANCESTRY);
	if ($ancestry_errors) {
	$errors = array_merge($errors, $ancestry_errors);
	}

	$target_document = id(new PhrictionDocumentQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withSlugs(array($object->getSlug()))
	->needContent(true)
	->executeOne();

	// Prevent overwrites and no-op moves.
	$exists = PhrictionDocumentStatus::STATUS_EXISTS;
	if ($target_document) {
	$message = null;
	if ($target_document->getSlug() == $source_document->getSlug()) {
	$message = pht(
	'You can not move a document to its existing location. '.
	'Choose a different location to move the document to.');
	} else if ($target_document->getStatus() == $exists) {
	$message = pht(
	'You can not move this document there, because it would '.
	'overwrite an existing document which is already at that '.
	'location. Move or delete the existing document first.');
	}
	if ($message !== null) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	$message,
	$xaction);
	$errors[] = $error;
	}
	}
	break;

	}
	}

	return $errors;
	}

	public function validateAncestry(
	PhabricatorLiskDAO $object,
	$type,
	PhabricatorApplicationTransaction $xaction,
	$verb) {

	$errors = array();
	// NOTE: We use the omnipotent user for these checks because policy
	// doesn't matter; existence does.
	$other_doc_viewer = PhabricatorUser::getOmnipotentUser();
	$ancestral_slugs = PhabricatorSlug::getAncestry($object->getSlug());
	if ($ancestral_slugs) {
	$ancestors = id(new PhrictionDocumentQuery())
	->setViewer($other_doc_viewer)
	->withSlugs($ancestral_slugs)
	->execute();
	$ancestors = mpull($ancestors, null, 'getSlug');
	foreach ($ancestral_slugs as $slug) {
	$ancestor_doc = idx($ancestors, $slug);
	if (!$ancestor_doc) {
	$create_uri = '/phriction/edit/?slug='.$slug;
	$create_link = phutil_tag(
	'a',
	array(
	'href' => $create_uri,
	),
	$slug);
	switch ($verb) {
	case self::VALIDATE_MOVE_ANCESTRY:
	$message = pht(
	'Can not move document because the parent document with '.
	'slug %s does not exist!',
	$create_link);
	break;
	case self::VALIDATE_CREATE_ANCESTRY:
	$message = pht(
	'Can not create document because the parent document with '.
	'slug %s does not exist!',
	$create_link);
	break;
	}
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Missing Ancestor'),
	$message,
	$xaction);
	$errors[] = $error;
	}
	}
	}
	return $errors;
	}

	private function validateContentVersion(
	PhabricatorLiskDAO $object,
	$type,
	PhabricatorApplicationTransaction $xaction) {

	$error = null;
	if ($this->getContentVersion() &&
	($object->getContent()->getVersion() != $this->getContentVersion())) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Edit Conflict'),
	pht(
	'Another user made changes to this document after you began '.
	'editing it. Do you want to overwrite their changes? '.
	'(If you choose to overwrite their changes, you should review '.
	'the document edit history to see what you overwrote, and '.
	'then make another edit to merge the changes if necessary.)'),
	$xaction);
	}
	return $error;
	}
	protected function requireCapabilities(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	/*
	* New objects have a special case. If a user can't see
	* x/y
	* then definitely don't let them make some
	* x/y/z
	* We need to load the direct parent to handle this case.
	*/
	if ($this->getIsNewObject()) {
	$actor = $this->requireActor();
	$parent_doc = null;
	$ancestral_slugs = PhabricatorSlug::getAncestry($object->getSlug());
	// No ancestral slugs is "/"; the first person gets to play with "/".
	if ($ancestral_slugs) {
	$parent = end($ancestral_slugs);
	$parent_doc = id(new PhrictionDocumentQuery())
	->setViewer($actor)
	->withSlugs(array($parent))
	->executeOne();
	// If the $actor can't see the $parent_doc then they can't create
	// the child $object; throw a policy exception.
	if (!$parent_doc) {
	id(new PhabricatorPolicyFilter())
	->setViewer($actor)
	->raisePolicyExceptions(true)
	->rejectObject(
	$object,
	$object->getEditPolicy(),
	PhabricatorPolicyCapability::CAN_EDIT);
	}

	// If the $actor can't edit the $parent_doc then they can't create
	// the child $object; throw a policy exception.
	if (!PhabricatorPolicyFilter::hasCapability(
	$actor,
	$parent_doc,
	PhabricatorPolicyCapability::CAN_EDIT)) {
	id(new PhabricatorPolicyFilter())
	->setViewer($actor)
	->raisePolicyExceptions(true)
	->rejectObject(
	$object,
	$object->getEditPolicy(),
	PhabricatorPolicyCapability::CAN_EDIT);
	}
	}
	}
	return parent::requireCapabilities($object, $xaction);
	}

	protected function supportsSearch() {
	return true;
	}

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

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

	return id(new PhrictionDocumentHeraldAdapter())
	->setDocument($object);
	}

	private function buildNewContentTemplate(
	PhrictionDocument $document) {

	$new_content = id(new PhrictionContent())
	->setSlug($document->getSlug())
	->setAuthorPHID($this->getActor()->getPHID())
	->setChangeType(PhrictionChangeType::CHANGE_EDIT)
	->setTitle($this->getOldContent()->getTitle())
	->setContent($this->getOldContent()->getContent());
	if (strlen($this->getDescription())) {
	$new_content->setDescription($this->getDescription());
	}
	$new_content->setVersion($this->getOldContent()->getVersion() + 1);

	return $new_content;
	}

	protected function getCustomWorkerState() {
	return array(
	'contentDiffURI' => $this->contentDiffURI,
	);
	}

	protected function loadCustomWorkerState(array $state) {
	$this->contentDiffURI = idx($state, 'contentDiffURI');
	return $this;
	}

	}
	diff --git a/src/applications/phurl/editor/PhabricatorPhurlURLEditor.php b/src/applications/phurl/editor/PhabricatorPhurlURLEditor.php
	index 439d62f84a..49f290c343 100644
	--- a/src/applications/phurl/editor/PhabricatorPhurlURLEditor.php
	+++ b/src/applications/phurl/editor/PhabricatorPhurlURLEditor.php
	@@ -1,116 +1,115 @@
	<?php

	final class PhabricatorPhurlURLEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorPhurlApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Phurl');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this URL.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

	protected function supportsSearch() {
	return true;
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();
	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;

	return $types;
	}

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

	public function getMailTagsMap() {
	return array(
	PhabricatorPhurlURLTransaction::MAILTAG_DETAILS =>
	pht(
	"A URL's details change."),
	);
	}

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

	protected function getMailSubjectPrefix() {
	return pht('[Phurl]');
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();
	$phids[] = $this->getActingAsPHID();

	return $phids;
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$name = $object->getName();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("U{$id}: {$name}")
	- ->addHeader('Thread-Topic', "U{$id}: ".$object->getName());
	+ ->setSubject("U{$id}: {$name}");
	}

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

	$description = $object->getDescription();
	$body = parent::buildMailBody($object, $xactions);

	if (strlen($description)) {
	$body->addRemarkupSection(
	pht('URL DESCRIPTION'),
	$object->getDescription());
	}

	$body->addLinkSection(
	pht('URL DETAIL'),
	PhabricatorEnv::getProductionURI('/U'.$object->getID()));


	return $body;
	}

	protected function didCatchDuplicateKeyException(
	PhabricatorLiskDAO $object,
	array $xactions,
	Exception $ex) {

	$errors = array();
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	PhabricatorPhurlURLAliasTransaction::TRANSACTIONTYPE,
	pht('Duplicate'),
	pht('This alias is already in use.'),
	null);

	throw new PhabricatorApplicationTransactionValidationException($errors);
	}

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

	}
	diff --git a/src/applications/ponder/editor/PonderAnswerEditor.php b/src/applications/ponder/editor/PonderAnswerEditor.php
	index bab0e1f72d..37b2fe2cd0 100644
	--- a/src/applications/ponder/editor/PonderAnswerEditor.php
	+++ b/src/applications/ponder/editor/PonderAnswerEditor.php
	@@ -1,86 +1,85 @@
	<?php

	final class PonderAnswerEditor extends PonderEditor {

	public function getEditorObjectsDescription() {
	return pht('Ponder Answers');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s added this answer.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s added %s.', $author, $object);
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();
	$types[] = PhabricatorTransactions::TYPE_COMMENT;

	return $types;
	}

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

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();
	$phids[] = $object->getAuthorPHID();
	$phids[] = $this->requireActor()->getPHID();

	$question = id(new PonderQuestionQuery())
	->setViewer($this->requireActor())
	->withIDs(array($object->getQuestionID()))
	->executeOne();

	$phids[] = $question->getAuthorPHID();

	return $phids;
	}

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

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

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

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("ANSR{$id}")
	- ->addHeader('Thread-Topic', "ANSR{$id}");
	+ ->setSubject("ANSR{$id}");
	}

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

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

	// If the user just gave the answer, add the answer text.
	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	$new = $xaction->getNewValue();
	if ($type == PonderAnswerContentTransaction::TRANSACTIONTYPE) {
	$body->addRawSection($new);
	}
	}

	$body->addLinkSection(
	pht('ANSWER DETAIL'),
	PhabricatorEnv::getProductionURI($object->getURI()));

	return $body;
	}

	}
	diff --git a/src/applications/ponder/editor/PonderQuestionEditor.php b/src/applications/ponder/editor/PonderQuestionEditor.php
	index 0720f436b9..ba9687bd0d 100644
	--- a/src/applications/ponder/editor/PonderQuestionEditor.php
	+++ b/src/applications/ponder/editor/PonderQuestionEditor.php
	@@ -1,197 +1,195 @@
	<?php

	final class PonderQuestionEditor
	extends PonderEditor {

	private $answer;

	public function getEditorObjectsDescription() {
	return pht('Ponder Questions');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s asked this question.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s asked %s.', $author, $object);
	}

	/**
	* This is used internally on @{method:applyInitialEffects} if a transaction
	* of type PonderQuestionTransaction::TYPE_ANSWERS is in the mix. The value
	* is set to the //last// answer in the transactions. Practically, one
	* answer is given at a time in the application, though theoretically
	* this is buggy.
	*
	* The answer is used in emails to generate proper links.
	*/
	private function setAnswer(PonderAnswer $answer) {
	$this->answer = $answer;
	return $this;
	}
	private function getAnswer() {
	return $this->answer;
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PonderQuestionAnswerTransaction::TRANSACTIONTYPE:
	return true;
	}
	}

	return false;
	}

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

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PonderQuestionAnswerTransaction::TRANSACTIONTYPE:
	$new_value = $xaction->getNewValue();
	$new = idx($new_value, '+', array());
	foreach ($new as $new_answer) {
	$answer = idx($new_answer, 'answer');
	if (!$answer) {
	continue;
	}
	$answer->save();
	$this->setAnswer($answer);
	}
	break;
	}
	}
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();
	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;

	return $types;
	}

	protected function supportsSearch() {
	return true;
	}

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

	switch ($xaction->getTransactionType()) {
	case PonderQuestionAnswerTransaction::TRANSACTIONTYPE:
	return false;
	}

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

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PonderQuestionAnswerTransaction::TRANSACTIONTYPE:
	return false;
	}
	}
	return true;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getAuthorPHID(),
	$this->requireActor()->getPHID(),
	);
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PonderQuestionAnswerTransaction::TRANSACTIONTYPE:
	return false;
	}
	}
	return true;
	}

	public function getMailTagsMap() {
	return array(
	PonderQuestionTransaction::MAILTAG_DETAILS =>
	pht('Someone changes the questions details.'),
	PonderQuestionTransaction::MAILTAG_ANSWERS =>
	pht('Someone adds a new answer.'),
	PonderQuestionTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on the question.'),
	PonderQuestionTransaction::MAILTAG_OTHER =>
	pht('Other question activity not listed above occurs.'),
	);
	}

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

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

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("Q{$id}: {$title}")
	- ->addHeader('Thread-Topic', "Q{$id}: {$original_title}");
	+ ->setSubject("Q{$id}: {$title}");
	}

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

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

	$header = pht('QUESTION DETAIL');
	$uri = '/Q'.$object->getID();
	foreach ($xactions as $xaction) {
	$type = $xaction->getTransactionType();
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();
	// If the user just asked the question, add the question text.
	if ($type == PonderQuestionContentTransaction::TRANSACTIONTYPE) {
	if ($old === null) {
	$body->addRawSection($new);
	}
	}
	}

	$body->addLinkSection(
	$header,
	PhabricatorEnv::getProductionURI($uri));

	return $body;
	}

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

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

	return id(new HeraldPonderQuestionAdapter())
	->setQuestion($object);
	}

	}
	diff --git a/src/applications/project/editor/PhabricatorProjectTransactionEditor.php b/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
	index 2764ce6322..de61c2a09b 100644
	--- a/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
	+++ b/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
	@@ -1,476 +1,474 @@
	<?php

	final class PhabricatorProjectTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	private $isMilestone;

	private function setIsMilestone($is_milestone) {
	$this->isMilestone = $is_milestone;
	return $this;
	}

	public function getIsMilestone() {
	return $this->isMilestone;
	}

	public function getEditorApplicationClass() {
	return 'PhabricatorProjectApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Projects');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this project.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

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

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

	return $types;
	}

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

	$errors = array();

	// Prevent creating projects which are both subprojects and milestones,
	// since this does not make sense, won't work, and will break everything.
	$parent_xaction = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectParentTransaction::TRANSACTIONTYPE:
	case PhabricatorProjectMilestoneTransaction::TRANSACTIONTYPE:
	if ($xaction->getNewValue() === null) {
	continue;
	}

	if (!$parent_xaction) {
	$parent_xaction = $xaction;
	continue;
	}

	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$xaction->getTransactionType(),
	pht('Invalid'),
	pht(
	'When creating a project, specify a maximum of one parent '.
	'project or milestone project. A project can not be both a '.
	'subproject and a milestone.'),
	$xaction);
	break;
	break;
	}
	}

	$is_milestone = $this->getIsMilestone();

	$is_parent = $object->getHasSubprojects();

	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_EDGE:
	$type = $xaction->getMetadataValue('edge:type');
	if ($type != PhabricatorProjectProjectHasMemberEdgeType::EDGECONST) {
	break;
	}

	if ($is_parent) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$xaction->getTransactionType(),
	pht('Invalid'),
	pht(
	'You can not change members of a project with subprojects '.
	'directly. Members of any subproject are automatically '.
	'members of the parent project.'),
	$xaction);
	}

	if ($is_milestone) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$xaction->getTransactionType(),
	pht('Invalid'),
	pht(
	'You can not change members of a milestone. Members of the '.
	'parent project are automatically members of the milestone.'),
	$xaction);
	}
	break;
	}
	}

	return $errors;
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectLockTransaction::TRANSACTIONTYPE:
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	newv($this->getEditorApplicationClass(), array()),
	ProjectCanLockProjectsCapability::CAPABILITY);
	return;
	case PhabricatorTransactions::TYPE_EDGE:
	switch ($xaction->getMetadataValue('edge:type')) {
	case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	$add = array_keys(array_diff_key($new, $old));
	$rem = array_keys(array_diff_key($old, $new));

	$actor_phid = $this->requireActor()->getPHID();

	$is_join = (($add === array($actor_phid)) && !$rem);
	$is_leave = (($rem === array($actor_phid)) && !$add);

	if ($is_join) {
	// You need CAN_JOIN to join a project.
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_JOIN);
	} else if ($is_leave) {
	// You usually don't need any capabilities to leave a project.
	if ($object->getIsMembershipLocked()) {
	// you must be able to edit though to leave locked projects
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	}
	} else {
	// You need CAN_EDIT to change members other than yourself.
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	}
	return;
	}
	break;
	}

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

	protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
	// NOTE: We're using the omnipotent user here because the original actor
	// may no longer have permission to view the object.
	return id(new PhabricatorProjectQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($object->getPHID()))
	->needAncestorMembers(true)
	->executeOne();
	}

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

	protected function getMailSubjectPrefix() {
	return pht('[Project]');
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$this->getActingAsPHID(),
	);
	}

	protected function getMailCc(PhabricatorLiskDAO $object) {
	return array();
	}

	public function getMailTagsMap() {
	return array(
	PhabricatorProjectTransaction::MAILTAG_METADATA =>
	pht('Project name, hashtags, icon, image, or color changes.'),
	PhabricatorProjectTransaction::MAILTAG_MEMBERS =>
	pht('Project membership changes.'),
	PhabricatorProjectTransaction::MAILTAG_WATCHERS =>
	pht('Project watcher list changes.'),
	PhabricatorProjectTransaction::MAILTAG_OTHER =>
	pht('Other project activity not listed above occurs.'),
	);
	}

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	- $id = $object->getID();
	$name = $object->getName();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("{$name}")
	- ->addHeader('Thread-Topic', "Project {$id}");
	+ ->setSubject("{$name}");
	}

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

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

	$uri = '/project/profile/'.$object->getID().'/';
	$body->addLinkSection(
	pht('PROJECT DETAIL'),
	PhabricatorEnv::getProductionURI($uri));

	return $body;
	}

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

	protected function supportsSearch() {
	return true;
	}

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

	$materialize = false;
	$new_parent = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_EDGE:
	switch ($xaction->getMetadataValue('edge:type')) {
	case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
	$materialize = true;
	break;
	}
	break;
	case PhabricatorProjectParentTransaction::TRANSACTIONTYPE:
	case PhabricatorProjectMilestoneTransaction::TRANSACTIONTYPE:
	$materialize = true;
	$new_parent = $object->getParentProject();
	break;
	}
	}

	if ($new_parent) {
	// If we just created the first subproject of this parent, we want to
	// copy all of the real members to the subproject.
	if (!$new_parent->getHasSubprojects()) {
	$member_type = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;

	$project_members = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$new_parent->getPHID(),
	$member_type);

	if ($project_members) {
	$editor = id(new PhabricatorEdgeEditor());
	foreach ($project_members as $phid) {
	$editor->addEdge($object->getPHID(), $member_type, $phid);
	}
	$editor->save();
	}
	}
	}

	// TODO: We should dump an informational transaction onto the parent
	// project to show that we created the sub-thing.

	if ($materialize) {
	id(new PhabricatorProjectsMembershipIndexEngineExtension())
	->rematerialize($object);
	}

	if ($new_parent) {
	id(new PhabricatorProjectsMembershipIndexEngineExtension())
	->rematerialize($new_parent);
	}

	return parent::applyFinalEffects($object, $xactions);
	}

	public function addSlug(PhabricatorProject $project, $slug, $force) {
	$slug = PhabricatorSlug::normalizeProjectSlug($slug);
	$table = new PhabricatorProjectSlug();
	$project_phid = $project->getPHID();

	if ($force) {
	// If we have the `$force` flag set, we only want to ignore an existing
	// slug if it's for the same project. We'll error on collisions with
	// other projects.
	$current = $table->loadOneWhere(
	'slug = %s AND projectPHID = %s',
	$slug,
	$project_phid);
	} else {
	// Without the `$force` flag, we'll just return without doing anything
	// if any other project already has the slug.
	$current = $table->loadOneWhere(
	'slug = %s',
	$slug);
	}

	if ($current) {
	return;
	}

	return id(new PhabricatorProjectSlug())
	->setSlug($slug)
	->setProjectPHID($project_phid)
	->save();
	}

	public function removeSlugs(PhabricatorProject $project, array $slugs) {
	if (!$slugs) {
	return;
	}

	// We're going to try to delete both the literal and normalized versions
	// of all slugs. This allows us to destroy old slugs that are no longer
	// valid.
	foreach ($this->normalizeSlugs($slugs) as $slug) {
	$slugs[] = $slug;
	}

	$objects = id(new PhabricatorProjectSlug())->loadAllWhere(
	'projectPHID = %s AND slug IN (%Ls)',
	$project->getPHID(),
	$slugs);

	foreach ($objects as $object) {
	$object->delete();
	}
	}

	public function normalizeSlugs(array $slugs) {
	foreach ($slugs as $key => $slug) {
	$slugs[$key] = PhabricatorSlug::normalizeProjectSlug($slug);
	}

	$slugs = array_unique($slugs);
	$slugs = array_values($slugs);

	return $slugs;
	}

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

	$copy = parent::adjustObjectForPolicyChecks($object, $xactions);

	$type_edge = PhabricatorTransactions::TYPE_EDGE;
	$edgetype_member = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;

	$member_xaction = null;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() !== $type_edge) {
	continue;
	}

	$edgetype = $xaction->getMetadataValue('edge:type');
	if ($edgetype !== $edgetype_member) {
	continue;
	}

	$member_xaction = $xaction;
	}

	if ($member_xaction) {
	$object_phid = $object->getPHID();

	if ($object_phid) {
	$project = id(new PhabricatorProjectQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($object_phid))
	->needMembers(true)
	->executeOne();
	$members = $project->getMemberPHIDs();
	} else {
	$members = array();
	}

	$clone_xaction = clone $member_xaction;
	$hint = $this->getPHIDTransactionNewValue($clone_xaction, $members);
	$rule = new PhabricatorProjectMembersPolicyRule();

	$hint = array_fuse($hint);

	PhabricatorPolicyRule::passTransactionHintToRule(
	$copy,
	$rule,
	$hint);
	}

	return $copy;
	}

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

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

	$results = parent::expandTransactions($object, $xactions);

	$is_milestone = $object->isMilestone();
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectMilestoneTransaction::TRANSACTIONTYPE:
	if ($xaction->getNewValue() !== null) {
	$is_milestone = true;
	}
	break;
	}
	}

	$this->setIsMilestone($is_milestone);

	return $results;
	}

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

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

	// Herald rules may run on behalf of other users and need to execute
	// membership checks against ancestors.
	$project = id(new PhabricatorProjectQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($object->getPHID()))
	->needAncestorMembers(true)
	->executeOne();

	return id(new PhabricatorProjectHeraldAdapter())
	->setProject($project);
	}

	}
	diff --git a/src/applications/releeph/editor/ReleephRequestTransactionalEditor.php b/src/applications/releeph/editor/ReleephRequestTransactionalEditor.php
	index 4710557043..da488d9c72 100644
	--- a/src/applications/releeph/editor/ReleephRequestTransactionalEditor.php
	+++ b/src/applications/releeph/editor/ReleephRequestTransactionalEditor.php
	@@ -1,309 +1,307 @@
	<?php

	final class ReleephRequestTransactionalEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorReleephApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Releeph Requests');
	}

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

	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = ReleephRequestTransaction::TYPE_COMMIT;
	$types[] = ReleephRequestTransaction::TYPE_DISCOVERY;
	$types[] = ReleephRequestTransaction::TYPE_EDIT_FIELD;
	$types[] = ReleephRequestTransaction::TYPE_MANUAL_IN_BRANCH;
	$types[] = ReleephRequestTransaction::TYPE_PICK_STATUS;
	$types[] = ReleephRequestTransaction::TYPE_REQUEST;
	$types[] = ReleephRequestTransaction::TYPE_USER_INTENT;

	return $types;
	}

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

	switch ($xaction->getTransactionType()) {
	case ReleephRequestTransaction::TYPE_REQUEST:
	return $object->getRequestCommitPHID();

	case ReleephRequestTransaction::TYPE_EDIT_FIELD:
	$field = newv($xaction->getMetadataValue('fieldClass'), array());
	$value = $field->setReleephRequest($object)->getValue();
	return $value;

	case ReleephRequestTransaction::TYPE_USER_INTENT:
	$user_phid = $xaction->getAuthorPHID();
	return idx($object->getUserIntents(), $user_phid);

	case ReleephRequestTransaction::TYPE_PICK_STATUS:
	return (int)$object->getPickStatus();
	break;

	case ReleephRequestTransaction::TYPE_COMMIT:
	return $object->getCommitIdentifier();

	case ReleephRequestTransaction::TYPE_DISCOVERY:
	return $object->getCommitPHID();

	case ReleephRequestTransaction::TYPE_MANUAL_IN_BRANCH:
	return $object->getInBranch();
	}
	}

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

	switch ($xaction->getTransactionType()) {
	case ReleephRequestTransaction::TYPE_REQUEST:
	case ReleephRequestTransaction::TYPE_USER_INTENT:
	case ReleephRequestTransaction::TYPE_EDIT_FIELD:
	case ReleephRequestTransaction::TYPE_PICK_STATUS:
	case ReleephRequestTransaction::TYPE_COMMIT:
	case ReleephRequestTransaction::TYPE_DISCOVERY:
	case ReleephRequestTransaction::TYPE_MANUAL_IN_BRANCH:
	return $xaction->getNewValue();
	}
	}

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

	$new = $xaction->getNewValue();

	switch ($xaction->getTransactionType()) {
	case ReleephRequestTransaction::TYPE_REQUEST:
	$object->setRequestCommitPHID($new);
	break;

	case ReleephRequestTransaction::TYPE_USER_INTENT:
	$user_phid = $xaction->getAuthorPHID();
	$intents = $object->getUserIntents();
	$intents[$user_phid] = $new;
	$object->setUserIntents($intents);
	break;

	case ReleephRequestTransaction::TYPE_EDIT_FIELD:
	$field = newv($xaction->getMetadataValue('fieldClass'), array());
	$field
	->setReleephRequest($object)
	->setValue($new);
	break;

	case ReleephRequestTransaction::TYPE_PICK_STATUS:
	$object->setPickStatus($new);
	break;

	case ReleephRequestTransaction::TYPE_COMMIT:
	$this->setInBranchFromAction($object, $xaction);
	$object->setCommitIdentifier($new);
	break;

	case ReleephRequestTransaction::TYPE_DISCOVERY:
	$this->setInBranchFromAction($object, $xaction);
	$object->setCommitPHID($new);
	break;

	case ReleephRequestTransaction::TYPE_MANUAL_IN_BRANCH:
	$object->setInBranch((int)$new);
	break;
	}
	}

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

	return;
	}

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

	// Remove TYPE_DISCOVERY xactions that are the result of a reparse.
	$previously_discovered_commits = array();
	$discovery_xactions = idx(
	mgroup($xactions, 'getTransactionType'),
	ReleephRequestTransaction::TYPE_DISCOVERY);
	if ($discovery_xactions) {
	$previous_xactions = id(new ReleephRequestTransactionQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withObjectPHIDs(array($object->getPHID()))
	->execute();

	foreach ($previous_xactions as $xaction) {
	if ($xaction->getTransactionType() ===
	ReleephRequestTransaction::TYPE_DISCOVERY) {

	$commit_phid = $xaction->getNewValue();
	$previously_discovered_commits[$commit_phid] = true;
	}
	}
	}

	foreach ($xactions as $key => $xaction) {
	if ($xaction->getTransactionType() ===
	ReleephRequestTransaction::TYPE_DISCOVERY &&
	idx($previously_discovered_commits, $xaction->getNewValue())) {

	unset($xactions[$key]);
	}
	}

	return parent::filterTransactions($object, $xactions);
	}

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

	// Avoid sending emails that only talk about commit discovery.
	$types = array_unique(mpull($xactions, 'getTransactionType'));
	if ($types === array(ReleephRequestTransaction::TYPE_DISCOVERY)) {
	return false;
	}

	// Don't email people when we discover that something picks or reverts OK.
	if ($types === array(ReleephRequestTransaction::TYPE_PICK_STATUS)) {
	if (!mfilter($xactions, 'isBoringPickStatus', true /* negate */)) {
	// If we effectively call "isInterestingPickStatus" and get nothing...
	return false;
	}
	}

	return true;
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	return id(new ReleephRequestReplyHandler())
	->setActor($this->getActor())
	->setMailReceiver($object);
	}

	protected function getMailSubjectPrefix() {
	return '[Releeph]';
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	- $phid = $object->getPHID();
	$title = $object->getSummaryForDisplay();
	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("RQ{$id}: {$title}")
	- ->addHeader('Thread-Topic', "RQ{$id}: {$phid}");
	+ ->setSubject("RQ{$id}: {$title}");
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$to_phids = array();

	$product = $object->getBranch()->getProduct();
	foreach ($product->getPushers() as $phid) {
	$to_phids[] = $phid;
	}

	foreach ($object->getUserIntents() as $phid => $intent) {
	$to_phids[] = $phid;
	}

	return $to_phids;
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	return array();
	}

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

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

	$rq = $object;
	$releeph_branch = $rq->getBranch();
	$releeph_project = $releeph_branch->getProduct();

	/**
	* If any of the events we are emailing about were about a pick failure
	* (and/or a revert failure?), include pick failure instructions.
	*/
	$has_pick_failure = false;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() ===
	ReleephRequestTransaction::TYPE_PICK_STATUS &&
	$xaction->getNewValue() === ReleephRequest::PICK_FAILED) {

	$has_pick_failure = true;
	break;
	}
	}
	if ($has_pick_failure) {
	$instructions = $releeph_project->getDetail('pick_failure_instructions');
	if ($instructions) {
	$body->addRemarkupSection(
	pht('PICK FAILURE INSTRUCTIONS'),
	$instructions);
	}
	}

	$name = sprintf('RQ%s: %s', $rq->getID(), $rq->getSummaryForDisplay());
	$body->addTextSection(
	pht('RELEEPH REQUEST'),
	$name."\n".
	PhabricatorEnv::getProductionURI('/RQ'.$rq->getID()));

	$project_and_branch = sprintf(
	'%s - %s',
	$releeph_project->getName(),
	$releeph_branch->getDisplayNameWithDetail());

	$body->addTextSection(
	pht('RELEEPH BRANCH'),
	$project_and_branch."\n".
	PhabricatorEnv::getProductionURI($releeph_branch->getURI()));

	return $body;
	}

	private function setInBranchFromAction(
	ReleephRequest $rq,
	ReleephRequestTransaction $xaction) {

	$action = $xaction->getMetadataValue('action');
	switch ($action) {
	case 'pick':
	$rq->setInBranch(1);
	break;

	case 'revert':
	$rq->setInBranch(0);
	break;

	default:
	$id = $rq->getID();
	$type = $xaction->getTransactionType();
	$new = $xaction->getNewValue();
	phlog(
	pht(
	"Unknown discovery action '%s' for xaction of type %s ".
	"with new value %s mentioning %s!",
	$action,
	$type,
	$new,
	'RQ'.$id));
	break;
	}

	return $this;
	}

	}
	diff --git a/src/applications/repository/worker/PhabricatorRepositoryPushMailWorker.php b/src/applications/repository/worker/PhabricatorRepositoryPushMailWorker.php
	index 17226a1377..5ffaf0a5c2 100644
	--- a/src/applications/repository/worker/PhabricatorRepositoryPushMailWorker.php
	+++ b/src/applications/repository/worker/PhabricatorRepositoryPushMailWorker.php
	@@ -1,226 +1,225 @@
	<?php

	final class PhabricatorRepositoryPushMailWorker
	extends PhabricatorWorker {

	protected function doWork() {
	$viewer = PhabricatorUser::getOmnipotentUser();

	$task_data = $this->getTaskData();

	$email_phids = idx($task_data, 'emailPHIDs');
	if (!$email_phids) {
	// If we don't have any email targets, don't send any email.
	return;
	}

	$event_phid = idx($task_data, 'eventPHID');
	$event = id(new PhabricatorRepositoryPushEventQuery())
	->setViewer($viewer)
	->withPHIDs(array($event_phid))
	->needLogs(true)
	->executeOne();

	$repository = $event->getRepository();
	if (!$repository->shouldPublish()) {
	// If the repository is still importing, don't send email.
	return;
	}

	$targets = id(new PhabricatorRepositoryPushReplyHandler())
	->setMailReceiver($repository)
	->getMailTargets($email_phids, array());

	$messages = array();
	foreach ($targets as $target) {
	$messages[] = $this->sendMail($target, $repository, $event);
	}

	foreach ($messages as $message) {
	$message->save();
	}
	}

	private function sendMail(
	PhabricatorMailTarget $target,
	PhabricatorRepository $repository,
	PhabricatorRepositoryPushEvent $event) {

	$task_data = $this->getTaskData();
	$viewer = $target->getViewer();

	$locale = PhabricatorEnv::beginScopedLocale($viewer->getTranslation());

	$logs = $event->getLogs();

	list($ref_lines, $ref_list) = $this->renderRefs($logs);
	list($commit_lines, $subject_line) = $this->renderCommits(
	$repository,
	$logs,
	idx($task_data, 'info', array()));

	$ref_count = count($ref_lines);
	$commit_count = count($commit_lines);

	$handles = id(new PhabricatorHandleQuery())
	->setViewer($viewer)
	->withPHIDs(array($event->getPusherPHID()))
	->execute();

	$pusher_name = $handles[$event->getPusherPHID()]->getName();
	$repo_name = $repository->getMonogram();

	if ($commit_count) {
	$overview = pht(
	'%s pushed %d commit(s) to %s.',
	$pusher_name,
	$commit_count,
	$repo_name);
	} else {
	$overview = pht(
	'%s pushed to %s.',
	$pusher_name,
	$repo_name);
	}

	$details_uri = PhabricatorEnv::getProductionURI(
	'/diffusion/pushlog/view/'.$event->getID().'/');

	$body = new PhabricatorMetaMTAMailBody();
	$body->addRawSection($overview);

	$body->addLinkSection(pht('DETAILS'), $details_uri);

	if ($commit_lines) {
	$body->addTextSection(pht('COMMITS'), implode("\n", $commit_lines));
	}

	if ($ref_lines) {
	$body->addTextSection(pht('REFERENCES'), implode("\n", $ref_lines));
	}

	$prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');

	$parts = array();
	if ($commit_count) {
	$parts[] = pht('%s commit(s)', $commit_count);
	}
	if ($ref_count) {
	$parts[] = implode(', ', $ref_list);
	}
	$parts = implode(', ', $parts);

	if ($subject_line) {
	$subject = pht('(%s) %s', $parts, $subject_line);
	} else {
	$subject = pht('(%s)', $parts);
	}

	$mail = id(new PhabricatorMetaMTAMail())
	->setRelatedPHID($event->getPHID())
	->setSubjectPrefix($prefix)
	->setVarySubjectPrefix(pht('[Push]'))
	->setSubject($subject)
	->setFrom($event->getPusherPHID())
	->setBody($body->render())
	->setThreadID($event->getPHID(), $is_new = true)
	- ->addHeader('Thread-Topic', $subject)
	->setIsBulk(true);

	return $target->willSendMail($mail);
	}

	private function renderRefs(array $logs) {
	$ref_lines = array();
	$ref_list = array();

	foreach ($logs as $log) {
	$type_name = null;
	$type_prefix = null;
	switch ($log->getRefType()) {
	case PhabricatorRepositoryPushLog::REFTYPE_BRANCH:
	$type_name = pht('branch');
	break;
	case PhabricatorRepositoryPushLog::REFTYPE_TAG:
	$type_name = pht('tag');
	$type_prefix = pht('tag:');
	break;
	case PhabricatorRepositoryPushLog::REFTYPE_BOOKMARK:
	$type_name = pht('bookmark');
	$type_prefix = pht('bookmark:');
	break;
	case PhabricatorRepositoryPushLog::REFTYPE_COMMIT:
	default:
	break;
	}

	if ($type_name === null) {
	continue;
	}

	$flags = $log->getChangeFlags();
	if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_DANGEROUS) {
	$action = '!';
	} else if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_DELETE) {
	$action = '-';
	} else if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_REWRITE) {
	$action = '~';
	} else if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_APPEND) {
	$action = ' ';
	} else if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_ADD) {
	$action = '+';
	} else {
	$action = '?';
	}

	$old = nonempty($log->getRefOldShort(), pht('<null>'));
	$new = nonempty($log->getRefNewShort(), pht('<null>'));

	$name = $log->getRefName();

	$ref_lines[] = "{$action} {$type_name} {$name} {$old} > {$new}";
	$ref_list[] = $type_prefix.$name;
	}

	return array(
	$ref_lines,
	array_unique($ref_list),
	);
	}

	private function renderCommits(
	PhabricatorRepository $repository,
	array $logs,
	array $info) {

	$commit_lines = array();
	$subject_line = null;
	foreach ($logs as $log) {
	if ($log->getRefType() != PhabricatorRepositoryPushLog::REFTYPE_COMMIT) {
	continue;
	}

	$commit_info = idx($info, $log->getRefNew(), array());

	$name = $repository->formatCommitName($log->getRefNew());

	$branches = null;
	if (idx($commit_info, 'branches')) {
	$branches = ' ('.implode(', ', $commit_info['branches']).')';
	}

	$summary = null;
	if (strlen(idx($commit_info, 'summary'))) {
	$summary = ' '.$commit_info['summary'];
	}

	$commit_lines[] = "{$name}{$branches}{$summary}";
	if ($subject_line === null) {
	$subject_line = "{$name}{$summary}";
	}
	}

	return array($commit_lines, $subject_line);
	}

	}
	diff --git a/src/applications/slowvote/editor/PhabricatorSlowvoteEditor.php b/src/applications/slowvote/editor/PhabricatorSlowvoteEditor.php
	index 38dbfb12d6..cf088f37d4 100644
	--- a/src/applications/slowvote/editor/PhabricatorSlowvoteEditor.php
	+++ b/src/applications/slowvote/editor/PhabricatorSlowvoteEditor.php
	@@ -1,96 +1,95 @@
	<?php

	final class PhabricatorSlowvoteEditor
	extends PhabricatorApplicationTransactionEditor {

	public function getEditorApplicationClass() {
	return 'PhabricatorSlowvoteApplication';
	}

	public function getEditorObjectsDescription() {
	return pht('Slowvote');
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this poll.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;

	return $types;
	}

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

	public function getMailTagsMap() {
	return array(
	PhabricatorSlowvoteTransaction::MAILTAG_DETAILS =>
	pht('Someone changes the poll details.'),
	PhabricatorSlowvoteTransaction::MAILTAG_RESPONSES =>
	pht('Someone votes on a poll.'),
	PhabricatorSlowvoteTransaction::MAILTAG_OTHER =>
	pht('Other poll activity not listed above occurs.'),
	);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$monogram = $object->getMonogram();
	$name = $object->getQuestion();

	return id(new PhabricatorMetaMTAMail())
	- ->setSubject("{$monogram}: {$name}")
	- ->addHeader('Thread-Topic', $monogram);
	+ ->setSubject("{$monogram}: {$name}");
	}

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

	$body = parent::buildMailBody($object, $xactions);
	$description = $object->getDescription();

	if (strlen($description)) {
	$body->addRemarkupSection(
	pht('SLOWVOTE DESCRIPTION'),
	$object->getDescription());
	}

	$body->addLinkSection(
	pht('SLOWVOTE DETAIL'),
	PhabricatorEnv::getProductionURI('/'.$object->getMonogram()));

	return $body;
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return array(
	$object->getAuthorPHID(),
	$this->requireActor()->getPHID(),
	);
	}
	protected function getMailSubjectPrefix() {
	return '[Slowvote]';
	}

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

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 28, 8:17 AM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 107885
Default Alt Text: (300 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions