No OneTemporary
Actions

Size

55 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/feed/PhabricatorFeedStoryPublisher.php b/src/applications/feed/PhabricatorFeedStoryPublisher.php
	index 5c6940fc8b..79b3b6cd55 100644
	--- a/src/applications/feed/PhabricatorFeedStoryPublisher.php
	+++ b/src/applications/feed/PhabricatorFeedStoryPublisher.php
	@@ -1,279 +1,288 @@
	<?php

	final class PhabricatorFeedStoryPublisher {

	private $relatedPHIDs;
	private $storyType;
	private $storyData;
	private $storyTime;
	private $storyAuthorPHID;
	private $primaryObjectPHID;
	private $subscribedPHIDs = array();
	private $mailRecipientPHIDs = array();
	private $notifyAuthor;
	private $mailTags = array();

	public function setMailTags(array $mail_tags) {
	$this->mailTags = $mail_tags;
	return $this;
	}

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

	public function setNotifyAuthor($notify_author) {
	$this->notifyAuthor = $notify_author;
	return $this;
	}

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

	public function setRelatedPHIDs(array $phids) {
	$this->relatedPHIDs = $phids;
	return $this;
	}

	public function setSubscribedPHIDs(array $phids) {
	$this->subscribedPHIDs = $phids;
	return $this;
	}

	public function setPrimaryObjectPHID($phid) {
	$this->primaryObjectPHID = $phid;
	return $this;
	}

	public function setStoryType($story_type) {
	$this->storyType = $story_type;
	return $this;
	}

	public function setStoryData(array $data) {
	$this->storyData = $data;
	return $this;
	}

	public function setStoryTime($time) {
	$this->storyTime = $time;
	return $this;
	}

	public function setStoryAuthorPHID($phid) {
	$this->storyAuthorPHID = $phid;
	return $this;
	}

	public function setMailRecipientPHIDs(array $phids) {
	$this->mailRecipientPHIDs = $phids;
	return $this;
	}

	public function publish() {
	$class = $this->storyType;
	if (!$class) {
	throw new Exception('Call setStoryType() before publishing!');
	}

	if (!class_exists($class)) {
	throw new Exception(
	"Story type must be a valid class name and must subclass ".
	"PhabricatorFeedStory. ".
	"'{$class}' is not a loadable class.");
	}

	if (!is_subclass_of($class, 'PhabricatorFeedStory')) {
	throw new Exception(
	"Story type must be a valid class name and must subclass ".
	"PhabricatorFeedStory. ".
	"'{$class}' is not a subclass of PhabricatorFeedStory.");
	}

	$chrono_key = $this->generateChronologicalKey();

	$story = new PhabricatorFeedStoryData();
	$story->setStoryType($this->storyType);
	$story->setStoryData($this->storyData);
	$story->setAuthorPHID((string)$this->storyAuthorPHID);
	$story->setChronologicalKey($chrono_key);
	$story->save();

	if ($this->relatedPHIDs) {
	$ref = new PhabricatorFeedStoryReference();

	$sql = array();
	$conn = $ref->establishConnection('w');
	foreach (array_unique($this->relatedPHIDs) as $phid) {
	$sql[] = qsprintf(
	$conn,
	'(%s, %s)',
	$phid,
	$chrono_key);
	}

	queryfx(
	$conn,
	'INSERT INTO %T (objectPHID, chronologicalKey) VALUES %Q',
	$ref->getTableName(),
	implode(', ', $sql));
	}

	$subscribed_phids = $this->subscribedPHIDs;
	if ($subscribed_phids) {
	$subscribed_phids = $this->filterSubscribedPHIDs($subscribed_phids);
	$this->insertNotifications($chrono_key, $subscribed_phids);
	$this->sendNotification($chrono_key, $subscribed_phids);
	}

	PhabricatorWorker::scheduleTask(
	'FeedPublisherWorker',
	array(
	'key' => $chrono_key,
	));

	return $story;
	}

	private function insertNotifications($chrono_key, array $subscribed_phids) {
	if (!$this->primaryObjectPHID) {
	throw new Exception(
	'You must call setPrimaryObjectPHID() if you setSubscribedPHIDs()!');
	}

	$notif = new PhabricatorFeedStoryNotification();
	$sql = array();
	$conn = $notif->establishConnection('w');

	$will_receive_mail = array_fill_keys($this->mailRecipientPHIDs, true);

	foreach (array_unique($subscribed_phids) as $user_phid) {
	if (isset($will_receive_mail[$user_phid])) {
	$mark_read = 1;
	} else {
	$mark_read = 0;
	}

	$sql[] = qsprintf(
	$conn,
	'(%s, %s, %s, %d)',
	$this->primaryObjectPHID,
	$user_phid,
	$chrono_key,
	$mark_read);
	}

	if ($sql) {
	queryfx(
	$conn,
	'INSERT INTO %T '.
	'(primaryObjectPHID, userPHID, chronologicalKey, hasViewed) '.
	'VALUES %Q',
	$notif->getTableName(),
	implode(', ', $sql));
	}
	}

	private function sendNotification($chrono_key, array $subscribed_phids) {
	$data = array(
	'key' => (string)$chrono_key,
	'type' => 'notification',
	'subscribers' => $subscribed_phids,
	);

	PhabricatorNotificationClient::tryToPostMessage($data);
	}

	/**
	* Remove PHIDs who should not receive notifications from a subscriber list.
	*
	* @param list<phid> List of potential subscribers.
	* @return list<phid> List of actual subscribers.
	*/
	private function filterSubscribedPHIDs(array $phids) {
	+ $phids = $this->expandRecipients($phids);
	+
	$tags = $this->getMailTags();
	if ($tags) {
	$all_prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
	'userPHID in (%Ls)',
	$phids);
	$all_prefs = mpull($all_prefs, null, 'getUserPHID');
	}

	$pref_default = PhabricatorUserPreferences::MAILTAG_PREFERENCE_EMAIL;
	$pref_ignore = PhabricatorUserPreferences::MAILTAG_PREFERENCE_IGNORE;

	$keep = array();
	foreach ($phids as $phid) {
	if (($phid == $this->storyAuthorPHID) && !$this->getNotifyAuthor()) {
	continue;
	}

	if ($tags && isset($all_prefs[$phid])) {
	$mailtags = $all_prefs[$phid]->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MAILTAGS,
	array());

	$notify = false;
	foreach ($tags as $tag) {
	// If this is set to "email" or "notify", notify the user.
	if ((int)idx($mailtags, $tag, $pref_default) != $pref_ignore) {
	$notify = true;
	break;
	}
	}

	if (!$notify) {
	continue;
	}
	}

	$keep[] = $phid;
	}

	return array_values(array_unique($keep));
	}

	+ private function expandRecipients(array $phids) {
	+ return id(new PhabricatorMetaMTAMemberQuery())
	+ ->setViewer(PhabricatorUser::getOmnipotentUser())
	+ ->withPHIDs($phids)
	+ ->executeExpansion();
	+ }
	+
	/**
	* We generate a unique chronological key for each story type because we want
	* to be able to page through the stream with a cursor (i.e., select stories
	* after ID = X) so we can efficiently perform filtering after selecting data,
	* and multiple stories with the same ID make this cumbersome without putting
	* a bunch of logic in the client. We could use the primary key, but that
	* would prevent publishing stories which happened in the past. Since it's
	* potentially useful to do that (e.g., if you're importing another data
	* source) build a unique key for each story which has chronological ordering.
	*
	* @return string A unique, time-ordered key which identifies the story.
	*/
	private function generateChronologicalKey() {
	// Use the epoch timestamp for the upper 32 bits of the key. Default to
	// the current time if the story doesn't have an explicit timestamp.
	$time = nonempty($this->storyTime, time());

	// Generate a random number for the lower 32 bits of the key.
	$rand = head(unpack('L', Filesystem::readRandomBytes(4)));

	// On 32-bit machines, we have to get creative.
	if (PHP_INT_SIZE < 8) {
	// We're on a 32-bit machine.
	if (function_exists('bcadd')) {
	// Try to use the 'bc' extension.
	return bcadd(bcmul($time, bcpow(2, 32)), $rand);
	} else {
	// Do the math in MySQL. TODO: If we formalize a bc dependency, get
	// rid of this.
	$conn_r = id(new PhabricatorFeedStoryData())->establishConnection('r');
	$result = queryfx_one(
	$conn_r,
	'SELECT (%d << 32) + %d as N',
	$time,
	$rand);
	return $result['N'];
	}
	} else {
	// This is a 64 bit machine, so we can just do the math.
	return ($time << 32) + $rand;
	}
	}
	}
	diff --git a/src/applications/metamta/query/PhabricatorMetaMTAMemberQuery.php b/src/applications/metamta/query/PhabricatorMetaMTAMemberQuery.php
	index 34a1569643..f565baf595 100644
	--- a/src/applications/metamta/query/PhabricatorMetaMTAMemberQuery.php
	+++ b/src/applications/metamta/query/PhabricatorMetaMTAMemberQuery.php
	@@ -1,69 +1,83 @@
	<?php

	/**
	* Expands aggregate mail recipients into their component mailables. For
	* example, a project currently expands into all of its members.
	*/
	final class PhabricatorMetaMTAMemberQuery extends PhabricatorQuery {

	private $phids = array();
	private $viewer;

	public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}

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

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function execute() {
	$phids = array_fuse($this->phids);
	$actors = array();
	$type_map = array();
	foreach ($phids as $phid) {
	$type_map[phid_get_type($phid)][] = $phid;
	}

	// TODO: Generalize this somewhere else.

	$results = array();
	foreach ($type_map as $type => $phids) {
	switch ($type) {
	case PhabricatorProjectProjectPHIDType::TYPECONST:
	// NOTE: We're loading the projects here in order to respect policies.

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($phids)
	->execute();

	$subscribers = id(new PhabricatorSubscribersQuery())
	->withObjectPHIDs($phids)
	->execute();

	$projects = mpull($projects, null, 'getPHID');
	foreach ($phids as $phid) {
	$project = idx($projects, $phid);
	if (!$project) {
	$results[$phid] = array();
	} else {
	$results[$phid] = idx($subscribers, $phid, array());
	}
	}
	break;
	default:
	+ // For other types, just map the PHID to itself without modification.
	+ // This allows callers to do less work.
	+ foreach ($phids as $phid) {
	+ $results[$phid] = array($phid);
	+ }
	break;
	}
	}

	return $results;
	}

	+
	+ /**
	+ * Execute the query, merging results into a single list of unique member
	+ * PHIDs.
	+ */
	+ public function executeExpansion() {
	+ return array_unique(array_mergev($this->execute()));
	+ }
	+
	}
	diff --git a/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php b/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	index c320de9b78..a4d503cf8b 100644
	--- a/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	+++ b/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	@@ -1,385 +1,374 @@
	<?php

	abstract class PhabricatorMailReplyHandler {

	private $mailReceiver;
	private $applicationEmail;
	private $actor;
	private $excludePHIDs = array();

	final public function setMailReceiver($mail_receiver) {
	$this->validateMailReceiver($mail_receiver);
	$this->mailReceiver = $mail_receiver;
	return $this;
	}

	final public function getMailReceiver() {
	return $this->mailReceiver;
	}

	public function setApplicationEmail(
	PhabricatorMetaMTAApplicationEmail $email) {
	$this->applicationEmail = $email;
	return $this;
	}

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

	final public function setActor(PhabricatorUser $actor) {
	$this->actor = $actor;
	return $this;
	}

	final public function getActor() {
	return $this->actor;
	}

	final public function setExcludeMailRecipientPHIDs(array $exclude) {
	$this->excludePHIDs = $exclude;
	return $this;
	}

	final public function getExcludeMailRecipientPHIDs() {
	return $this->excludePHIDs;
	}

	abstract public function validateMailReceiver($mail_receiver);
	abstract public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle);
	public function getReplyHandlerDomain() {
	return $this->getDefaultReplyHandlerDomain();
	}
	protected function getCustomReplyHandlerDomainIfExists($config_key) {
	$domain = PhabricatorEnv::getEnvConfig($config_key);
	if ($domain) {
	return $domain;
	}
	return $this->getDefaultReplyHandlerDomain();
	}
	private function getDefaultReplyHandlerDomain() {
	return PhabricatorEnv::getEnvConfig(
	'metamta.reply-handler-domain');
	}

	abstract public function getReplyHandlerInstructions();
	abstract protected function receiveEmail(
	PhabricatorMetaMTAReceivedMail $mail);

	public function processEmail(PhabricatorMetaMTAReceivedMail $mail) {
	$this->dropEmptyMail($mail);

	return $this->receiveEmail($mail);
	}

	private function dropEmptyMail(PhabricatorMetaMTAReceivedMail $mail) {
	$body = $mail->getCleanTextBody();
	$attachments = $mail->getAttachments();

	if (strlen($body) \|\| $attachments) {
	return;
	}

	// Only send an error email if the user is talking to just Phabricator.
	// We can assume if there is only one "To" address it is a Phabricator
	// address since this code is running and everything.
	$is_direct_mail = (count($mail->getToAddresses()) == 1) &&
	(count($mail->getCCAddresses()) == 0);

	if ($is_direct_mail) {
	$status_code = MetaMTAReceivedMailStatus::STATUS_EMPTY;
	} else {
	$status_code = MetaMTAReceivedMailStatus::STATUS_EMPTY_IGNORED;
	}

	throw new PhabricatorMetaMTAReceivedMailProcessingException(
	$status_code,
	pht(
	'Your message does not contain any body text or attachments, so '.
	'Phabricator can not do anything useful with it. Make sure comment '.
	'text appears at the top of your message: quoted replies, inline '.
	'text, and signatures are discarded and ignored.'));
	}

	public function supportsPrivateReplies() {
	return (bool)$this->getReplyHandlerDomain() &&
	!$this->supportsPublicReplies();
	}

	public function supportsPublicReplies() {
	if (!PhabricatorEnv::getEnvConfig('metamta.public-replies')) {
	return false;
	}
	if (!$this->getReplyHandlerDomain()) {
	return false;
	}
	return (bool)$this->getPublicReplyHandlerEmailAddress();
	}

	final public function supportsReplies() {
	return $this->supportsPrivateReplies() \|\|
	$this->supportsPublicReplies();
	}

	public function getPublicReplyHandlerEmailAddress() {
	return null;
	}

	final public function getRecipientsSummary(
	array $to_handles,
	array $cc_handles) {
	assert_instances_of($to_handles, 'PhabricatorObjectHandle');
	assert_instances_of($cc_handles, 'PhabricatorObjectHandle');

	$body = '';

	if (PhabricatorEnv::getEnvConfig('metamta.recipients.show-hints')) {
	if ($to_handles) {
	$body .= "To: ".implode(', ', mpull($to_handles, 'getName'))."\n";
	}
	if ($cc_handles) {
	$body .= "Cc: ".implode(', ', mpull($cc_handles, 'getName'))."\n";
	}
	}

	return $body;
	}

	final public function getRecipientsSummaryHTML(
	array $to_handles,
	array $cc_handles) {
	assert_instances_of($to_handles, 'PhabricatorObjectHandle');
	assert_instances_of($cc_handles, 'PhabricatorObjectHandle');

	if (PhabricatorEnv::getEnvConfig('metamta.recipients.show-hints')) {
	$body = array();
	if ($to_handles) {
	$body[] = phutil_tag('strong', array(), 'To: ');
	$body[] = phutil_implode_html(', ', mpull($to_handles, 'getName'));
	$body[] = phutil_tag('br');
	}
	if ($cc_handles) {
	$body[] = phutil_tag('strong', array(), 'Cc: ');
	$body[] = phutil_implode_html(', ', mpull($cc_handles, 'getName'));
	$body[] = phutil_tag('br');
	}
	return phutil_tag('div', array(), $body);
	} else {
	return '';
	}

	}

	final public function multiplexMail(
	PhabricatorMetaMTAMail $mail_template,
	array $to_handles,
	array $cc_handles) {
	assert_instances_of($to_handles, 'PhabricatorObjectHandle');
	assert_instances_of($cc_handles, 'PhabricatorObjectHandle');

	$result = array();

	// If MetaMTA is configured to always multiplex, skip the single-email
	// case.
	if (!PhabricatorMetaMTAMail::shouldMultiplexAllMail()) {
	// If private replies are not supported, simply send one email to all
	// recipients and CCs. This covers cases where we have no reply handler,
	// or we have a public reply handler.
	if (!$this->supportsPrivateReplies()) {
	$mail = clone $mail_template;
	$mail->addTos(mpull($to_handles, 'getPHID'));
	$mail->addCCs(mpull($cc_handles, 'getPHID'));

	if ($this->supportsPublicReplies()) {
	$reply_to = $this->getPublicReplyHandlerEmailAddress();
	$mail->setReplyTo($reply_to);
	}

	$result[] = $mail;

	return $result;
	}
	}

	// TODO: This is pretty messy. We should really be doing all of this
	// multiplexing in the task queue, but that requires significant rewriting
	// in the general case. ApplicationTransactions can do it fairly easily,
	// but other mail sites currently can not, so we need to support this
	// junky version until they catch up and we can swap things over.

	$to_handles = $this->expandRecipientHandles($to_handles);
	$cc_handles = $this->expandRecipientHandles($cc_handles);

	$tos = mpull($to_handles, null, 'getPHID');
	$ccs = mpull($cc_handles, null, 'getPHID');

	// Merge all the recipients together. TODO: We could keep the CCs as real
	// CCs and send to a "noreply@domain.com" type address, but keep it simple
	// for now.
	$recipients = $tos + $ccs;

	// When multiplexing mail, explicitly include To/Cc information in the
	// message body and headers.

	$mail_template = clone $mail_template;

	$mail_template->addPHIDHeaders('X-Phabricator-To', array_keys($tos));
	$mail_template->addPHIDHeaders('X-Phabricator-Cc', array_keys($ccs));

	$body = $mail_template->getBody();
	$body .= "\n";
	$body .= $this->getRecipientsSummary($to_handles, $cc_handles);

	$html_body = $mail_template->getHTMLBody();
	if (strlen($html_body)) {
	$html_body .= hsprintf('%s',
	$this->getRecipientsSummaryHTML($to_handles, $cc_handles));
	}

	foreach ($recipients as $phid => $recipient) {

	$mail = clone $mail_template;
	if (isset($to_handles[$phid])) {
	$mail->addTos(array($phid));
	} else if (isset($cc_handles[$phid])) {
	$mail->addCCs(array($phid));
	} else {
	// not good - they should be a to or a cc
	continue;
	}

	$mail->setBody($body);
	$mail->setHTMLBody($html_body);

	$reply_to = null;
	if (!$reply_to && $this->supportsPrivateReplies()) {
	$reply_to = $this->getPrivateReplyHandlerEmailAddress($recipient);
	}

	if (!$reply_to && $this->supportsPublicReplies()) {
	$reply_to = $this->getPublicReplyHandlerEmailAddress();
	}

	if ($reply_to) {
	$mail->setReplyTo($reply_to);
	}

	$result[] = $mail;
	}

	return $result;
	}

	protected function getDefaultPublicReplyHandlerEmailAddress($prefix) {

	$receiver = $this->getMailReceiver();
	$receiver_id = $receiver->getID();
	$domain = $this->getReplyHandlerDomain();

	// We compute a hash using the object's own PHID to prevent an attacker
	// from blindly interacting with objects that they haven't ever received
	// mail about by just sending to D1@, D2@, etc...
	$hash = PhabricatorObjectMailReceiver::computeMailHash(
	$receiver->getMailKey(),
	$receiver->getPHID());

	$address = "{$prefix}{$receiver_id}+public+{$hash}@{$domain}";
	return $this->getSingleReplyHandlerPrefix($address);
	}

	protected function getSingleReplyHandlerPrefix($address) {
	$single_handle_prefix = PhabricatorEnv::getEnvConfig(
	'metamta.single-reply-handler-prefix');
	return ($single_handle_prefix)
	? $single_handle_prefix.'+'.$address
	: $address;
	}

	protected function getDefaultPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle,
	$prefix) {

	if ($handle->getType() != PhabricatorPeopleUserPHIDType::TYPECONST) {
	// You must be a real user to get a private reply handler address.
	return null;
	}

	$user = id(new PhabricatorPeopleQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($handle->getPHID()))
	->executeOne();

	if (!$user) {
	// This may happen if a user was subscribed to something, and was then
	// deleted.
	return null;
	}

	$receiver = $this->getMailReceiver();
	$receiver_id = $receiver->getID();
	$user_id = $user->getID();
	$hash = PhabricatorObjectMailReceiver::computeMailHash(
	$receiver->getMailKey(),
	$handle->getPHID());
	$domain = $this->getReplyHandlerDomain();

	$address = "{$prefix}{$receiver_id}+{$user_id}+{$hash}@{$domain}";
	return $this->getSingleReplyHandlerPrefix($address);
	}

	final protected function enhanceBodyWithAttachments(
	$body,
	array $attachments,
	$format = '- {F%d, layout=link}') {
	if (!$attachments) {
	return $body;
	}

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

	// if we have some text then double return before adding our file list
	if ($body) {
	$body .= "\n\n";
	}

	foreach ($files as $file) {
	$file_str = sprintf($format, $file->getID());
	$body .= $file_str."\n";
	}

	return rtrim($body);
	}

	private function expandRecipientHandles(array $handles) {
	if (!$handles) {
	return array();
	}

	$phids = mpull($handles, 'getPHID');
	- $map = id(new PhabricatorMetaMTAMemberQuery())
	+ $results = id(new PhabricatorMetaMTAMemberQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($phids)
	- ->execute();
	-
	- $results = array();
	- foreach ($phids as $phid) {
	- if (isset($map[$phid])) {
	- foreach ($map[$phid] as $expanded_phid) {
	- $results[$expanded_phid] = $expanded_phid;
	- }
	- } else {
	- $results[$phid] = $phid;
	- }
	- }
	+ ->executeExpansion();

	return id(new PhabricatorHandleQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($results)
	->execute();
	}

	}
	diff --git a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	index 0fb118252a..4f2fe4821f 100644
	--- a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	+++ b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	@@ -1,978 +1,966 @@
	<?php

	/**
	* @task recipients Managing Recipients
	*/
	final class PhabricatorMetaMTAMail extends PhabricatorMetaMTADAO {

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

	const RETRY_DELAY = 5;

	protected $parameters;
	protected $status;
	protected $message;
	protected $relatedPHID;

	private $recipientExpansionMap;

	public function __construct() {

	$this->status = self::STATUS_QUEUE;
	$this->parameters = array();

	parent::__construct();
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_SERIALIZATION => array(
	'parameters' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'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'),
	),
	'relatedPHID' => array(
	'columns' => array('relatedPHID'),
	),
	'key_created' => array(
	'columns' => array('dateCreated'),
	),
	),
	) + parent::getConfiguration();
	}

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

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

	/**
	* 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', 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 getTranslation(array $objects) {
	$default_translation = PhabricatorEnv::getEnvConfig('translation.provider');
	$return = null;
	$recipients = array_merge(
	idx($this->parameters, 'to', array()),
	idx($this->parameters, 'cc', array()));
	foreach (array_select_keys($objects, $recipients) as $object) {
	$translation = null;
	if ($object instanceof PhabricatorUser) {
	$translation = $object->getTranslation();
	}
	if (!$translation) {
	$translation = $default_translation;
	}
	if ($return && $translation != $return) {
	return $default_translation;
	}
	$return = $translation;
	}

	if (!$return) {
	$return = $default_translation;
	}

	return $return;
	}

	public function addPHIDHeaders($name, array $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 setAttachments(array $attachments) {
	assert_instances_of($attachments, 'PhabricatorMetaMTAAttachment');
	$this->setParam('attachments', mpull($attachments, 'toDictionary'));
	return $this;
	}

	public function setFrom($from) {
	$this->setParam('from', $from);
	return $this;
	}

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

	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 task ID.
	$result = parent::save();

	// Queue a task to send this mail.
	$mailer_task = PhabricatorWorker::scheduleTask(
	'PhabricatorMetaMTAWorker',
	$this->getID(),
	array(
	'priority' => PhabricatorWorker::PRIORITY_ALERTS,
	));

	$this->saveTransaction();

	return $result;
	}

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

	try {
	$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');

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

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

	// Only try to use preferences if everything is multiplexed, so we
	// get consistent behavior.
	$use_prefs = self::shouldMultiplexAllMail();

	$prefs = null;
	if ($use_prefs) {

	// If multiplexing is enabled, 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()));
	}

	if ($target_phid) {
	$user = id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$target_phid);
	if ($user) {
	$prefs = $user->loadPreferences();
	}
	}
	}

	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':
	$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 'headers':
	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);

	$mailer->addHeader($header_key, $header_value);
	}
	break;
	case 'attachments':
	$value = $this->getAttachments();
	foreach ($value as $attachment) {
	$mailer->addAttachment(
	$attachment->getData(),
	$attachment->getFilename(),
	$attachment->getMimeType());
	}
	break;
	case '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) {
	$subject[] = 'Re:';
	}
	}

	$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-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 'subject-prefix':
	case 'vary-subject-prefix':
	// Handled above.
	break;
	default:
	// Just discard.
	}
	}

	$body = idx($params, '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);

	$html_emails = false;
	if ($use_prefs && $prefs) {
	$html_emails = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_HTML_EMAILS,
	$html_emails);
	}

	if ($html_emails && isset($params['html-body'])) {
	$mailer->setHTMLBody($params['html-body']);
	}

	if (!$add_to && !$add_cc) {
	$this->setStatus(self::STATUS_VOID);
	$this->setMessage(
	'Message has no valid recipients: all To/Cc are disabled, invalid, '.
	'or configured not to receive this mail.');
	return $this->save();
	}

	if ($this->getIsErrorEmail()) {
	$all_recipients = array_merge($add_to, $add_cc);
	if ($this->shouldRateLimitMail($all_recipients)) {
	$this->setStatus(self::STATUS_VOID);
	$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 $this->save();
	}
	}

	if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
	$this->setStatus(self::STATUS_VOID);
	$this->setMessage(
	pht(
	'Phabricator is running in silent mode. See `phabricator.silent` '.
	'in the configuration to change this setting.'));
	return $this->save();
	}

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

	// 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);
	}
	} catch (Exception $ex) {
	$this
	->setStatus(self::STATUS_FAIL)
	->setMessage($ex->getMessage())
	->save();

	throw $ex;
	}

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

	$this->setStatus(self::STATUS_SENT);
	$this->save();

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

	throw $ex;
	} catch (Exception $ex) {
	$this
	->setMessage($ex->getMessage()."\n".$ex->getTraceAsString())
	->save();

	throw $ex;
	}
	}

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

	public static function shouldMultiplexAllMail() {
	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->loadActors(
	- array_merge(
	- $this->getToPHIDs(),
	- $this->getCcPHIDs()));
	+ $actors = $this->loadAllActors();
	$actors = $this->filterDeliverableActors($actors);
	return mpull($actors, 'getPHID');
	}

	public function loadAllActors() {
	- $actor_phids = array_merge(
	- array($this->getParam('from')),
	- $this->getToPHIDs(),
	- $this->getCcPHIDs());
	-
	- $this->loadRecipientExpansions($actor_phids);
	+ $actor_phids = $this->getAllActorPHIDs();
	$actor_phids = $this->expandRecipients($actor_phids);
	-
	return $this->loadActors($actor_phids);
	}

	- private function loadRecipientExpansions(array $phids) {
	- $expansions = id(new PhabricatorMetaMTAMemberQuery())
	- ->setViewer(PhabricatorUser::getOmnipotentUser())
	- ->withPHIDs($phids)
	- ->execute();
	-
	- $this->recipientExpansionMap = $expansions;
	-
	- return $this;
	+ 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) {
	- throw new Exception(
	- pht(
	- 'Call loadRecipientExpansions() before expandRecipients()!'));
	+ $all_phids = $this->getAllActorPHIDs();
	+ $this->recipientExpansionMap = id(new PhabricatorMetaMTAMemberQuery())
	+ ->setViewer(PhabricatorUser::getOmnipotentUser())
	+ ->withPHIDs($all_phids)
	+ ->execute();
	}

	$results = array();
	foreach ($phids as $phid) {
	- if (!isset($this->recipientExpansionMap[$phid])) {
	- $results[$phid] = $phid;
	- } else {
	- foreach ($this->recipientExpansionMap[$phid] as $recipient_phid) {
	- $results[$recipient_phid] = $recipient_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.
	return $actors;
	}

	// Exclude explicit recipients.
	foreach ($this->getExcludeMailRecipientPHIDs() as $phid) {
	$actor = idx($actors, $phid);
	if (!$actor) {
	continue;
	}
	$actor->setUndeliverable(
	pht(
	'This message is a response to another email message, and this '.
	'recipient received the original email message, so we are not '.
	'sending them this substantially similar message (for example, '.
	'the sender used "Reply All" instead of "Reply" in response to '.
	'mail from Phabricator).'));
	}

	// 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))
	->execute();
	$from_user = head($from_user);
	if ($from_user) {
	$pref_key = PhabricatorUserPreferences::PREFERENCE_NO_SELF_MAIL;
	$exclude_self = $from_user
	->loadPreferences()
	->getPreference($pref_key);
	if ($exclude_self) {
	$from_actor->setUndeliverable(
	pht(
	'This recipient is the user whose actions caused delivery of '.
	'this message, but they have set preferences so they do not '.
	'receive mail about their own actions (Settings > Email '.
	'Preferences > Self Actions).'));
	}
	}
	}

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

	// Exclude recipients who don't want any mail.
	foreach ($all_prefs as $phid => $prefs) {
	$exclude = $prefs->getPreference(
	PhabricatorUserPreferences::PREFERENCE_NO_MAIL,
	false);
	if ($exclude) {
	$actors[$phid]->setUndeliverable(
	pht(
	'This recipient has disabled all email notifications '.
	'(Settings > Email Preferences > Email Notifications).'));
	}
	}

	$value_email = PhabricatorUserPreferences::MAILTAG_PREFERENCE_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->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MAILTAGS,
	array());

	// 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(
	pht(
	'This mail has tags which control which users receive it, and '.
	'this recipient has not elected to receive mail with any of '.
	'the tags on this message (Settings > Email Preferences).'));
	}
	}
	}

	return $actors;
	}

	private function shouldRateLimitMail(array $all_recipients) {
	try {
	PhabricatorSystemActionEngine::willTakeAction(
	$all_recipients,
	new PhabricatorMetaMTAErrorMailAction(),
	1);
	return false;
	} catch (PhabricatorSystemActionRateLimitException $ex) {
	return true;
	}
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 10, 3:37 PM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 140205
Default Alt Text: (55 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions