No OneTemporary
Actions

Size

95 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	index 1771507857..4b06aa03be 100644
	--- a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	+++ b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
	@@ -1,531 +1,530 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class PhabricatorAuditCommentEditor {

	private $commit;
	private $user;

	private $attachInlineComments;
	private $auditors = array();
	private $ccs = array();

	public function __construct(PhabricatorRepositoryCommit $commit) {
	$this->commit = $commit;
	return $this;
	}

	public function setUser(PhabricatorUser $user) {
	$this->user = $user;
	return $this;
	}

	public function addAuditors(array $auditor_phids) {
	$this->auditors = array_merge($this->auditors, $auditor_phids);
	return $this;
	}

	public function addCCs(array $cc_phids) {
	$this->ccs = array_merge($this->ccs, $cc_phids);
	return $this;
	}

	public function setAttachInlineComments($attach_inline_comments) {
	$this->attachInlineComments = $attach_inline_comments;
	return $this;
	}

	public function addComment(PhabricatorAuditComment $comment) {

	$commit = $this->commit;
	$user = $this->user;

	$other_comments = id(new PhabricatorAuditComment())->loadAllWhere(
	'targetPHID = %s',
	$commit->getPHID());

	$inline_comments = array();
	if ($this->attachInlineComments) {
	$inline_comments = id(new PhabricatorAuditInlineComment())->loadAllWhere(
	'authorPHID = %s AND commitPHID = %s
	AND auditCommentID IS NULL',
	$user->getPHID(),
	$commit->getPHID());
	}

	$comment
	->setActorPHID($user->getPHID())
	->setTargetPHID($commit->getPHID())
	->save();

	$content_blocks = array($comment->getContent());

	if ($inline_comments) {
	foreach ($inline_comments as $inline) {
	$inline->setAuditCommentID($comment->getID());
	$inline->save();
	$content_blocks[] = $inline->getContent();
	}
	}

	$ccs = $this->ccs;
	$auditors = $this->auditors;

	$metadata = $comment->getMetadata();
	$metacc = array();

	// Find any "@mentions" in the content blocks.
	$mention_ccs = PhabricatorMarkupEngine::extractPHIDsFromMentions(
	$content_blocks);
	if ($mention_ccs) {
	$metacc = idx(
	$metadata,
	PhabricatorAuditComment::METADATA_ADDED_CCS,
	array());
	foreach ($mention_ccs as $cc_phid) {
	$metacc[] = $cc_phid;
	}
	}

	if ($metacc) {
	$ccs = array_merge($ccs, $metacc);
	}

	// When a user submits an audit comment, we update all the audit requests
	// they have authority over to reflect the most recent status. The general
	// idea here is that if audit has triggered for, e.g., several packages, but
	// a user owns all of them, they can clear the audit requirement in one go
	// without auditing the commit for each trigger.

	$audit_phids = self::loadAuditPHIDsForUser($this->user);
	$audit_phids = array_fill_keys($audit_phids, true);

	$requests = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere(
	'commitPHID = %s',
	$commit->getPHID());

	$action = $comment->getAction();


	// TODO: We should validate the action, currently we allow anyone to, e.g.,
	// close an audit if they muck with form parameters. I'll followup with this
	// and handle the no-effect cases (e.g., closing and already-closed audit).


	$user_is_author = ($user->getPHID() == $commit->getAuthorPHID());

	if ($action == PhabricatorAuditActionConstants::CLOSE) {
	// "Close" means wipe out all the concerns.
	$concerned_status = PhabricatorAuditStatusConstants::CONCERNED;
	foreach ($requests as $request) {
	if ($request->getAuditStatus() == $concerned_status) {
	$request->setAuditStatus(PhabricatorAuditStatusConstants::CLOSED);
	$request->save();
	}
	}
	} else if ($action == PhabricatorAuditActionConstants::RESIGN) {
	// "Resign" has unusual rules for writing user rows, only affects the
	// user row (never package/project rows), and always affects the user
	// row (other actions don't, if they were able to affect a package/project
	// row).
	$user_request = null;
	foreach ($requests as $request) {
	if ($request->getAuditorPHID() == $user->getPHID()) {
	$user_request = $request;
	break;
	}
	}
	if (!$user_request) {
	$user_request = id(new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($commit->getPHID())
	->setAuditorPHID($user->getPHID())
	->setAuditReasons(array("Resigned"));
	}

	$user_request
	->setAuditStatus(PhabricatorAuditStatusConstants::RESIGNED)
	->save();

	$requests[] = $user_request;
	} else {
	$have_any_requests = false;
	foreach ($requests as $request) {
	if (empty($audit_phids[$request->getAuditorPHID()])) {
	continue;
	}

	$request_is_for_user = ($request->getAuditorPHID() == $user->getPHID());

	$have_any_requests = true;
	$new_status = null;
	switch ($action) {
	case PhabricatorAuditActionConstants::COMMENT:
	case PhabricatorAuditActionConstants::ADD_CCS:
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	// Commenting or adding cc's/auditors doesn't change status.
	break;
	case PhabricatorAuditActionConstants::ACCEPT:
	if (!$user_is_author \|\| $request_is_for_user) {
	// When modifying your own commits, you act only on behalf of
	// yourself, not your packages/projects -- the idea being that
	// you can't accept your own commits.
	$new_status = PhabricatorAuditStatusConstants::ACCEPTED;
	}
	break;
	case PhabricatorAuditActionConstants::CONCERN:
	if (!$user_is_author \|\| $request_is_for_user) {
	// See above.
	$new_status = PhabricatorAuditStatusConstants::CONCERNED;
	}
	break;
	default:
	throw new Exception("Unknown action '{$action}'!");
	}
	if ($new_status !== null) {
	$request->setAuditStatus($new_status);
	$request->save();
	}
	}

	// If the user has no current authority over any audit trigger, make a
	// new one to represent their audit state.
	if (!$have_any_requests) {
	$new_status = null;
	switch ($action) {
	case PhabricatorAuditActionConstants::COMMENT:
	case PhabricatorAuditActionConstants::ADD_CCS:
	case PhabricatorAuditActionConstants::ADD_AUDITORS:
	$new_status = PhabricatorAuditStatusConstants::AUDIT_NOT_REQUIRED;
	break;
	case PhabricatorAuditActionConstants::ACCEPT:
	$new_status = PhabricatorAuditStatusConstants::ACCEPTED;
	break;
	case PhabricatorAuditActionConstants::CONCERN:
	$new_status = PhabricatorAuditStatusConstants::CONCERNED;
	break;
	case PhabricatorAuditActionConstants::CLOSE:
	// Impossible to reach this block with 'close'.
	default:
	throw new Exception("Unknown or invalid action '{$action}'!");
	}

	$request = id(new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($commit->getPHID())
	->setAuditorPHID($user->getPHID())
	->setAuditStatus($new_status)
	->setAuditReasons(array("Voluntary Participant"))
	->save();
	$requests[] = $request;
	}
	}

	$requests_by_auditor = mpull($requests, null, 'getAuditorPHID');
	$requests_phids = array_keys($requests_by_auditor);

	$ccs = array_diff($ccs, $requests_phids);
	$auditors = array_diff($auditors, $requests_phids);

	if ($action == PhabricatorAuditActionConstants::ADD_CCS) {
	if ($ccs) {
	$metadata[PhabricatorAuditComment::METADATA_ADDED_CCS] = $ccs;
	$comment->setMetaData($metadata);
	} else {
	$comment->setAction(PhabricatorAuditActionConstants::COMMENT);
	}
	}

	if ($action == PhabricatorAuditActionConstants::ADD_AUDITORS) {
	if ($auditors) {
	$metadata[PhabricatorAuditComment::METADATA_ADDED_AUDITORS]
	= $auditors;
	$comment->setMetaData($metadata);
	} else {
	$comment->setAction(PhabricatorAuditActionConstants::COMMENT);
	}
	}

	$comment->save();

	if ($auditors) {
	foreach ($auditors as $auditor_phid) {
	$audit_requested = PhabricatorAuditStatusConstants::AUDIT_REQUESTED;
	$requests[] = id (new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($commit->getPHID())
	->setAuditorPHID($auditor_phid)
	->setAuditStatus($audit_requested)
	->setAuditReasons(
	array('Added by ' . $user->getUsername()))
	->save();
	}
	}

	if ($ccs) {
	foreach ($ccs as $cc_phid) {
	$audit_cc = PhabricatorAuditStatusConstants::CC;
	$requests[] = id (new PhabricatorRepositoryAuditRequest())
	->setCommitPHID($commit->getPHID())
	->setAuditorPHID($cc_phid)
	->setAuditStatus($audit_cc)
	->setAuditReasons(
	array('Added by ' . $user->getUsername()))
	->save();
	}
	}

	$commit->updateAuditStatus($requests);
	$commit->save();

	$this->publishFeedStory($comment, array_keys($audit_phids));
	PhabricatorSearchCommitIndexer::indexCommit($commit);
	$this->sendMail($comment, $other_comments, $inline_comments, $requests);
	}


	/**
	* Load the PHIDs for all objects the user has the authority to act as an
	* audit for. This includes themselves, and any packages they are an owner
	* of.
	*/
	public static function loadAuditPHIDsForUser(PhabricatorUser $user) {
	$phids = array();

	// The user can audit on their own behalf.
	$phids[$user->getPHID()] = true;

	// The user can audit on behalf of all packages they own.
	$owned_packages = PhabricatorOwnersOwner::loadAffiliatedPackages(
	$user->getPHID());

	if ($owned_packages) {
	$packages = id(new PhabricatorOwnersPackage())->loadAllWhere(
	'id IN (%Ld)',
	mpull($owned_packages, 'getPackageID'));
	foreach (mpull($packages, 'getPHID') as $phid) {
	$phids[$phid] = true;
	}
	}

	// The user can audit on behalf of all projects they are a member of.
	$query = new PhabricatorProjectQuery();
	$query->setMembers(array($user->getPHID()));
	$projects = $query->execute();
	foreach ($projects as $project) {
	$phids[$project->getPHID()] = true;
	}

	return array_keys($phids);
	}

	private function publishFeedStory(
	PhabricatorAuditComment $comment,
	array $more_phids) {

	$commit = $this->commit;
	$user = $this->user;

	$related_phids = array_merge(
	array(
	$user->getPHID(),
	$commit->getPHID(),
	),
	$more_phids);

	id(new PhabricatorFeedStoryPublisher())
	->setRelatedPHIDs($related_phids)
	->setStoryAuthorPHID($user->getPHID())
	->setStoryTime(time())
	->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_AUDIT)
	->setStoryData(
	array(
	'commitPHID' => $commit->getPHID(),
	'action' => $comment->getAction(),
	'content' => $comment->getContent(),
	))
	->publish();
	}

	private function sendMail(
	PhabricatorAuditComment $comment,
	array $other_comments,
	array $inline_comments,
	array $requests) {

	assert_instances_of($other_comments, 'PhabricatorAuditComment');
	assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');

	$commit = $this->commit;

	$data = $commit->loadCommitData();
	$summary = $data->getSummary();

	$commit_phid = $commit->getPHID();
	$phids = array($commit_phid);
	$handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
	$handle = $handles[$commit_phid];

	$name = $handle->getName();

	$map = array(
	PhabricatorAuditActionConstants::CONCERN => 'Raised Concern',
	PhabricatorAuditActionConstants::ACCEPT => 'Accepted',
	PhabricatorAuditActionConstants::RESIGN => 'Resigned',
	PhabricatorAuditActionConstants::CLOSE => 'Closed',
	PhabricatorAuditActionConstants::ADD_CCS => 'Added CCs',
	PhabricatorAuditActionConstants::ADD_AUDITORS => 'Added Auditors',
	);
	$verb = idx($map, $comment->getAction(), 'Commented On');

	$reply_handler = self::newReplyHandlerForCommit($commit);

	$prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');
	- $subject = "{$prefix} {$name}: {$summary}";
	- $vary_subject = "{$prefix} [{$verb}] {$name}: {$summary}";

	$threading = self::getMailThreading($commit->getPHID());
	list($thread_id, $thread_topic) = $threading;

	$body = $this->renderMailBody(
	$comment,
	"{$name}: {$summary}",
	$handle,
	$reply_handler,
	$inline_comments);

	$email_to = array();
	$email_cc = array();

	$author_phid = $data->getCommitDetail('authorPHID');
	if ($author_phid) {
	$email_to[] = $author_phid;
	}

	$email_cc = array();
	foreach ($other_comments as $other_comment) {
	$email_cc[] = $other_comment->getActorPHID();
	}

	foreach ($requests as $request) {
	if ($request->getAuditStatus() == PhabricatorAuditStatusConstants::CC) {
	$email_cc[] = $request->getAuditorPHID();
	}
	}

	$phids = array_merge($email_to, $email_cc);
	$handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();

	// NOTE: Always set $is_new to false, because the "first" mail in the
	// thread is the Herald notification of the commit.
	$is_new = false;

	$template = id(new PhabricatorMetaMTAMail())
	- ->setSubject($subject)
	- ->setVarySubject($subject)
	+ ->setSubject("{$name}: {$summary}")
	+ ->setSubjectPrefix($prefix)
	+ ->setVarySubjectPrefix("[{$verb}]")
	->setFrom($comment->getActorPHID())
	->setThreadID($thread_id, $is_new)
	->addHeader('Thread-Topic', $thread_topic)
	->setRelatedPHID($commit->getPHID())
	->setIsBulk(true)
	->setBody($body);

	$mails = $reply_handler->multiplexMail(
	$template,
	array_select_keys($handles, $email_to),
	array_select_keys($handles, $email_cc));

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

	public static function getMailThreading($phid) {
	return array(
	'diffusion-audit-'.$phid,
	'Diffusion Audit '.$phid,
	);
	}

	public static function newReplyHandlerForCommit($commit) {
	$reply_handler = PhabricatorEnv::newObjectFromConfig(
	'metamta.diffusion.reply-handler');
	$reply_handler->setMailReceiver($commit);
	return $reply_handler;
	}

	private function renderMailBody(
	PhabricatorAuditComment $comment,
	$cname,
	PhabricatorObjectHandle $handle,
	PhabricatorMailReplyHandler $reply_handler,
	array $inline_comments) {
	assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');

	$commit = $this->commit;
	$user = $this->user;
	$name = $user->getUsername();

	$verb = PhabricatorAuditActionConstants::getActionPastTenseVerb(
	$comment->getAction());

	$body = array();
	$body[] = "{$name} {$verb} commit {$cname}.";

	if ($comment->getContent()) {
	$body[] = $comment->getContent();
	}

	if ($inline_comments) {
	$block = array();

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

	foreach ($inline_comments 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}";
	}
	$body[] = "INLINE COMMENTS\n ".implode("\n ", $block);
	}

	$body[] = "COMMIT\n ".PhabricatorEnv::getProductionURI($handle->getURI());


	$reply_instructions = $reply_handler->getReplyHandlerInstructions();
	if ($reply_instructions) {
	$body[] = "REPLY HANDLER ACTIONS\n ".$reply_instructions;
	}

	return implode("\n\n", $body)."\n";
	}

	}
	diff --git a/src/applications/differential/mail/DifferentialCCWelcomeMail.php b/src/applications/differential/mail/DifferentialCCWelcomeMail.php
	index 004822177a..33a58f0124 100644
	--- a/src/applications/differential/mail/DifferentialCCWelcomeMail.php
	+++ b/src/applications/differential/mail/DifferentialCCWelcomeMail.php
	@@ -1,38 +1,38 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class DifferentialCCWelcomeMail extends DifferentialReviewRequestMail {

	- protected function renderVarySubject() {
	- return '[Added to CC] '.$this->renderSubject();
	+ protected function renderVaryPrefix() {
	+ return '[Added to CC]';
	}

	protected function renderBody() {

	$actor = $this->getActorName();
	$name = $this->getRevision()->getTitle();
	$body = array();

	$body[] = "{$actor} added you to the CC list for the revision \"{$name}\".";
	$body[] = null;

	$body[] = $this->renderReviewRequestBody();

	return implode("\n", $body);
	}
	}
	diff --git a/src/applications/differential/mail/DifferentialCommentMail.php b/src/applications/differential/mail/DifferentialCommentMail.php
	index d5821617d0..b8d32b93ab 100644
	--- a/src/applications/differential/mail/DifferentialCommentMail.php
	+++ b/src/applications/differential/mail/DifferentialCommentMail.php
	@@ -1,168 +1,168 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class DifferentialCommentMail extends DifferentialMail {

	protected $changedByCommit;

	public function setChangedByCommit($changed_by_commit) {
	$this->changedByCommit = $changed_by_commit;
	return $this;
	}

	public function getChangedByCommit() {
	return $this->changedByCommit;
	}

	public function __construct(
	DifferentialRevision $revision,
	PhabricatorObjectHandle $actor,
	DifferentialComment $comment,
	array $changesets,
	array $inline_comments) {
	assert_instances_of($changesets, 'DifferentialChangeset');
	assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');

	$this->setRevision($revision);
	$this->setActorHandle($actor);
	$this->setComment($comment);
	$this->setChangesets($changesets);
	$this->setInlineComments($inline_comments);

	}

	protected function getMailTags() {
	$comment = $this->getComment();
	$action = $comment->getAction();

	$tags = array();
	switch ($action) {
	case DifferentialAction::ACTION_ADDCCS:
	$tags[] = MetaMTANotificationType::TYPE_DIFFERENTIAL_CC;
	break;
	case DifferentialAction::ACTION_CLOSE:
	$tags[] = MetaMTANotificationType::TYPE_DIFFERENTIAL_CLOSED;
	break;
	}

	if (strlen(trim($comment->getContent()))) {
	switch ($action) {
	case DifferentialAction::ACTION_CLOSE:
	// Commit comments are auto-generated and not especially interesting,
	// so don't tag them as having a comment.
	break;
	default:
	$tags[] = MetaMTANotificationType::TYPE_DIFFERENTIAL_COMMENT;
	break;
	}
	}

	return $tags;
	}

	- protected function renderVarySubject() {
	+ protected function renderVaryPrefix() {
	$verb = ucwords($this->getVerb());
	- return "[{$verb}] ".$this->renderSubject();
	+ return "[{$verb}]";
	}

	protected function getVerb() {
	$comment = $this->getComment();
	$action = $comment->getAction();
	$verb = DifferentialAction::getActionPastTenseVerb($action);
	return $verb;
	}

	protected function renderBody() {

	$comment = $this->getComment();

	$actor = $this->getActorName();
	$name = $this->getRevision()->getTitle();
	$verb = $this->getVerb();

	$body = array();

	$body[] = "{$actor} has {$verb} the revision \"{$name}\".";

	// If the commented added reviewers or CCs, list them explicitly.
	$meta = $comment->getMetadata();
	$m_reviewers = idx(
	$meta,
	DifferentialComment::METADATA_ADDED_REVIEWERS,
	array());
	$m_cc = idx(
	$meta,
	DifferentialComment::METADATA_ADDED_CCS,
	array());
	$load = array_merge($m_reviewers, $m_cc);
	if ($load) {
	$handles = id(new PhabricatorObjectHandleData($load))->loadHandles();
	if ($m_reviewers) {
	$body[] = 'Added Reviewers: '.$this->renderHandleList(
	$handles,
	$m_reviewers);
	}
	if ($m_cc) {
	$body[] = 'Added CCs: '.$this->renderHandleList(
	$handles,
	$m_cc);
	}
	}

	$body[] = null;

	$content = $comment->getContent();
	if (strlen($content)) {
	$body[] = $this->formatText($content);
	$body[] = null;
	}

	if ($this->getChangedByCommit()) {
	$body[] = 'CHANGED PRIOR TO COMMIT';
	$body[] = ' '.$this->getChangedByCommit();
	$body[] = null;
	}

	$inlines = $this->getInlineComments();
	if ($inlines) {
	$body[] = 'INLINE COMMENTS';
	$changesets = $this->getChangesets();
	foreach ($inlines as $inline) {
	$changeset = $changesets[$inline->getChangesetID()];
	if (!$changeset) {
	throw new Exception('Changeset missing!');
	}
	$file = $changeset->getFilename();
	$start = $inline->getLineNumber();
	$len = $inline->getLineLength();
	if ($len) {
	$range = $start.'-'.($start + $len);
	} else {
	$range = $start;
	}
	$content = $inline->getContent();
	$body[] = $this->formatText("{$file}:{$range} {$content}");
	}
	$body[] = null;
	}

	$body[] = $this->renderAuxFields(DifferentialMailPhase::COMMENT);

	return implode("\n", $body);
	}
	}
	diff --git a/src/applications/differential/mail/DifferentialDiffContentMail.php b/src/applications/differential/mail/DifferentialDiffContentMail.php
	index 110c98117c..37b079c342 100644
	--- a/src/applications/differential/mail/DifferentialDiffContentMail.php
	+++ b/src/applications/differential/mail/DifferentialDiffContentMail.php
	@@ -1,35 +1,35 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class DifferentialDiffContentMail extends DifferentialMail {

	protected $content;

	public function __construct(DifferentialRevision $revision, $content) {
	$this->setRevision($revision);
	$this->content = $content;
	}

	- protected function renderVarySubject() {
	- return '[Content] '.$this->renderSubject();
	+ protected function renderVaryPrefix() {
	+ return '[Content]';
	}

	protected function renderBody() {
	return $this->content;
	}
	}
	diff --git a/src/applications/differential/mail/DifferentialExceptionMail.php b/src/applications/differential/mail/DifferentialExceptionMail.php
	index ef11cf9e6b..d168302054 100644
	--- a/src/applications/differential/mail/DifferentialExceptionMail.php
	+++ b/src/applications/differential/mail/DifferentialExceptionMail.php
	@@ -1,66 +1,66 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class DifferentialExceptionMail extends DifferentialMail {

	public function __construct(
	DifferentialRevision $revision,
	Exception $exception,
	$original_body) {

	$this->revision = $revision;
	$this->exception = $exception;
	$this->originalBody = $original_body;
	}

	protected function renderBody() {
	// Never called since buildBody() is overridden.
	}

	protected function renderSubject() {
	- return "Exception: unable to process your mail request.";
	+ return "Exception: unable to process your mail request";
	}

	- protected function renderVarySubject() {
	- return $this->renderSubject();
	+ protected function renderVaryPrefix() {
	+ return '';
	}

	protected function buildBody() {
	$exception = $this->exception;
	$original_body = $this->originalBody;

	$message = $exception->getMessage();
	$trace = $exception->getTraceAsString();

	return <<<EOBODY
	Your request failed because an exception was encoutered while processing it:

	EXCEPTION: {$message}

	{$trace}

	-- Original Body --------------------------

	{$original_body}

	EOBODY;
	}

	}


	diff --git a/src/applications/differential/mail/DifferentialMail.php b/src/applications/differential/mail/DifferentialMail.php
	index fae1cda58c..2f539caf50 100644
	--- a/src/applications/differential/mail/DifferentialMail.php
	+++ b/src/applications/differential/mail/DifferentialMail.php
	@@ -1,430 +1,421 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	abstract class DifferentialMail {

	protected $to = array();
	protected $cc = array();

	protected $actorHandle;

	protected $revision;
	protected $comment;
	protected $changesets;
	protected $inlineComments;
	protected $isFirstMailAboutRevision;
	protected $isFirstMailToRecipients;
	protected $heraldTranscriptURI;
	protected $heraldRulesHeader;
	protected $replyHandler;
	protected $parentMessageID;

	protected function renderSubject() {
	$revision = $this->getRevision();
	$title = $revision->getTitle();
	$id = $revision->getID();
	return "D{$id}: {$title}";
	}

	- abstract protected function renderVarySubject();
	+ abstract protected function renderVaryPrefix();
	abstract protected function renderBody();

	public function setActorHandle($actor_handle) {
	$this->actorHandle = $actor_handle;
	return $this;
	}

	public function getActorHandle() {
	return $this->actorHandle;
	}

	protected function getActorName() {
	$handle = $this->getActorHandle();
	if ($handle) {
	return $handle->getName();
	}
	return '???';
	}

	public function setParentMessageID($parent_message_id) {
	$this->parentMessageID = $parent_message_id;
	return $this;
	}

	public function setXHeraldRulesHeader($header) {
	$this->heraldRulesHeader = $header;
	return $this;
	}

	public function send() {
	$to_phids = $this->getToPHIDs();
	if (!$to_phids) {
	throw new Exception('No "To:" users provided!');
	}

	$cc_phids = $this->getCCPHIDs();
	- $subject = $this->buildSubject();
	- $vary_subject = $this->buildVarySubject();
	$body = $this->buildBody();
	$attachments = $this->buildAttachments();

	$template = new PhabricatorMetaMTAMail();
	$actor_handle = $this->getActorHandle();
	$reply_handler = $this->getReplyHandler();

	if ($actor_handle) {
	$template->setFrom($actor_handle->getPHID());
	}

	$template
	- ->setSubject($subject)
	- ->setVarySubject($vary_subject)
	+ ->setSubject($this->renderSubject())
	+ ->setSubjectPrefix($this->getSubjectPrefix())
	+ ->setVarySubjectPrefix($this->renderVaryPrefix())
	->setBody($body)
	->setIsHTML($this->shouldMarkMailAsHTML())
	->setParentMessageID($this->parentMessageID)
	->addHeader('Thread-Topic', $this->getRevision()->getTitle());

	$template->setAttachments($attachments);

	$template->setThreadID(
	$this->getThreadID(),
	$this->isFirstMailAboutRevision());

	if ($this->heraldRulesHeader) {
	$template->addHeader('X-Herald-Rules', $this->heraldRulesHeader);
	}

	$revision = $this->revision;
	if ($revision) {
	if ($revision->getAuthorPHID()) {
	$template->addHeader(
	'X-Differential-Author',
	'<'.$revision->getAuthorPHID().'>');
	}
	if ($revision->getReviewers()) {
	$template->addHeader(
	'X-Differential-Reviewers',
	'<'.implode('>, <', $revision->getReviewers()).'>');
	}
	if ($revision->getCCPHIDs()) {
	$template->addHeader(
	'X-Differential-CCs',
	'<'.implode('>, <', $revision->getCCPHIDs()).'>');

	// Determine explicit CCs (those added by humans) and put them in a
	// header so users can differentiate between Herald CCs and human CCs.

	$relation_subscribed = DifferentialRevision::RELATION_SUBSCRIBED;
	$raw = $revision->getRawRelations($relation_subscribed);

	$reason_phids = ipull($raw, 'reasonPHID');
	$reason_handles = id(new PhabricatorObjectHandleData($reason_phids))
	->loadHandles();

	$explicit_cc = array();
	foreach ($raw as $relation) {
	if (!$relation['reasonPHID']) {
	continue;
	}
	$type = $reason_handles[$relation['reasonPHID']]->getType();
	if ($type == PhabricatorPHIDConstants::PHID_TYPE_USER) {
	$explicit_cc[] = $relation['objectPHID'];
	}
	}

	if ($explicit_cc) {
	$template->addHeader(
	'X-Differential-Explicit-CCs',
	'<'.implode('>, <', $explicit_cc).'>');
	}
	}
	}

	$template->setIsBulk(true);
	$template->setRelatedPHID($this->getRevision()->getPHID());

	$mailtags = $this->getMailTags();
	if ($mailtags) {
	$template->setMailTags($mailtags);
	}

	$phids = array();
	foreach ($to_phids as $phid) {
	$phids[$phid] = true;
	}
	foreach ($cc_phids as $phid) {
	$phids[$phid] = true;
	}
	$phids = array_keys($phids);

	$handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_DIFFERENTIAL_WILLSENDMAIL,
	array(
	'mail' => $template,
	)
	);
	PhutilEventEngine::dispatchEvent($event);

	$template = $event->getValue('mail');

	$mails = $reply_handler->multiplexMail(
	$template,
	array_select_keys($handles, $to_phids),
	array_select_keys($handles, $cc_phids));

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

	protected function getMailTags() {
	return array();
	}

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

	- protected function buildSubject() {
	- return trim($this->getSubjectPrefix().' '.$this->renderSubject());
	- }
	-
	- protected function buildVarySubject() {
	- return trim($this->getSubjectPrefix().' '.$this->renderVarySubject());
	- }
	-
	protected function shouldMarkMailAsHTML() {
	return false;
	}

	protected function buildBody() {

	$body = $this->renderBody();

	$reply_handler = $this->getReplyHandler();
	$reply_instructions = $reply_handler->getReplyHandlerInstructions();
	if ($reply_instructions) {
	$body .=
	"\nREPLY HANDLER ACTIONS\n".
	" {$reply_instructions}\n";
	}

	if ($this->getHeraldTranscriptURI() && $this->isFirstMailToRecipients()) {
	$manage_uri = PhabricatorEnv::getProductionURI(
	'/herald/view/differential/');

	$xscript_uri = $this->getHeraldTranscriptURI();
	$body .= <<<EOTEXT

	MANAGE HERALD DIFFERENTIAL RULES
	{$manage_uri}

	WHY DID I GET THIS EMAIL?
	{$xscript_uri}

	EOTEXT;
	}

	return $body;
	}

	/**
	* You can override this method in a subclass and return array of attachments
	* to be sent with the email. Each attachment is an instance of
	* PhabricatorMetaMTAAttachment.
	*/
	protected function buildAttachments() {
	return array();
	}

	public function getReplyHandler() {
	if (!$this->replyHandler) {
	$this->replyHandler =
	self::newReplyHandlerForRevision($this->getRevision());
	}

	return $this->replyHandler;
	}

	public static function newReplyHandlerForRevision(
	DifferentialRevision $revision) {

	$reply_handler = PhabricatorEnv::newObjectFromConfig(
	'metamta.differential.reply-handler');
	$reply_handler->setMailReceiver($revision);

	return $reply_handler;
	}


	protected function formatText($text) {
	$text = explode("\n", $text);
	foreach ($text as &$line) {
	$line = rtrim(' '.$line);
	}
	unset($line);
	return implode("\n", $text);
	}

	public function setToPHIDs(array $to) {
	$this->to = $this->filterContactPHIDs($to);
	return $this;
	}

	public function setCCPHIDs(array $cc) {
	$this->cc = $this->filterContactPHIDs($cc);
	return $this;
	}

	protected function filterContactPHIDs(array $phids) {
	return $phids;

	// TODO: actually do this?

	// Differential revisions use Subscriptions for CCs, so any arbitrary
	// PHID can end up CC'd to them. Only try to actually send email PHIDs
	// which have ToolsHandle types that are marked emailable. If we don't
	// filter here, sending the email will fail.
	/*
	$handles = array();
	prep(new ToolsHandleData($phids, $handles));
	foreach ($handles as $phid => $handle) {
	if (!$handle->isEmailable()) {
	unset($handles[$phid]);
	}
	}
	return array_keys($handles);
	*/
	}

	protected function getToPHIDs() {
	return $this->to;
	}

	protected function getCCPHIDs() {
	return $this->cc;
	}

	public function setRevision($revision) {
	$this->revision = $revision;
	return $this;
	}

	public function getRevision() {
	return $this->revision;
	}

	protected function getThreadID() {
	$phid = $this->getRevision()->getPHID();
	return "differential-rev-{$phid}-req";
	}

	public function setComment($comment) {
	$this->comment = $comment;
	return $this;
	}

	public function getComment() {
	return $this->comment;
	}

	public function setChangesets($changesets) {
	$this->changesets = $changesets;
	return $this;
	}

	public function getChangesets() {
	return $this->changesets;
	}

	public function setInlineComments(array $inline_comments) {
	assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');
	$this->inlineComments = $inline_comments;
	return $this;
	}

	public function getInlineComments() {
	return $this->inlineComments;
	}

	protected function renderAuxFields($phase) {
	$selector = DifferentialFieldSelector::newSelector();
	$aux_fields = $selector->sortFieldsForMail(
	$selector->getFieldSpecifications());

	$body = array();
	foreach ($aux_fields as $field) {
	$field->setRevision($this->getRevision());
	$text = $field->renderValueForMail($phase);
	if ($text !== null) {
	$body[] = $text;
	$body[] = null;
	}
	}

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

	public function renderRevisionDetailLink() {
	$uri = $this->getRevisionURI();
	return "REVISION DETAIL\n {$uri}";
	}

	public function getRevisionURI() {
	return PhabricatorEnv::getProductionURI('/D'.$this->getRevision()->getID());
	}

	public function setIsFirstMailToRecipients($first) {
	$this->isFirstMailToRecipients = $first;
	return $this;
	}

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

	public function setIsFirstMailAboutRevision($first) {
	$this->isFirstMailAboutRevision = $first;
	return $this;
	}

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

	public function setHeraldTranscriptURI($herald_transcript_uri) {
	$this->heraldTranscriptURI = $herald_transcript_uri;
	return $this;
	}

	public function getHeraldTranscriptURI() {
	return $this->heraldTranscriptURI;
	}

	protected function renderHandleList(array $handles, array $phids) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	$names = array();
	foreach ($phids as $phid) {
	$names[] = $handles[$phid]->getName();
	}
	return implode(', ', $names);
	}

	}
	diff --git a/src/applications/differential/mail/DifferentialNewDiffMail.php b/src/applications/differential/mail/DifferentialNewDiffMail.php
	index 06cd6e45b8..3b95f4ee13 100644
	--- a/src/applications/differential/mail/DifferentialNewDiffMail.php
	+++ b/src/applications/differential/mail/DifferentialNewDiffMail.php
	@@ -1,53 +1,53 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class DifferentialNewDiffMail extends DifferentialReviewRequestMail {

	- protected function renderVarySubject() {
	+ protected function renderVaryPrefix() {
	$revision = $this->getRevision();
	$line_count = $revision->getLineCount();
	$lines = ($line_count == 1 ? "1 line" : "{$line_count} lines");

	if ($this->isFirstMailToRecipients()) {
	$verb = 'Request';
	} else {
	$verb = 'Updated';
	}

	- return "[{$verb}, {$lines}] ".$this->renderSubject();
	+ return "[{$verb}, {$lines}]";
	}

	protected function renderBody() {
	$actor = $this->getActorName();

	$name = $this->getRevision()->getTitle();

	$body = array();

	if ($this->isFirstMailToRecipients()) {
	$body[] = "{$actor} requested code review of \"{$name}\".";
	} else {
	$body[] = "{$actor} updated the revision \"{$name}\".";
	}
	$body[] = null;

	$body[] = $this->renderReviewRequestBody();

	return implode("\n", $body);
	}
	}
	diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	index d27ec0cd3c..4876fb5849 100644
	--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	@@ -1,442 +1,440 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @group maniphest
	*/
	final class ManiphestTransactionEditor {

	private $parentMessageID;
	private $auxiliaryFields = array();

	public function setAuxiliaryFields(array $fields) {
	assert_instances_of($fields, 'ManiphestAuxiliaryFieldSpecification');
	$this->auxiliaryFields = $fields;
	return $this;
	}

	public function setParentMessageID($parent_message_id) {
	$this->parentMessageID = $parent_message_id;
	return $this;
	}

	public function applyTransactions(ManiphestTask $task, array $transactions) {
	assert_instances_of($transactions, 'ManiphestTransaction');

	$email_cc = $task->getCCPHIDs();

	$email_to = array();
	$email_to[] = $task->getOwnerPHID();

	$pri_changed = $this->isCreate($transactions);

	foreach ($transactions as $key => $transaction) {
	$type = $transaction->getTransactionType();
	$new = $transaction->getNewValue();
	$email_to[] = $transaction->getAuthorPHID();

	$value_is_phid_set = false;

	switch ($type) {
	case ManiphestTransactionType::TYPE_NONE:
	$old = null;
	break;
	case ManiphestTransactionType::TYPE_STATUS:
	$old = $task->getStatus();
	break;
	case ManiphestTransactionType::TYPE_OWNER:
	$old = $task->getOwnerPHID();
	break;
	case ManiphestTransactionType::TYPE_CCS:
	$old = $task->getCCPHIDs();
	$value_is_phid_set = true;
	break;
	case ManiphestTransactionType::TYPE_PRIORITY:
	$old = $task->getPriority();
	break;
	case ManiphestTransactionType::TYPE_ATTACH:
	$old = $task->getAttached();
	break;
	case ManiphestTransactionType::TYPE_TITLE:
	$old = $task->getTitle();
	break;
	case ManiphestTransactionType::TYPE_DESCRIPTION:
	$old = $task->getDescription();
	break;
	case ManiphestTransactionType::TYPE_PROJECTS:
	$old = $task->getProjectPHIDs();
	$value_is_phid_set = true;
	break;
	case ManiphestTransactionType::TYPE_AUXILIARY:
	$aux_key = $transaction->getMetadataValue('aux:key');
	if (!$aux_key) {
	throw new Exception(
	"Expected 'aux:key' metadata on TYPE_AUXILIARY transaction.");
	}
	$old = $task->getAuxiliaryAttribute($aux_key);
	break;
	default:
	throw new Exception('Unknown action type.');
	}

	$old_cmp = $old;
	$new_cmp = $new;
	if ($value_is_phid_set) {

	// Normalize the old and new values if they are PHID sets so we don't
	// get any no-op transactions where the values differ only by keys,
	// order, duplicates, etc.

	if (is_array($old)) {
	$old = array_filter($old);
	$old = array_unique($old);
	sort($old);
	$old = array_values($old);
	$old_cmp = $old;
	}

	if (is_array($new)) {
	$new = array_filter($new);
	$new = array_unique($new);
	$transaction->setNewValue($new);

	$new_cmp = $new;
	sort($new_cmp);
	$new_cmp = array_values($new_cmp);
	}
	}

	if (($old !== null) && ($old_cmp == $new_cmp)) {
	if (count($transactions) > 1 && !$transaction->hasComments()) {
	// If we have at least one other transaction and this one isn't
	// doing anything and doesn't have any comments, just throw it
	// away.
	unset($transactions[$key]);
	continue;
	} else {
	$transaction->setOldValue(null);
	$transaction->setNewValue(null);
	$transaction->setTransactionType(ManiphestTransactionType::TYPE_NONE);
	}
	} else {
	switch ($type) {
	case ManiphestTransactionType::TYPE_NONE:
	break;
	case ManiphestTransactionType::TYPE_STATUS:
	$task->setStatus($new);
	break;
	case ManiphestTransactionType::TYPE_OWNER:
	if ($new) {
	$handles = id(new PhabricatorObjectHandleData(array($new)))
	->loadHandles();
	$task->setOwnerOrdering($handles[$new]->getName());
	} else {
	$task->setOwnerOrdering(null);
	}
	$task->setOwnerPHID($new);
	break;
	case ManiphestTransactionType::TYPE_CCS:
	$task->setCCPHIDs($new);
	break;
	case ManiphestTransactionType::TYPE_PRIORITY:
	$task->setPriority($new);
	$pri_changed = true;
	break;
	case ManiphestTransactionType::TYPE_ATTACH:
	$task->setAttached($new);
	break;
	case ManiphestTransactionType::TYPE_TITLE:
	$task->setTitle($new);
	break;
	case ManiphestTransactionType::TYPE_DESCRIPTION:
	$task->setDescription($new);
	break;
	case ManiphestTransactionType::TYPE_PROJECTS:
	$task->setProjectPHIDs($new);
	break;
	case ManiphestTransactionType::TYPE_AUXILIARY:
	$aux_key = $transaction->getMetadataValue('aux:key');
	$task->setAuxiliaryAttribute($aux_key, $new);
	break;
	default:
	throw new Exception('Unknown action type.');
	}

	$transaction->setOldValue($old);
	$transaction->setNewValue($new);
	}

	}

	if ($pri_changed) {
	$subpriority = ManiphestTransactionEditor::getNextSubpriority(
	$task->getPriority(),
	null);
	$task->setSubpriority($subpriority);
	}

	$task->save();
	foreach ($transactions as $transaction) {
	$transaction->setTaskID($task->getID());
	$transaction->save();
	}

	$email_to[] = $task->getOwnerPHID();
	$email_cc = array_merge(
	$email_cc,
	$task->getCCPHIDs());

	$this->publishFeedStory($task, $transactions);

	// TODO: Do this offline via timeline
	PhabricatorSearchManiphestIndexer::indexTask($task);

	$this->sendEmail($task, $transactions, $email_to, $email_cc);
	}

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

	private function sendEmail($task, $transactions, $email_to, $email_cc) {
	$email_to = array_filter(array_unique($email_to));
	$email_cc = array_filter(array_unique($email_cc));

	$phids = array();
	foreach ($transactions as $transaction) {
	foreach ($transaction->extractPHIDs() as $phid) {
	$phids[$phid] = true;
	}
	}
	foreach ($email_to as $phid) {
	$phids[$phid] = true;
	}
	foreach ($email_cc as $phid) {
	$phids[$phid] = true;
	}
	$phids = array_keys($phids);

	$handles = id(new PhabricatorObjectHandleData($phids))
	->loadHandles();

	$view = new ManiphestTransactionDetailView();
	$view->setTransactionGroup($transactions);
	$view->setHandles($handles);
	$view->setAuxiliaryFields($this->auxiliaryFields);
	list($action, $body) = $view->renderForEmail($with_date = false);

	$is_create = $this->isCreate($transactions);

	$task_uri = PhabricatorEnv::getURI('/T'.$task->getID());

	$reply_handler = $this->buildReplyHandler($task);

	if ($is_create) {
	$body .=
	"\n\n".
	"TASK DESCRIPTION\n".
	" ".$task->getDescription();
	}

	$body .=
	"\n\n".
	"TASK DETAIL\n".
	" ".$task_uri."\n";

	$reply_instructions = $reply_handler->getReplyHandlerInstructions();
	if ($reply_instructions) {
	$body .=
	"\n".
	"REPLY HANDLER ACTIONS\n".
	" ".$reply_instructions."\n";
	}

	$thread_id = 'maniphest-task-'.$task->getPHID();
	$task_id = $task->getID();
	$title = $task->getTitle();
	- $prefix = $this->getSubjectPrefix();
	- $subject = trim("{$prefix} T{$task_id}: {$title}");
	- $vary_subject = trim("{$prefix} [{$action}] T{$task_id}: {$title}");

	$mailtags = $this->getMailTags($transactions);

	$template = id(new PhabricatorMetaMTAMail())
	- ->setSubject($subject)
	- ->setVarySubject($vary_subject)
	+ ->setSubject("T{$task_id}: {$title}")
	+ ->setSubjectPrefix($this->getSubjectPrefix())
	+ ->setVarySubjectPrefix("[{$action}]")
	->setFrom($transaction->getAuthorPHID())
	->setParentMessageID($this->parentMessageID)
	->addHeader('Thread-Topic', 'Maniphest Task '.$task->getID())
	->setThreadID($thread_id, $is_create)
	->setRelatedPHID($task->getPHID())
	->setIsBulk(true)
	->setMailTags($mailtags)
	->setBody($body);

	$mails = $reply_handler->multiplexMail(
	$template,
	array_select_keys($handles, $email_to),
	array_select_keys($handles, $email_cc));

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

	public function buildReplyHandler(ManiphestTask $task) {
	$handler_object = PhabricatorEnv::newObjectFromConfig(
	'metamta.maniphest.reply-handler');
	$handler_object->setMailReceiver($task);

	return $handler_object;
	}

	private function publishFeedStory(ManiphestTask $task, array $transactions) {
	assert_instances_of($transactions, 'ManiphestTransaction');

	$actions = array(ManiphestAction::ACTION_UPDATE);
	$comments = null;
	foreach ($transactions as $transaction) {
	if ($transaction->hasComments()) {
	$comments = $transaction->getComments();
	}
	$type = $transaction->getTransactionType();
	switch ($type) {
	case ManiphestTransactionType::TYPE_OWNER:
	$actions[] = ManiphestAction::ACTION_ASSIGN;
	break;
	case ManiphestTransactionType::TYPE_STATUS:
	if ($task->getStatus() != ManiphestTaskStatus::STATUS_OPEN) {
	$actions[] = ManiphestAction::ACTION_CLOSE;
	} else if ($this->isCreate($transactions)) {
	$actions[] = ManiphestAction::ACTION_CREATE;
	} else {
	$actions[] = ManiphestAction::ACTION_REOPEN;
	}
	break;
	default:
	$actions[] = $type;
	break;
	}
	}

	$action_type = ManiphestAction::selectStrongestAction($actions);
	$owner_phid = $task->getOwnerPHID();
	$actor_phid = head($transactions)->getAuthorPHID();
	$author_phid = $task->getAuthorPHID();


	id(new PhabricatorFeedStoryPublisher())
	->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_MANIPHEST)
	->setStoryData(array(
	'taskPHID' => $task->getPHID(),
	'transactionIDs' => mpull($transactions, 'getID'),
	'ownerPHID' => $owner_phid,
	'action' => $action_type,
	'comments' => $comments,
	'description' => $task->getDescription(),
	))
	->setStoryTime(time())
	->setStoryAuthorPHID($actor_phid)
	->setRelatedPHIDs(
	array_merge(
	array_filter(
	array(
	$task->getPHID(),
	$author_phid,
	$actor_phid,
	$owner_phid,
	)),
	$task->getProjectPHIDs()))
	->setPrimaryObjectPHID($task->getPHID())
	->setSubscribedPHIDs(
	array_merge(
	array_filter(
	array(
	$author_phid,
	$owner_phid,
	$actor_phid)),
	$task->getCCPHIDs()))
	->publish();
	}

	private function isCreate(array $transactions) {
	assert_instances_of($transactions, 'ManiphestTransaction');
	$is_create = false;
	foreach ($transactions as $transaction) {
	$type = $transaction->getTransactionType();
	if (($type == ManiphestTransactionType::TYPE_STATUS) &&
	($transaction->getOldValue() === null) &&
	($transaction->getNewValue() == ManiphestTaskStatus::STATUS_OPEN)) {
	$is_create = true;
	}
	}
	return $is_create;
	}

	private function getMailTags(array $transactions) {
	assert_instances_of($transactions, 'ManiphestTransaction');

	$tags = array();
	foreach ($transactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTransactionType::TYPE_CCS:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_CC;
	break;
	case ManiphestTransactionType::TYPE_PROJECTS:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_PROJECTS;
	break;
	case ManiphestTransactionType::TYPE_PRIORITY:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_PRIORITY;
	break;
	default:
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_OTHER;
	break;
	}

	if ($xaction->hasComments()) {
	$tags[] = MetaMTANotificationType::TYPE_MANIPHEST_COMMENT;
	}
	}

	return array_unique($tags);
	}

	public static function getNextSubpriority($pri, $sub) {

	if ($sub === null) {
	$next = id(new ManiphestTask())->loadOneWhere(
	'priority = %d ORDER BY subpriority ASC LIMIT 1',
	$pri);
	if ($next) {
	return $next->getSubpriority() - ((double)(2 << 16));
	}
	} else {
	$next = id(new ManiphestTask())->loadOneWhere(
	'priority = %d AND subpriority > %s ORDER BY subpriority ASC LIMIT 1',
	$pri,
	$sub);
	if ($next) {
	return ($sub + $next->getSubpriority()) / 2;
	}
	}

	return (double)(2 << 32);
	}


	}
	diff --git a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	index ae845745ac..f6ccdbe25d 100644
	--- a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	+++ b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	@@ -1,736 +1,748 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* See #394445 for an explanation of why this thing even exists.
	*/
	final class PhabricatorMetaMTAMail extends PhabricatorMetaMTADAO {

	const STATUS_QUEUE = 'queued';
	const STATUS_SENT = 'sent';
	const STATUS_FAIL = 'fail';
	const STATUS_VOID = 'void';

	const MAX_RETRIES = 250;
	const RETRY_DELAY = 5;

	protected $parameters;
	protected $status;
	protected $message;
	protected $retryCount;
	protected $nextRetry;
	protected $relatedPHID;

	public function __construct() {

	$this->status = self::STATUS_QUEUE;
	$this->retryCount = 0;
	$this->nextRetry = time();
	$this->parameters = array();

	parent::__construct();
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_SERIALIZATION => array(
	'parameters' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

	protected function setParam($param, $value) {
	$this->parameters[$param] = $value;
	return $this;
	}

	protected function getParam($param) {
	return idx($this->parameters, $param);
	}

	/**
	* Set tags (@{class:MetaMTANotificationType} constants) which identify the
	* content of this mail in a general way. 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> List of @{class:MetaMTANotificationType} constants.
	* @return this
	*/
	public function setMailTags(array $tags) {
	$this->setParam('mailtags', $tags);
	return $this;
	}

	/**
	* 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) {
	$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 addHeader($name, $value) {
	$this->parameters['headers'][$name] = $value;
	return $this;
	}

	public function addAttachment(PhabricatorMetaMTAAttachment $attachment) {
	$this->parameters['attachments'][] = $attachment;
	return $this;
	}

	public function getAttachments() {
	return $this->getParam('attachments');
	}

	public function setAttachments(array $attachments) {
	assert_instances_of($attachments, 'PhabricatorMetaMTAAttachment');
	$this->setParam('attachments', $attachments);
	return $this;
	}

	public function setFrom($from) {
	$this->setParam('from', $from);
	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 setVarySubject($subject) {
	- $this->setParam('vary-subject', $subject);
	+ 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 getBody() {
	return $this->getParam('body');
	}

	public function setIsHTML($html) {
	$this->setParam('is-html', $html);
	return $this;
	}

	public function getSimulatedFailureCount() {
	return nonempty($this->getParam('simulated-failures'), 0);
	}

	public function setSimulatedFailureCount($count) {
	$this->setParam('simulated-failures', $count);
	return $this;
	}

	public function getWorkerTaskID() {
	return $this->getParam('worker-task');
	}

	public function setWorkerTaskID($id) {
	$this->setParam('worker-task', $id);
	return $this;
	}

	/**
	* 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 and attempt to send it
	* immediately if the server is configured for immediate sends. When
	* applications generate new mail they should generally use this method to
	* deliver it. If the server doesn't use immediate sends, this has the same
	* effect as calling save(): the mail will eventually be delivered by the
	* MetaMTA daemon.
	*
	* @return this
	*/
	public function saveAndSend() {
	$ret = null;

	if (PhabricatorEnv::getEnvConfig('metamta.send-immediately')) {
	$ret = $this->sendNow();
	} else {
	$ret = $this->save();
	}

	return $ret;
	}

	protected function didWriteData() {
	parent::didWriteData();

	if (!$this->getWorkerTaskID()) {
	$mailer_task = new PhabricatorWorkerTask();
	$mailer_task->setTaskClass('PhabricatorMetaMTAWorker');
	$mailer_task->setData($this->getID());
	$mailer_task->save();
	$this->setWorkerTaskID($mailer_task->getID());
	$this->save();
	}
	}


	public function buildDefaultMailer() {
	return PhabricatorEnv::newObjectFromConfig('metamta.mail-adapter');
	}

	/**
	* Attempt to deliver an email immediately, in this process.
	*
	* @param bool Try to deliver this email even if it has already been
	* delivered or is in backoff after a failed delivery attempt.
	* @param PhabricatorMailImplementationAdapter Use a specific mail adapter,
	* instead of the default.
	*
	* @return void
	*/
	public function sendNow(
	$force_send = false,
	PhabricatorMailImplementationAdapter $mailer = null) {

	if ($mailer === null) {
	$mailer = $this->buildDefaultMailer();
	}

	if (!$force_send) {
	if ($this->getStatus() != self::STATUS_QUEUE) {
	throw new Exception("Trying to send an already-sent mail!");
	}

	if (time() < $this->getNextRetry()) {
	throw new Exception("Trying to send an email before next retry!");
	}
	}

	try {
	$parameters = $this->parameters;
	$phids = array();
	foreach ($parameters as $key => $value) {
	switch ($key) {
	case 'from':
	case 'to':
	case 'cc':
	if (!is_array($value)) {
	$value = array($value);
	}
	foreach (array_filter($value) as $phid) {
	$type = phid_get_type($phid);
	$phids[$phid] = $type;
	}
	break;
	}
	}

	$this->loadEmailAndNameDataFromPHIDs($phids);

	$exclude = array();

	$params = $this->parameters;
	$default = PhabricatorEnv::getEnvConfig('metamta.default-address');
	if (empty($params['from'])) {
	$mailer->setFrom($default);
	} else {
	$from = $params['from'];

	// If the user has set their preferences to not send them email about
	// things they do, exclude them from being on To or Cc.
	$from_user = id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$from);
	if ($from_user) {
	$pref_key = PhabricatorUserPreferences::PREFERENCE_NO_SELF_MAIL;
	$exclude_self = $from_user
	->loadPreferences()
	->getPreference($pref_key);
	if ($exclude_self) {
	$exclude[$from] = true;
	}
	}

	if (!PhabricatorEnv::getEnvConfig('metamta.can-send-as-user')) {
	if (empty($params['reply-to'])) {
	$params['reply-to'] = $phids[$from]['email'];
	$params['reply-to-name'] = $phids[$from]['name'];
	}
	$mailer->setFrom(
	$default,
	$phids[$from]['name']);
	unset($params['from']);
	}
	}

	$is_first = idx($params, 'is-first-message');
	unset($params['is-first-message']);

	$is_threaded = (bool)idx($params, 'thread-id');

	$reply_to_name = idx($params, 'reply-to-name', '');
	unset($params['reply-to-name']);

	$add_cc = array();
	$add_to = array();

	foreach ($params as $key => $value) {
	switch ($key) {
	case 'from':
	$mailer->setFrom($phids[$from]['email']);
	break;
	case 'reply-to':
	$mailer->addReplyTo($value, $reply_to_name);
	break;
	case 'to':
	$to_emails = $this->filterSendable($value, $phids, $exclude);
	if ($to_emails) {
	$add_to = array_merge($add_to, $to_emails);
	}
	break;
	case 'raw-to':
	$add_to = array_merge($add_to, $value);
	break;
	case 'cc':
	$cc_emails = $this->filterSendable($value, $phids, $exclude);
	if ($cc_emails) {
	$add_cc = $cc_emails;
	}
	break;
	case 'headers':
	foreach ($value as $header_key => $header_value) {
	// NOTE: If we have \n in a header, SES rejects the email.
	$header_value = str_replace("\n", " ", $header_value);

	$mailer->addHeader($header_key, $header_value);
	}
	break;
	case 'attachments':
	foreach ($value as $attachment) {
	$mailer->addAttachment(
	$attachment->getData(),
	$attachment->getFilename(),
	$attachment->getMimeType()
	);
	}
	break;
	case 'body':
	$mailer->setBody($value);
	break;
	case 'subject':
	// Only try to use preferences if everything is multiplexed, so we
	// get consistent behavior.
	$use_prefs = self::shouldMultiplexAllMail();

	$prefs = null;
	if ($use_prefs) {
	$to = idx($params, 'to', array());
	$user = id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	head($to));
	if ($user) {
	$prefs = $user->loadPreferences();
	}
	}

	- $alt_subject = idx($params, 'vary-subject');
	- if ($alt_subject) {
	- $use_subject = PhabricatorEnv::getEnvConfig(
	- 'metamta.vary-subjects');
	-
	- if ($prefs) {
	- $use_subject = $prefs->getPreference(
	- PhabricatorUserPreferences::PREFERENCE_VARY_SUBJECT,
	- $use_subject);
	- }
	-
	- if ($use_subject) {
	- $value = $alt_subject;
	- }
	- }
	+ $subject = array();

	if ($is_threaded) {
	$add_re = PhabricatorEnv::getEnvConfig('metamta.re-prefix');

	if ($prefs) {
	$add_re = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_RE_PREFIX,
	$add_re);
	}

	if ($add_re) {
	- $value = 'Re: '.$value;
	+ $subject[] = 'Re:';
	}
	}

	- $mailer->setSubject($value);
	+ $subject[] = trim(idx($params, 'subject-prefix'));
	+
	+ $vary_prefix = idx($params, 'vary-subject-prefix');
	+ if ($vary_prefix != '') {
	+ $use_subject = PhabricatorEnv::getEnvConfig(
	+ 'metamta.vary-subjects');
	+
	+ if ($prefs) {
	+ $use_subject = $prefs->getPreference(
	+ PhabricatorUserPreferences::PREFERENCE_VARY_SUBJECT,
	+ $use_subject);
	+ }
	+
	+ if ($use_subject) {
	+ $subject[] = $vary_prefix;
	+ }
	+ }
	+
	+ $subject[] = $value;
	+
	+ $mailer->setSubject(implode(' ', array_filter($subject)));
	break;
	case 'is-html':
	if ($value) {
	$mailer->setIsHTML(true);
	}
	break;
	case 'is-bulk':
	if ($value) {
	if (PhabricatorEnv::getEnvConfig('metamta.precedence-bulk')) {
	$mailer->addHeader('Precedence', 'bulk');
	}
	}
	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()) {
	$mailer->addHeader('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);
	$mailer->addHeader('In-Reply-To', $in_reply_to);
	$mailer->addHeader('References', $references);
	}
	$thread_index = $this->generateThreadIndex($value, $is_first);
	$mailer->addHeader('Thread-Index', $thread_index);
	break;
	case 'mailtags':
	// Handled below.
	break;
	- case 'vary-subject':
	+ case 'subject-prefix':
	+ case 'vary-subject-prefix':
	// Handled above.
	break;
	default:
	// Just discard.
	}
	}

	$mailer->addHeader('X-Phabricator-Sent-This-Message', 'Yes');
	$mailer->addHeader('X-Mail-Transport-Agent', 'MetaMTA');

	// Some clients respect this to suppress OOF and other auto-responses.
	$mailer->addHeader('X-Auto-Response-Suppress', 'All');

	// If the message has mailtags, filter out any recipients who don't want
	// to receive this type of mail.
	$mailtags = $this->getParam('mailtags');
	if ($mailtags && ($add_to \|\| $add_cc)) {

	$tag_header = array();
	foreach ($mailtags as $mailtag) {
	$tag_header[] = '<'.$mailtag.'>';
	}
	$tag_header = implode(', ', $tag_header);
	$mailer->addHeader('X-Phabricator-Mail-Tags', $tag_header);

	$exclude = array();

	$all_recipients = array_merge(
	array_keys($add_to),
	array_keys($add_cc));

	$all_prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
	'userPHID in (%Ls)',
	$all_recipients);
	$all_prefs = mpull($all_prefs, null, 'getUserPHID');

	foreach ($all_recipients as $recipient) {
	$prefs = idx($all_prefs, $recipient);
	if (!$prefs) {
	continue;
	}

	$user_mailtags = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MAILTAGS,
	array());

	// The user must have elected to receive mail for at least one
	// of the mailtags.
	$send = false;
	foreach ($mailtags as $tag) {
	if (idx($user_mailtags, $tag, true)) {
	$send = true;
	break;
	}
	}

	if (!$send) {
	$exclude[$recipient] = true;
	}
	}

	$add_to = array_diff_key($add_to, $exclude);
	$add_cc = array_diff_key($add_cc, $exclude);
	}


	if ($add_to) {
	$mailer->addTos($add_to);
	if ($add_cc) {
	$mailer->addCCs($add_cc);
	}
	} else if ($add_cc) {
	// If we have CC addresses but no "to" address, promote the CCs to
	// "to".
	$mailer->addTos($add_cc);
	} else {
	$this->setStatus(self::STATUS_VOID);
	$this->setMessage(
	"Message has no valid recipients: all To/CC are disabled or ".
	"configured not to receive this mail.");
	return $this->save();
	}

	} catch (Exception $ex) {
	$this->setStatus(self::STATUS_FAIL);
	$this->setMessage($ex->getMessage());
	return $this->save();
	}

	if ($this->getRetryCount() < $this->getSimulatedFailureCount()) {
	$ok = false;
	$error = 'Simulated failure.';
	} else {
	try {
	$ok = $mailer->send();
	$error = null;
	} catch (Exception $ex) {
	$ok = false;
	$error = $ex->getMessage()."\n".$ex->getTraceAsString();
	}
	}

	if (!$ok) {
	$this->setMessage($error);
	if ($this->getRetryCount() > self::MAX_RETRIES) {
	$this->setStatus(self::STATUS_FAIL);
	} else {
	$this->setRetryCount($this->getRetryCount() + 1);
	$next_retry = time() + ($this->getRetryCount() * self::RETRY_DELAY);
	$this->setNextRetry($next_retry);
	}
	} else {
	$this->setStatus(self::STATUS_SENT);
	}

	return $this->save();
	}

	public static function getReadableStatus($status_code) {
	static $readable = array(
	self::STATUS_QUEUE => "Queued for Delivery",
	self::STATUS_FAIL => "Delivery Failed",
	self::STATUS_SENT => "Sent",
	self::STATUS_VOID => "Void",
	);
	$status_code = coalesce($status_code, '?');
	return idx($readable, $status_code, $status_code);
	}

	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);
	}

	private function loadEmailAndNameDataFromPHIDs(array &$phids) {
	$users = array();
	$mlsts = array();
	// first iteration - group by types to do data fetches
	foreach ($phids as $phid => $type) {
	switch ($type) {
	case PhabricatorPHIDConstants::PHID_TYPE_USER:
	$users[] = $phid;
	break;
	case PhabricatorPHIDConstants::PHID_TYPE_MLST:
	$mlsts[] = $phid;
	break;
	}
	}
	$user_emails = array();
	if ($users) {
	$user_emails = id(new PhabricatorUserEmail())->loadAllWhere(
	'userPHID IN (%Ls) AND isPrimary = 1', $users);
	$users = id(new PhabricatorUser())->loadAllWhere(
	'phid IN (%Ls)', $users);
	$user_emails = mpull($user_emails, null, 'getUserPHID');
	$users = mpull($users, null, 'getPHID');
	}
	if ($mlsts) {
	$mlsts = id(new PhabricatorMetaMTAMailingList())->loadAllWhere(
	'phid IN (%Ls)', $mlsts);
	$mlsts = mpull($mlsts, null, 'getPHID');
	}

	// second iteration - create entries for each phid
	$default = PhabricatorEnv::getEnvConfig('metamta.default-address');
	foreach ($phids as $phid => &$value) {
	$name = '';
	$email = $default;
	$is_mailable = false;
	switch ($value) {
	case PhabricatorPHIDConstants::PHID_TYPE_USER:
	$user = $users[$phid];
	if ($user) {
	$name = $user->getFullName();
	$is_mailable = !$user->getIsDisabled()
	&& !$user->getIsSystemAgent();
	}
	$email = $user_emails[$phid] ?
	$user_emails[$phid]->getAddress() :
	$default;
	break;
	case PhabricatorPHIDConstants::PHID_TYPE_MLST:
	$mlst = $mlsts[$phid];
	if ($mlst) {
	$name = $mlst->getName();
	$email = $mlst->getEmail();
	$is_mailable = true;
	}
	break;
	}
	$value = array(
	'name' => $name,
	'email' => $email,
	'mailable' => $is_mailable,
	);
	}
	}

	private function filterSendable($value, $phids, $exclude) {
	$result = array();
	foreach ($value as $phid) {
	if (isset($exclude[$phid])) {
	continue;
	}
	if (isset($phids[$phid]) && $phids[$phid]['mailable']) {
	$result[$phid] = $phids[$phid]['email'];
	}
	}
	return $result;
	}

	public static function shouldMultiplexAllMail() {
	return PhabricatorEnv::getEnvConfig('metamta.one-mail-per-recipient');
	}

	}
	diff --git a/src/applications/owners/mail/PackageMail.php b/src/applications/owners/mail/PackageMail.php
	index 1ec79512d8..6be89d2df0 100644
	--- a/src/applications/owners/mail/PackageMail.php
	+++ b/src/applications/owners/mail/PackageMail.php
	@@ -1,222 +1,220 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	abstract class PackageMail {

	protected $package;
	protected $handles;
	protected $owners;
	protected $paths;
	protected $mailTo;

	public function __construct($package) {
	$this->package = $package;
	}

	abstract protected function getVerb();

	abstract protected function isNewThread();

	final protected function getPackage() {
	return $this->package;
	}

	final protected function getHandles() {
	return $this->handles;
	}

	final protected function getOwners() {
	return $this->owners;
	}

	final protected function getPaths() {
	return $this->paths;
	}

	final protected function getMailTo() {
	return $this->mailTo;
	}

	final protected function renderPackageTitle() {
	return $this->getPackage()->getName();
	}

	final protected function renderRepoSubSection($repository_phid, $paths) {
	$handles = $this->getHandles();
	$section = array();
	$section[] = ' In repository '.$handles[$repository_phid]->getName().
	' - '. PhabricatorEnv::getProductionURI($handles[$repository_phid]
	->getURI());
	foreach ($paths as $path => $ignored) {
	$section[] = ' '.$path;
	}

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

	protected function needSend() {
	return true;
	}

	protected function loadData() {
	$package = $this->getPackage();
	$owners = $package->loadOwners();
	$this->owners = $owners;

	$owner_phids = mpull($owners, 'getUserPHID');
	$primary_owner_phid = $package->getPrimaryOwnerPHID();
	$mail_to = $owner_phids;
	if (!in_array($primary_owner_phid, $owner_phids)) {
	$mail_to[] = $primary_owner_phid;
	}
	$this->mailTo = $mail_to;

	$paths = $package->loadPaths();
	$this->paths = mgroup($paths, 'getRepositoryPHID', 'getPath');

	$phids = array_merge(
	$this->mailTo,
	array($package->getActorPHID()),
	array_keys($this->paths));
	$this->handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
	}

	final protected function renderSummarySection() {
	$package = $this->getPackage();
	$handles = $this->getHandles();
	$section = array();
	$section[] = $handles[$package->getActorPHID()]->getName().' '.
	strtolower($this->getVerb()).' '.$this->renderPackageTitle().'.';
	$section[] = '';

	$section[] = 'PACKAGE DETAIL';
	$section[] = ' '.PhabricatorEnv::getProductionURI(
	'/owners/package/'.$package->getID().'/');

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

	protected function renderDescriptionSection() {
	return "PACKAGE DESCRIPTION\n".
	' '.$this->getPackage()->getDescription();
	}

	protected function renderPrimaryOwnerSection() {
	$handles = $this->getHandles();
	return "PRIMARY OWNER\n".
	' '.$handles[$this->getPackage()->getPrimaryOwnerPHID()]->getName();
	}

	protected function renderOwnersSection() {
	$handles = $this->getHandles();
	$owners = $this->getOwners();
	if (!$owners) {
	return null;
	}

	$owners = mpull($owners, 'getUserPHID');
	$owners = array_select_keys($handles, $owners);
	$owners = mpull($owners, 'getName');
	return "OWNERS\n".
	' '.implode(', ', $owners);
	}

	protected function renderAuditingEnabledSection() {
	return "AUDITING ENABLED STATUS\n".
	' '.($this->getPackage()->getAuditingEnabled() ? 'Enabled' : 'Disabled');
	}

	protected function renderPathsSection() {
	$section = array();
	$section[] = 'PATHS';
	foreach ($this->paths as $repository_phid => $paths) {
	$section[] = $this->renderRepoSubSection($repository_phid, $paths);
	}

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

	final protected function renderBody() {
	$body = array();
	$body[] = $this->renderSummarySection();
	$body[] = $this->renderDescriptionSection();
	$body[] = $this->renderPrimaryOwnerSection();
	$body[] = $this->renderOwnersSection();
	$body[] = $this->renderAuditingEnabledSection();
	$body[] = $this->renderPathsSection();
	$body = array_filter($body);
	return implode("\n\n", $body);
	}

	final public function send() {
	$mails = $this->prepareMails();

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

	final public function prepareMails() {
	if (!$this->needSend()) {
	return array();
	}

	$this->loadData();

	$package = $this->getPackage();
	$prefix = PhabricatorEnv::getEnvConfig('metamta.package.subject-prefix');
	$verb = $this->getVerb();
	- $package_title = $this->renderPackageTitle();
	- $subject = trim("{$prefix} {$package_title}");
	- $vary_subject = trim("{$prefix} [{$verb}] {$package_title}");
	$threading = $this->getMailThreading();
	list($thread_id, $thread_topic) = $threading;

	$template = id(new PhabricatorMetaMTAMail())
	- ->setSubject($subject)
	- ->setVarySubject($vary_subject)
	+ ->setSubject($this->renderPackageTitle())
	+ ->setSubjectPrefix($prefix)
	+ ->setVarySubjectPrefix("[{$verb}]")
	->setFrom($package->getActorPHID())
	->setThreadID($thread_id, $this->isNewThread())
	->addHeader('Thread-Topic', $thread_topic)
	->setRelatedPHID($package->getPHID())
	->setIsBulk(true)
	->setBody($this->renderBody());

	$reply_handler = $this->newReplyHandler();
	$mails = $reply_handler->multiplexMail(
	$template,
	array_select_keys($this->getHandles(), $this->getMailTo()),
	array());
	return $mails;
	}

	private function getMailThreading() {
	return array(
	'package-'.$this->getPackage()->getPHID(),
	'package '.$this->getPackage()->getPHID(),
	);
	}

	private function newReplyHandler() {
	$reply_handler = PhabricatorEnv::newObjectFromConfig(
	'metamta.package.reply-handler');
	$reply_handler->setMailReceiver($this->getPackage());
	return $reply_handler;
	}

	}
	diff --git a/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php b/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	index 203dee9e33..bcc0b658b7 100644
	--- a/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	+++ b/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
	@@ -1,277 +1,275 @@
	<?php

	/*
	* Copyright 2012 Facebook, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	final class PhabricatorRepositoryCommitHeraldWorker
	extends PhabricatorRepositoryCommitParserWorker {

	public function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());

	if (!$data) {
	// TODO: Permanent failure.
	return;
	}

	$rules = HeraldRule::loadAllByContentTypeWithFullData(
	HeraldContentTypeConfig::CONTENT_TYPE_COMMIT,
	$commit->getPHID());

	$adapter = new HeraldCommitAdapter(
	$repository,
	$commit,
	$data);
	$engine = new HeraldEngine();

	$effects = $engine->applyRules($rules, $adapter);
	$engine->applyEffects($effects, $adapter, $rules);

	$audit_phids = $adapter->getAuditMap();
	if ($audit_phids) {
	$this->createAudits($commit, $audit_phids, $rules);
	}

	$this->createAuditsFromCommitMessage($commit, $data);

	$email_phids = $adapter->getEmailPHIDs();
	if (!$email_phids) {
	return;
	}

	if ($repository->getDetail('herald-disabled')) {
	// This just means "disable email"; audits are (mostly) idempotent.
	return;
	}

	$xscript = $engine->getTranscript();

	$revision = $adapter->loadDifferentialRevision();
	if ($revision) {
	$name = $revision->getTitle();
	} else {
	$name = $data->getSummary();
	}

	$author_phid = $data->getCommitDetail('authorPHID');
	$reviewer_phid = $data->getCommitDetail('reviewerPHID');

	$phids = array_filter(
	array(
	$author_phid,
	$reviewer_phid,
	$commit->getPHID(),
	));

	$handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();

	$commit_handle = $handles[$commit->getPHID()];
	$commit_name = $commit_handle->getName();

	if ($author_phid) {
	$author_name = $handles[$author_phid]->getName();
	} else {
	$author_name = $data->getAuthorName();
	}

	if ($reviewer_phid) {
	$reviewer_name = $handles[$reviewer_phid]->getName();
	} else {
	$reviewer_name = null;
	}

	$who = implode(', ', array_filter(array($author_name, $reviewer_name)));

	$description = $data->getCommitMessage();

	$commit_uri = PhabricatorEnv::getProductionURI($commit_handle->getURI());
	$differential = $revision
	? PhabricatorEnv::getProductionURI('/D'.$revision->getID())
	: 'No revision.';

	$files = $adapter->loadAffectedPaths();
	sort($files);
	$files = implode("\n ", $files);

	$xscript_id = $xscript->getID();

	$manage_uri = PhabricatorEnv::getProductionURI('/herald/view/commits/');
	$why_uri = PhabricatorEnv::getProductionURI(
	'/herald/transcript/'.$xscript_id.'/');

	$reply_handler = PhabricatorAuditCommentEditor::newReplyHandlerForCommit(
	$commit);

	$reply_instructions = $reply_handler->getReplyHandlerInstructions();
	if ($reply_instructions) {
	$reply_instructions =
	"\n".
	"REPLY HANDLER ACTIONS\n".
	" ".$reply_instructions."\n";
	}


	$body = <<<EOBODY
	DESCRIPTION
	{$description}

	DETAILS
	{$commit_uri}

	DIFFERENTIAL REVISION
	{$differential}

	AFFECTED FILES
	{$files}
	{$reply_instructions}
	MANAGE HERALD COMMIT RULES
	{$manage_uri}

	WHY DID I GET THIS EMAIL?
	{$why_uri}

	EOBODY;

	$prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');

	- $subject = trim("{$prefix} {$commit_name}: {$name}");
	- $vary_subject = trim("{$prefix} [Commit] {$commit_name}: {$name}");
	-
	$threading = PhabricatorAuditCommentEditor::getMailThreading(
	$commit->getPHID());
	list($thread_id, $thread_topic) = $threading;

	$template = new PhabricatorMetaMTAMail();
	$template->setRelatedPHID($commit->getPHID());
	- $template->setSubject($subject);
	- $template->setVarySubject($subject);
	+ $template->setSubject("{$commit_name}: {$name}");
	+ $template->setSubjectPrefix($prefix);
	+ $template->setVarySubjectPrefix("[Commit]");
	$template->setBody($body);
	$template->setThreadID($thread_id, $is_new = true);
	$template->addHeader('Thread-Topic', $thread_topic);
	$template->setIsBulk(true);

	$template->addHeader('X-Herald-Rules', $xscript->getXHeraldRulesHeader());
	if ($author_phid) {
	$template->setFrom($author_phid);
	}

	$mails = $reply_handler->multiplexMail(
	$template,
	id(new PhabricatorObjectHandleData($email_phids))->loadHandles(),
	array());

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

	private function createAudits(
	PhabricatorRepositoryCommit $commit,
	array $map,
	array $rules) {
	assert_instances_of($rules, 'HeraldRule');

	$requests = id(new PhabricatorRepositoryAuditRequest())->loadAllWhere(
	'commitPHID = %s',
	$commit->getPHID());
	$requests = mpull($requests, null, 'getAuditorPHID');

	$rules = mpull($rules, null, 'getID');
	foreach ($map as $phid => $rule_ids) {
	$request = idx($requests, $phid);
	if ($request) {
	continue;
	}
	$reasons = array();
	foreach ($rule_ids as $id) {
	$rule_name = '?';
	if ($rules[$id]) {
	$rule_name = $rules[$id]->getName();
	}
	$reasons[] = 'Herald Rule #'.$id.' "'.$rule_name.'" Triggered Audit';
	}

	$request = new PhabricatorRepositoryAuditRequest();
	$request->setCommitPHID($commit->getPHID());
	$request->setAuditorPHID($phid);
	$request->setAuditStatus(PhabricatorAuditStatusConstants::AUDIT_REQUIRED);
	$request->setAuditReasons($reasons);
	$request->save();
	}

	$commit->updateAuditStatus($requests);
	$commit->save();
	}


	/**
	* Find audit requests in the "Auditors" field if it is present and trigger
	* explicit audit requests.
	*/
	private function createAuditsFromCommitMessage(
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $data) {

	$message = $data->getCommitMessage();

	$matches = null;
	if (!preg_match('/^Auditors:\s(.)$/im', $message, $matches)) {
	return;
	}

	$phids = DifferentialFieldSpecification::parseCommitMessageObjectList(
	$matches[1],
	$include_mailables = false,
	$allow_partial = true);

	if (!$phids) {
	return;
	}

	$requests = id(new PhabricatorRepositoryAuditRequest())->loadAllWhere(
	'commitPHID = %s',
	$commit->getPHID());
	$requests = mpull($requests, null, 'getAuditorPHID');

	foreach ($phids as $phid) {
	if (isset($requests[$phid])) {
	continue;
	}

	$request = new PhabricatorRepositoryAuditRequest();
	$request->setCommitPHID($commit->getPHID());
	$request->setAuditorPHID($phid);
	$request->setAuditStatus(
	PhabricatorAuditStatusConstants::AUDIT_REQUESTED);
	$request->setAuditReasons(
	array(
	'Requested by Author',
	));
	$request->save();

	$requests[$phid] = $request;
	}

	$commit->updateAuditStatus($requests);
	$commit->save();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jul 28, 1:31 AM (1 w, 20 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 186319
Default Alt Text: (95 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions