No OneTemporary
Actions

Size

81 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/base/controller/PhabricatorController.php b/src/applications/base/controller/PhabricatorController.php
	index 33d7d84fa3..ad0055f3aa 100644
	--- a/src/applications/base/controller/PhabricatorController.php
	+++ b/src/applications/base/controller/PhabricatorController.php
	@@ -1,132 +1,130 @@
	<?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 PhabricatorController extends AphrontController {

	public function shouldRequireLogin() {
	return true;
	}

	public function shouldRequireAdmin() {
	return false;
	}

	public function shouldRequireEnabledUser() {
	return true;
	}

	public function shouldRequireEmailVerification() {
	$need_verify = PhabricatorUserEmail::isEmailVerificationRequired();
	$need_login = $this->shouldRequireLogin();

	return ($need_login && $need_verify);
	}

	final public function willBeginExecution() {

	$request = $this->getRequest();

	$user = new PhabricatorUser();

	$phusr = $request->getCookie('phusr');
	$phsid = $request->getCookie('phsid');

	if ($phusr && $phsid) {
	$info = queryfx_one(
	$user->establishConnection('r'),
	'SELECT u.* FROM %T u JOIN %T s ON u.phid = s.userPHID
	AND s.type LIKE %> AND s.sessionKey = %s',
	$user->getTableName(),
	'phabricator_session',
	'web-',
	$phsid);
	if ($info) {
	$user->loadFromArray($info);
	}
	}

	$translation = $user->getTranslation();
	if ($translation &&
	- $translation != PhabricatorEnv::getEnvConfig('translation.provider') &&
	- class_exists($translation) &&
	- is_subclass_of($translation, 'PhabricatorTranslation')) {
	+ $translation != PhabricatorEnv::getEnvConfig('translation.provider')) {
	$translation = newv($translation, array());
	PhutilTranslator::getInstance()
	->setLanguage($translation->getLanguage())
	->addTranslations($translation->getTranslations());
	}

	$request->setUser($user);

	if ($user->getIsDisabled() && $this->shouldRequireEnabledUser()) {
	$disabled_user_controller = new PhabricatorDisabledUserController(
	$request);
	return $this->delegateToController($disabled_user_controller);
	}

	if (PhabricatorEnv::getEnvConfig('darkconsole.enabled')) {
	if ($user->getConsoleEnabled() \|\|
	PhabricatorEnv::getEnvConfig('darkconsole.always-on')) {
	$console = new DarkConsoleCore();
	$request->getApplicationConfiguration()->setConsole($console);
	}
	}

	if ($this->shouldRequireLogin() && !$user->getPHID()) {
	$login_controller = new PhabricatorLoginController($request);
	return $this->delegateToController($login_controller);
	}

	if ($this->shouldRequireEmailVerification()) {
	$email = $user->loadPrimaryEmail();
	if (!$email) {
	throw new Exception(
	"No primary email address associated with this account!");
	}
	if (!$email->getIsVerified()) {
	$verify_controller = new PhabricatorMustVerifyEmailController($request);
	return $this->delegateToController($verify_controller);
	}
	}

	if ($this->shouldRequireAdmin() && !$user->getIsAdmin()) {
	return new Aphront403Response();
	}

	}

	public function buildStandardPageView() {
	$view = new PhabricatorStandardPageView();
	$view->setRequest($this->getRequest());

	if ($this->shouldRequireAdmin()) {
	$view->setIsAdminInterface(true);
	}

	return $view;
	}

	public function buildStandardPageResponse($view, array $data) {
	$page = $this->buildStandardPageView();
	$page->appendChild($view);
	$response = new AphrontWebpageResponse();
	$response->setContent($page->render());
	return $response;
	}

	}
	diff --git a/src/applications/differential/mail/DifferentialCommentMail.php b/src/applications/differential/mail/DifferentialCommentMail.php
	index b8d32b93ab..412dcd8b63 100644
	--- a/src/applications/differential/mail/DifferentialCommentMail.php
	+++ b/src/applications/differential/mail/DifferentialCommentMail.php
	@@ -1,168 +1,178 @@
	<?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;

	+ private $addedReviewers;
	+ private $addedCCs;
	+
	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 renderVaryPrefix() {
	$verb = ucwords($this->getVerb());
	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}\".";
	+ protected function prepareBody() {
	+ parent::prepareBody();

	// If the commented added reviewers or CCs, list them explicitly.
	- $meta = $comment->getMetadata();
	+ $meta = $this->getComment()->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);
	+ $this->addedReviewers = $this->renderHandleList($handles, $m_reviewers);
	}
	if ($m_cc) {
	- $body[] = 'Added CCs: '.$this->renderHandleList(
	- $handles,
	- $m_cc);
	+ $this->addedCCs = $this->renderHandleList($handles, $m_cc);
	}
	}
	+ }
	+
	+ 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 ($this->addedReviewers) {
	+ $body[] = 'Added Reviewers: '.$this->addedReviewers;
	+ }
	+ if ($this->addedCCs) {
	+ $body[] = 'Added CCs: '.$this->addedCCs;
	+ }

	$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/DifferentialMail.php b/src/applications/differential/mail/DifferentialMail.php
	index 6b5a1e6d10..7cebc79069 100644
	--- a/src/applications/differential/mail/DifferentialMail.php
	+++ b/src/applications/differential/mail/DifferentialMail.php
	@@ -1,418 +1,463 @@
	<?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 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();
	- $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($this->renderSubject())
	- ->setSubjectPrefix($this->getSubjectPrefix())
	- ->setVarySubjectPrefix($this->renderVaryPrefix())
	- ->setBody($body)
	->setIsHTML($this->shouldMarkMailAsHTML())
	->setParentMessageID($this->parentMessageID)
	->addHeader('Thread-Topic', $this->getThreadTopic());

	$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();
	+ $objects = id(new PhabricatorObjectHandleData($phids))->loadObjects();

	- $event = new PhabricatorEvent(
	- PhabricatorEventType::TYPE_DIFFERENTIAL_WILLSENDMAIL,
	- array(
	- 'mail' => $template,
	- )
	- );
	- PhutilEventEngine::dispatchEvent($event);
	+ $to_handles = array_select_keys($handles, $to_phids);
	+ $cc_handles = array_select_keys($handles, $cc_phids);

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

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

	- foreach ($mails as $mail) {
	- $mail->saveAndSend();
	+ $original_translator = PhutilTranslator::getInstance();
	+ if (!PhabricatorMetaMTAMail::shouldMultiplexAllMail()) {
	+ $translation = PhabricatorEnv::newObjectFromConfig(
	+ 'translation.provider');
	+ $translator = id(new PhutilTranslator())
	+ ->setLanguage($translation->getLanguage())
	+ ->addTranslations($translation->getTranslations());
	}
	+
	+ try {
	+ foreach ($mails as $mail) {
	+ if (PhabricatorMetaMTAMail::shouldMultiplexAllMail()) {
	+ $translation = newv($mail->getTranslation($objects), array());
	+ $translator = id(new PhutilTranslator())
	+ ->setLanguage($translation->getLanguage())
	+ ->addTranslations($translation->getTranslations());
	+ PhutilTranslator::setInstance($translator);
	+ }
	+
	+ $body =
	+ $this->buildBody()."\n".
	+ $reply_handler->getRecipientsSummary($to_handles, $cc_handles);
	+
	+ $mail
	+ ->setSubject($this->renderSubject())
	+ ->setSubjectPrefix($this->getSubjectPrefix())
	+ ->setVarySubjectPrefix($this->renderVaryPrefix())
	+ ->setBody($body);
	+
	+ $event = new PhabricatorEvent(
	+ PhabricatorEventType::TYPE_DIFFERENTIAL_WILLSENDMAIL,
	+ array(
	+ 'mail' => $mail,
	+ )
	+ );
	+ PhutilEventEngine::dispatchEvent($event);
	+ $mail = $event->getValue('mail');
	+
	+ $mail->saveAndSend();
	+ }
	+
	+ } catch (Exception $ex) {
	+ PhutilTranslator::setInstance($original_translator);
	+ throw $ex;
	+ }
	+
	+ PhutilTranslator::setInstance($original_translator);
	}

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

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

	protected function shouldMarkMailAsHTML() {
	return false;
	}

	+ /**
	+ * @{method:buildBody} is called once for each e-mail recipient to allow
	+ * translating text to his language. This method can be used to load data that
	+ * don't need translation and use them later in @{method:buildBody}.
	+ *
	+ * @param
	+ * @return
	+ */
	+ protected function prepareBody() {
	+ }
	+
	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", rtrim($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";
	}

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

	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());
	+ // TODO: Introduce and use getRequiredHandlePHIDsForMail() and load all
	+ // handles in prepareBody().
	$text = $field->renderValueForMail($phase);
	if ($text !== null) {
	$body[] = $text;
	$body[] = null;
	}
	}

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

	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/DifferentialReviewRequestMail.php b/src/applications/differential/mail/DifferentialReviewRequestMail.php
	index 94cf686cbf..446579468f 100644
	--- a/src/applications/differential/mail/DifferentialReviewRequestMail.php
	+++ b/src/applications/differential/mail/DifferentialReviewRequestMail.php
	@@ -1,147 +1,152 @@
	<?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 DifferentialReviewRequestMail extends DifferentialMail {

	protected $comments;

	+ private $patch;
	+
	public function setComments($comments) {
	$this->comments = $comments;
	return $this;
	}

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

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

	$this->setRevision($revision);
	$this->setActorHandle($actor);
	$this->setChangesets($changesets);
	}

	+ protected function prepareBody() {
	+ parent::prepareBody();
	+
	+ $inline_max_length = PhabricatorEnv::getEnvConfig(
	+ 'metamta.differential.inline-patches');
	+ if ($inline_max_length) {
	+ $patch = $this->buildPatch();
	+ if (count(explode("\n", $patch)) <= $inline_max_length) {
	+ $this->patch = $patch;
	+ }
	+ }
	+ }
	+
	protected function renderReviewRequestBody() {
	$revision = $this->getRevision();

	$body = array();
	if (!$this->isFirstMailToRecipients()) {
	if (strlen($this->getComments())) {
	$body[] = $this->formatText($this->getComments());
	$body[] = null;
	}
	}

	$phase = ($this->isFirstMailToRecipients() ?
	DifferentialMailPhase::WELCOME :
	DifferentialMailPhase::UPDATE);
	$body[] = $this->renderAuxFields($phase);

	$changesets = $this->getChangesets();
	if ($changesets) {
	$body[] = 'AFFECTED FILES';
	foreach ($changesets as $changeset) {
	$body[] = ' '.$changeset->getFilename();
	}
	$body[] = null;
	}

	- $inline_key = 'metamta.differential.inline-patches';
	- $inline_max_length = PhabricatorEnv::getEnvConfig($inline_key);
	- if ($inline_max_length) {
	- $patch = $this->buildPatch();
	- if (count(explode("\n", $patch)) <= $inline_max_length) {
	- $body[] = 'CHANGE DETAILS';
	- $body[] = $patch;
	- }
	+ if ($this->patch) {
	+ $body[] = 'CHANGE DETAILS';
	+ $body[] = $this->patch;
	}

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

	protected function buildAttachments() {
	$attachments = array();

	if (PhabricatorEnv::getEnvConfig('metamta.differential.attach-patches')) {

	$revision = $this->getRevision();
	$revision_id = $revision->getID();

	$diffs = $revision->loadDiffs();
	$diff_number = count($diffs);

	$attachments[] = new PhabricatorMetaMTAAttachment(
	$this->buildPatch(),
	"D{$revision_id}.{$diff_number}.patch",
	'text/x-patch; charset=utf-8'
	);
	}

	return $attachments;
	}

	public function loadFileByPHID($phid) {
	$file = id(new PhabricatorFile())->loadOneWhere(
	'phid = %s',
	$phid);
	if (!$file) {
	return null;
	}
	return $file->loadFileData();
	}

	private function buildPatch() {
	- $revision = $this->getRevision();
	- $revision_id = $revision->getID();
	-
	- $diffs = $revision->loadDiffs();
	- $diff_number = count($diffs);
	- $diff = array_pop($diffs);
	+ $diff = new DifferentialDiff();

	- $diff->attachChangesets($diff->loadChangesets());
	+ $diff->attachChangesets($this->getChangesets());
	// TODO: We could batch this to improve performance.
	foreach ($diff->getChangesets() as $changeset) {
	$changeset->attachHunks($changeset->loadHunks());
	}
	$diff_dict = $diff->getDiffDict();

	$changes = array();
	foreach ($diff_dict['changes'] as $changedict) {
	$changes[] = ArcanistDiffChange::newFromDictionary($changedict);
	}
	$bundle = ArcanistBundle::newFromChanges($changes);

	$bundle->setLoadFileDataCallback(array($this, 'loadFileByPHID'));

	$format = PhabricatorEnv::getEnvConfig('metamta.differential.patch-format');
	switch ($format) {
	case 'git':
	return $bundle->toGitPatch();
	break;
	case 'unified':
	default:
	return $bundle->toUnifiedDiff();
	break;
	}
	}

	}
	diff --git a/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php b/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	index 689b37afd8..00bfea095e 100644
	--- a/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	+++ b/src/applications/metamta/replyhandler/PhabricatorMailReplyHandler.php
	@@ -1,209 +1,224 @@
	<?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 PhabricatorMailReplyHandler {

	private $mailReceiver;
	private $actor;

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

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

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

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

	abstract public function validateMailReceiver($mail_receiver);
	abstract public function getPrivateReplyHandlerEmailAddress(
	PhabricatorObjectHandle $handle);
	abstract public function getReplyHandlerDomain();
	abstract public function getReplyHandlerInstructions();
	abstract public function receiveEmail(PhabricatorMetaMTAReceivedMail $mail);

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

	// 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 = mpull($to_handles, null, 'getPHID') +
	mpull($cc_handles, null, 'getPHID');

	// When multiplexing mail, explicitly include To/Cc information in the
	// message body and headers.
	$add_headers = array();

	$body = $mail_template->getBody();
	$body .= "\n";
	if ($to_handles) {
	- $body .= "To: ".implode(', ', mpull($to_handles, 'getName'))."\n";
	$add_headers['X-Phabricator-To'] = $this->formatPHIDList($to_handles);
	}
	if ($cc_handles) {
	- $body .= "Cc: ".implode(', ', mpull($cc_handles, 'getName'))."\n";
	$add_headers['X-Phabricator-Cc'] = $this->formatPHIDList($cc_handles);
	}
	+ $body .= $this->getRecipientsSummary($to_handles, $cc_handles);

	foreach ($recipients as $recipient) {
	$mail = clone $mail_template;
	$mail->addTos(array($recipient->getPHID()));

	$mail->setBody($body);
	foreach ($add_headers as $header => $value) {
	$mail->addHeader($header, $value);
	}

	$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 formatPHIDList(array $handles) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	$list = array();
	foreach ($handles as $handle) {
	$list[] = '<'.$handle->getPHID().'>';
	}
	return implode(', ', $list);
	}

	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 = PhabricatorMetaMTAReceivedMail::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() != PhabricatorPHIDConstants::PHID_TYPE_USER) {
	// You must be a real user to get a private reply handler address.
	return null;
	}

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

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

	}
	diff --git a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	index f6ccdbe25d..e189296885 100644
	--- a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	+++ b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
	@@ -1,748 +1,770 @@
	<?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 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;
	+ }
	+ return $return;
	+ }
	+
	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 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();
	}
	}

	$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-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 '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/people/storage/PhabricatorUser.php b/src/applications/people/storage/PhabricatorUser.php
	index 56482894a6..8786196b89 100644
	--- a/src/applications/people/storage/PhabricatorUser.php
	+++ b/src/applications/people/storage/PhabricatorUser.php
	@@ -1,649 +1,662 @@
	<?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 PhabricatorUser extends PhabricatorUserDAO implements PhutilPerson {

	const SESSION_TABLE = 'phabricator_session';
	const NAMETOKEN_TABLE = 'user_nametoken';

	protected $phid;
	protected $userName;
	protected $realName;
	protected $sex;
	protected $translation;
	protected $passwordSalt;
	protected $passwordHash;
	protected $profileImagePHID;
	protected $timezoneIdentifier = '';

	protected $consoleEnabled = 0;
	protected $consoleVisible = 0;
	protected $consoleTab = '';

	protected $conduitCertificate;

	protected $isSystemAgent = 0;
	protected $isAdmin = 0;
	protected $isDisabled = 0;

	private $preferences = null;

	protected function readField($field) {
	switch ($field) {
	case 'timezoneIdentifier':
	// If the user hasn't set one, guess the server's time.
	return nonempty(
	$this->timezoneIdentifier,
	date_default_timezone_get());
	// Make sure these return booleans.
	case 'isAdmin':
	return (bool)$this->isAdmin;
	case 'isDisabled':
	return (bool)$this->isDisabled;
	case 'isSystemAgent':
	return (bool)$this->isSystemAgent;
	default:
	return parent::readField($field);
	}
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_PARTIAL_OBJECTS => true,
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorPHIDConstants::PHID_TYPE_USER);
	}

	public function setPassword($password) {
	if (!$this->getPHID()) {
	throw new Exception(
	"You can not set a password for an unsaved user because their PHID ".
	"is a salt component in the password hash.");
	}

	if (!strlen($password)) {
	$this->setPasswordHash('');
	} else {
	$this->setPasswordSalt(md5(mt_rand()));
	$hash = $this->hashPassword($password);
	$this->setPasswordHash($hash);
	}
	return $this;
	}

	// To satisfy PhutilPerson.
	public function getSex() {
	return $this->sex;
	}

	+ public function getTranslation() {
	+ try {
	+ if ($this->translation &&
	+ class_exists($this->translation) &&
	+ is_subclass_of($this->translation, 'PhabricatorTranslation')) {
	+ return $this->translation;
	+ }
	+ } catch (PhutilMissingSymbolException $ex) {
	+ return null;
	+ }
	+ return null;
	+ }
	+
	public function isLoggedIn() {
	return !($this->getPHID() === null);
	}

	public function save() {
	if (!$this->getConduitCertificate()) {
	$this->setConduitCertificate($this->generateConduitCertificate());
	}
	$result = parent::save();

	$this->updateNameTokens();
	PhabricatorSearchUserIndexer::indexUser($this);

	return $result;
	}

	private function generateConduitCertificate() {
	return Filesystem::readRandomCharacters(255);
	}

	public function comparePassword($password) {
	if (!strlen($password)) {
	return false;
	}
	if (!strlen($this->getPasswordHash())) {
	return false;
	}
	$password = $this->hashPassword($password);
	return ($password === $this->getPasswordHash());
	}

	private function hashPassword($password) {
	$password = $this->getUsername().
	$password.
	$this->getPHID().
	$this->getPasswordSalt();
	for ($ii = 0; $ii < 1000; $ii++) {
	$password = md5($password);
	}
	return $password;
	}

	const CSRF_CYCLE_FREQUENCY = 3600;
	const CSRF_TOKEN_LENGTH = 16;

	const EMAIL_CYCLE_FREQUENCY = 86400;
	const EMAIL_TOKEN_LENGTH = 24;

	public function getCSRFToken($offset = 0) {
	return $this->generateToken(
	time() + (self::CSRF_CYCLE_FREQUENCY * $offset),
	self::CSRF_CYCLE_FREQUENCY,
	PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
	self::CSRF_TOKEN_LENGTH);
	}

	public function validateCSRFToken($token) {

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

	// When the user posts a form, we check that it contains a valid CSRF token.
	// Tokens cycle each hour (every CSRF_CYLCE_FREQUENCY seconds) and we accept
	// either the current token, the next token (users can submit a "future"
	// token if you have two web frontends that have some clock skew) or any of
	// the last 6 tokens. This means that pages are valid for up to 7 hours.
	// There is also some Javascript which periodically refreshes the CSRF
	// tokens on each page, so theoretically pages should be valid indefinitely.
	// However, this code may fail to run (if the user loses their internet
	// connection, or there's a JS problem, or they don't have JS enabled).
	// Choosing the size of the window in which we accept old CSRF tokens is
	// an issue of balancing concerns between security and usability. We could
	// choose a very narrow (e.g., 1-hour) window to reduce vulnerability to
	// attacks using captured CSRF tokens, but it's also more likely that real
	// users will be affected by this, e.g. if they close their laptop for an
	// hour, open it back up, and try to submit a form before the CSRF refresh
	// can kick in. Since the user experience of submitting a form with expired
	// CSRF is often quite bad (you basically lose data, or it's a big pain to
	// recover at least) and I believe we gain little additional protection
	// by keeping the window very short (the overwhelming value here is in
	// preventing blind attacks, and most attacks which can capture CSRF tokens
	// can also just capture authentication information [sniffing networks]
	// or act as the user [xss]) the 7 hour default seems like a reasonable
	// balance. Other major platforms have much longer CSRF token lifetimes,
	// like Rails (session duration) and Django (forever), which suggests this
	// is a reasonable analysis.
	$csrf_window = 6;

	for ($ii = -$csrf_window; $ii <= 1; $ii++) {
	$valid = $this->getCSRFToken($ii);
	if ($token == $valid) {
	return true;
	}
	}

	return false;
	}

	private function generateToken($epoch, $frequency, $key, $len) {
	$time_block = floor($epoch / $frequency);
	$vec = $this->getPHID().$this->getPasswordHash().$key.$time_block;
	return substr(PhabricatorHash::digest($vec), 0, $len);
	}

	/**
	* Issue a new session key to this user. Phabricator supports different
	* types of sessions (like "web" and "conduit") and each session type may
	* have multiple concurrent sessions (this allows a user to be logged in on
	* multiple browsers at the same time, for instance).
	*
	* Note that this method is transport-agnostic and does not set cookies or
	* issue other types of tokens, it ONLY generates a new session key.
	*
	* You can configure the maximum number of concurrent sessions for various
	* session types in the Phabricator configuration.
	*
	* @param string Session type, like "web".
	* @return string Newly generated session key.
	*/
	public function establishSession($session_type) {
	$conn_w = $this->establishConnection('w');

	if (strpos($session_type, '-') !== false) {
	throw new Exception("Session type must not contain hyphen ('-')!");
	}

	// We allow multiple sessions of the same type, so when a caller requests
	// a new session of type "web", we give them the first available session in
	// "web-1", "web-2", ..., "web-N", up to some configurable limit. If none
	// of these sessions is available, we overwrite the oldest session and
	// reissue a new one in its place.

	$session_limit = 1;
	switch ($session_type) {
	case 'web':
	$session_limit = PhabricatorEnv::getEnvConfig('auth.sessions.web');
	break;
	case 'conduit':
	$session_limit = PhabricatorEnv::getEnvConfig('auth.sessions.conduit');
	break;
	default:
	throw new Exception("Unknown session type '{$session_type}'!");
	}

	$session_limit = (int)$session_limit;
	if ($session_limit <= 0) {
	throw new Exception(
	"Session limit for '{$session_type}' must be at least 1!");
	}

	// NOTE: Session establishment is sensitive to race conditions, as when
	// piping `arc` to `arc`:
	//
	// arc export ... \| arc paste ...
	//
	// To avoid this, we overwrite an old session only if it hasn't been
	// re-established since we read it.

	// Consume entropy to generate a new session key, forestalling the eventual
	// heat death of the universe.
	$session_key = Filesystem::readRandomCharacters(40);

	// Load all the currently active sessions.
	$sessions = queryfx_all(
	$conn_w,
	'SELECT type, sessionKey, sessionStart FROM %T
	WHERE userPHID = %s AND type LIKE %>',
	PhabricatorUser::SESSION_TABLE,
	$this->getPHID(),
	$session_type.'-');
	$sessions = ipull($sessions, null, 'type');
	$sessions = isort($sessions, 'sessionStart');

	$existing_sessions = array_keys($sessions);

	// UNGUARDED WRITES: Logging-in users don't have CSRF stuff yet.
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();

	$retries = 0;
	while (true) {


	// Choose which 'type' we'll actually establish, i.e. what number we're
	// going to append to the basic session type. To do this, just check all
	// the numbers sequentially until we find an available session.
	$establish_type = null;
	for ($ii = 1; $ii <= $session_limit; $ii++) {
	$try_type = $session_type.'-'.$ii;
	if (!in_array($try_type, $existing_sessions)) {
	$establish_type = $try_type;
	$expect_key = $session_key;
	$existing_sessions[] = $try_type;

	// Ensure the row exists so we can issue an update below. We don't
	// care if we race here or not.
	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (userPHID, type, sessionKey, sessionStart)
	VALUES (%s, %s, %s, 0)',
	self::SESSION_TABLE,
	$this->getPHID(),
	$establish_type,
	$session_key);
	break;
	}
	}

	// If we didn't find an available session, choose the oldest session and
	// overwrite it.
	if (!$establish_type) {
	$oldest = reset($sessions);
	$establish_type = $oldest['type'];
	$expect_key = $oldest['sessionKey'];
	}

	// This is so that we'll only overwrite the session if it hasn't been
	// refreshed since we read it. If it has, the session key will be
	// different and we know we're racing other processes. Whichever one
	// won gets the session, we go back and try again.

	queryfx(
	$conn_w,
	'UPDATE %T SET sessionKey = %s, sessionStart = UNIX_TIMESTAMP()
	WHERE userPHID = %s AND type = %s AND sessionKey = %s',
	self::SESSION_TABLE,
	$session_key,
	$this->getPHID(),
	$establish_type,
	$expect_key);

	if ($conn_w->getAffectedRows()) {
	// The update worked, so the session is valid.
	break;
	} else {
	// We know this just got grabbed, so don't try it again.
	unset($sessions[$establish_type]);
	}

	if (++$retries > $session_limit) {
	throw new Exception("Failed to establish a session!");
	}
	}

	$log = PhabricatorUserLog::newLog(
	$this,
	$this,
	PhabricatorUserLog::ACTION_LOGIN);
	$log->setDetails(
	array(
	'session_type' => $session_type,
	'session_issued' => $establish_type,
	));
	$log->setSession($session_key);
	$log->save();

	return $session_key;
	}

	public function destroySession($session_key) {
	$conn_w = $this->establishConnection('w');
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE userPHID = %s AND sessionKey = %s',
	self::SESSION_TABLE,
	$this->getPHID(),
	$session_key);
	}

	private function generateEmailToken(
	PhabricatorUserEmail $email,
	$offset = 0) {

	$key = implode(
	'-',
	array(
	PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
	$this->getPHID(),
	$email->getVerificationCode(),
	));

	return $this->generateToken(
	time() + ($offset * self::EMAIL_CYCLE_FREQUENCY),
	self::EMAIL_CYCLE_FREQUENCY,
	$key,
	self::EMAIL_TOKEN_LENGTH);
	}

	public function validateEmailToken(
	PhabricatorUserEmail $email,
	$token) {
	for ($ii = -1; $ii <= 1; $ii++) {
	$valid = $this->generateEmailToken($email, $ii);
	if ($token == $valid) {
	return true;
	}
	}
	return false;
	}

	public function getEmailLoginURI(PhabricatorUserEmail $email = null) {
	if (!$email) {
	$email = $this->loadPrimaryEmail();
	if (!$email) {
	throw new Exception("User has no primary email!");
	}
	}
	$token = $this->generateEmailToken($email);
	$uri = PhabricatorEnv::getProductionURI('/login/etoken/'.$token.'/');
	$uri = new PhutilURI($uri);
	return $uri->alter('email', $email->getAddress());
	}

	public function loadPrimaryEmailAddress() {
	$email = $this->loadPrimaryEmail();
	if (!$email) {
	throw new Exception("User has no primary email address!");
	}
	return $email->getAddress();
	}

	public function loadPrimaryEmail() {
	return $this->loadOneRelative(
	new PhabricatorUserEmail(),
	'userPHID',
	'getPHID',
	'(isPrimary = 1)');
	}

	public function loadPreferences() {
	if ($this->preferences) {
	return $this->preferences;
	}

	$preferences = id(new PhabricatorUserPreferences())->loadOneWhere(
	'userPHID = %s',
	$this->getPHID());

	if (!$preferences) {
	$preferences = new PhabricatorUserPreferences();
	$preferences->setUserPHID($this->getPHID());

	$default_dict = array(
	PhabricatorUserPreferences::PREFERENCE_TITLES => 'glyph',
	PhabricatorUserPreferences::PREFERENCE_EDITOR => '',
	PhabricatorUserPreferences::PREFERENCE_MONOSPACED => '');

	$preferences->setPreferences($default_dict);
	}

	$this->preferences = $preferences;
	return $preferences;
	}

	public function loadEditorLink($path, $line, $callsign) {
	$editor = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_EDITOR);
	if ($editor) {
	return strtr($editor, array(
	'%%' => '%',
	'%f' => phutil_escape_uri($path),
	'%l' => phutil_escape_uri($line),
	'%r' => phutil_escape_uri($callsign),
	));
	}
	}

	private static function tokenizeName($name) {
	if (function_exists('mb_strtolower')) {
	$name = mb_strtolower($name, 'UTF-8');
	} else {
	$name = strtolower($name);
	}
	$name = trim($name);
	if (!strlen($name)) {
	return array();
	}
	return preg_split('/\s+/', $name);
	}

	/**
	* Populate the nametoken table, which used to fetch typeahead results. When
	* a user types "linc", we want to match "Abraham Lincoln" from on-demand
	* typeahead sources. To do this, we need a separate table of name fragments.
	*/
	public function updateNameTokens() {
	$tokens = array_merge(
	self::tokenizeName($this->getRealName()),
	self::tokenizeName($this->getUserName()));
	$tokens = array_unique($tokens);
	$table = self::NAMETOKEN_TABLE;
	$conn_w = $this->establishConnection('w');

	$sql = array();
	foreach ($tokens as $token) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s)',
	$this->getID(),
	$token);
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE userID = %d',
	$table,
	$this->getID());
	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (userID, token) VALUES %Q',
	$table,
	implode(', ', $sql));
	}
	}

	public function sendWelcomeEmail(PhabricatorUser $admin) {
	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$user_username = $this->getUserName();
	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	$base_uri = PhabricatorEnv::getProductionURI('/');

	$uri = $this->getEmailLoginURI();
	$body = <<<EOBODY
	Welcome to Phabricator!

	{$admin_username} ({$admin_realname}) has created an account for you.

	Username: {$user_username}

	To login to Phabricator, follow this link and set a password:

	{$uri}

	After you have set a password, you can login in the future by going here:

	{$base_uri}

	EOBODY;

	if (!$is_serious) {
	$body .= <<<EOBODY

	Love,
	Phabricator

	EOBODY;
	}

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setSubject('[Phabricator] Welcome to Phabricator')
	->setBody($body)
	->setFrom($admin->getPHID())
	->saveAndSend();
	}

	public function sendUsernameChangeEmail(
	PhabricatorUser $admin,
	$old_username) {

	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$new_username = $this->getUserName();

	$password_instructions = null;
	if (PhabricatorEnv::getEnvConfig('auth.password-auth-enabled')) {
	$uri = $this->getEmailLoginURI();
	$password_instructions = <<<EOTXT
	If you use a password to login, you'll need to reset it before you can login
	again. You can reset your password by following this link:

	{$uri}

	And, of course, you'll need to use your new username to login from now on. If
	you use OAuth to login, nothing should change.

	EOTXT;
	}

	$body = <<<EOBODY
	{$admin_username} ({$admin_realname}) has changed your Phabricator username.

	Old Username: {$old_username}
	New Username: {$new_username}

	{$password_instructions}
	EOBODY;

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setSubject('[Phabricator] Username Changed')
	->setBody($body)
	->setFrom($admin->getPHID())
	->saveAndSend();
	}

	public static function describeValidUsername() {
	return 'Usernames must contain only numbers, letters, period, underscore '.
	'and hyphen, and can not end with a period.';
	}

	public static function validateUsername($username) {
	// NOTE: If you update this, make sure to update:
	//
	// - Remarkup rule for @mentions.
	// - Routing rule for "/p/username/".
	// - Unit tests, obviously.
	// - describeValidUsername() method, above.

	return (bool)preg_match('/^[a-zA-Z0-9._-]*[a-zA-Z0-9_-]$/', $username);
	}

	public static function getDefaultProfileImageURI() {
	return celerity_get_resource_uri('/rsrc/image/avatar.png');
	}

	public function loadProfileImageURI() {
	$src_phid = $this->getProfileImagePHID();

	$file = id(new PhabricatorFile())->loadOneWhere('phid = %s', $src_phid);
	if ($file) {
	return $file->getBestURI();
	}

	return self::getDefaultProfileImageURI();
	}

	public function getFullName() {
	return $this->getUsername().' ('.$this->getRealName().')';
	}

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

	public static function loadOneWithEmailAddress($address) {
	$email = id(new PhabricatorUserEmail())->loadOneWhere(
	'address = %s',
	$address);
	if (!$email) {
	return null;
	}
	return id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$email->getUserPHID());
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 1, 7:39 AM (1 d, 9 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 430290
Default Alt Text: (81 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions