No OneTemporary
Actions

Size

70 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/resources/sql/autopatches/20150514.user.cache.2.sql b/resources/sql/autopatches/20150514.user.cache.2.sql
	new file mode 100644
	index 0000000000..fc53324dc3
	--- /dev/null
	+++ b/resources/sql/autopatches/20150514.user.cache.2.sql
	@@ -0,0 +1,5 @@
	+ALTER TABLE {$NAMESPACE}_user.user
	+ ADD availabilityCache VARCHAR(255) COLLATE {$COLLATE_TEXT};
	+
	+ALTER TABLE {$NAMESPACE}_user.user
	+ ADD availabilityCacheTTL INT UNSIGNED;
	diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	index 6e80d19236..947098ff28 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	@@ -1,362 +1,400 @@
	<?php

	final class PhabricatorCalendarEventEditor
	extends PhabricatorApplicationTransactionEditor {

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

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

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

	$types[] = PhabricatorCalendarEventTransaction::TYPE_NAME;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_START_DATE;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_STATUS;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_CANCEL;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_INVITE;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_ALL_DAY;

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

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	return $object->getName();
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	return $object->getDateFrom();
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	return $object->getDateTo();
	case PhabricatorCalendarEventTransaction::TYPE_STATUS:
	$status = $object->getStatus();
	if ($status === null) {
	return null;
	}
	return (int)$status;
	case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
	return $object->getDescription();
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	return $object->getIsCancelled();
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	return (int)$object->getIsAllDay();
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	$map = $xaction->getNewValue();
	$phids = array_keys($map);
	- $invitees = array();
	-
	- if ($map && !$this->getIsNewObject()) {
	- $invitees = id(new PhabricatorCalendarEventInviteeQuery())
	- ->setViewer($this->getActor())
	- ->withEventPHIDs(array($object->getPHID()))
	- ->withInviteePHIDs($phids)
	- ->execute();
	- $invitees = mpull($invitees, null, 'getInviteePHID');
	- }
	+ $invitees = mpull($object->getInvitees(), null, 'getInviteePHID');

	$old = array();
	foreach ($phids as $phid) {
	$invitee = idx($invitees, $phid);
	if ($invitee) {
	$old[$phid] = $invitee->getStatus();
	} else {
	$old[$phid] = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	}
	}
	return $old;
	}

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

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	return $xaction->getNewValue();
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	return (int)$xaction->getNewValue();
	case PhabricatorCalendarEventTransaction::TYPE_STATUS:
	return (int)$xaction->getNewValue();
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	return $xaction->getNewValue()->getEpoch();
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	$object->setName($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	$object->setDateFrom($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	$object->setDateTo($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_STATUS:
	$object->setStatus($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
	$object->setDescription($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	$object->setIsCancelled((int)$xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	$object->setIsAllDay((int)$xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	case PhabricatorTransactions::TYPE_COMMENT:
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case PhabricatorTransactions::TYPE_EDGE:
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_STATUS:
	case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	return;
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	$map = $xaction->getNewValue();
	$phids = array_keys($map);
	$invitees = $object->getInvitees();
	$invitees = mpull($invitees, null, 'getInviteePHID');

	foreach ($phids as $phid) {
	$invitee = idx($invitees, $phid);
	if (!$invitee) {
	$invitee = id(new PhabricatorCalendarEventInvitee())
	->setEventPHID($object->getPHID())
	->setInviteePHID($phid)
	->setInviterPHID($this->getActingAsPHID());
	$invitees[] = $invitee;
	}
	$invitee->setStatus($map[$phid])
	->save();
	}
	$object->attachInvitees($invitees);
	return;
	case PhabricatorTransactions::TYPE_COMMENT:
	case PhabricatorTransactions::TYPE_VIEW_POLICY:
	case PhabricatorTransactions::TYPE_EDIT_POLICY:
	case PhabricatorTransactions::TYPE_EDGE:
	case PhabricatorTransactions::TYPE_SUBSCRIBERS:
	return;
	}

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

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

	$object->removeViewerTimezone($this->requireActor());

	return $xactions;
	}

	+ protected function applyFinalEffects($object, array $xactions) {
	+
	+ // Clear the availability caches for users whose availability is affected
	+ // by this edit.
	+
	+ $invalidate_all = false;
	+ $invalidate_phids = array();
	+ foreach ($xactions as $xaction) {
	+ switch ($xaction->getTransactionType()) {
	+ case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	+ case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	+ case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	+ case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	+ // For these kinds of changes, we need to invalidate the availabilty
	+ // caches for all attendees.
	+ $invalidate_all = true;
	+ break;
	+ case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	+ foreach ($xaction->getNewValue() as $phid => $ignored) {
	+ $invalidate_phids[$phid] = $phid;
	+ }
	+ break;
	+ }
	+ }
	+
	+ $phids = mpull($object->getInvitees(), 'getInviteePHID');
	+ $phids = array_fuse($phids);
	+
	+ if (!$invalidate_all) {
	+ $phids = array_select_keys($phids, $invalidate_phids);
	+ }
	+
	+ if ($phids) {
	+ $user = new PhabricatorUser();
	+ $conn_w = $user->establishConnection('w');
	+ queryfx(
	+ $conn_w,
	+ 'UPDATE %T SET availabilityCacheTTL = NULL
	+ WHERE phid IN (%Ls) AND availabilityCacheTTL >= %d',
	+ $user->getTableName(),
	+ $phids,
	+ $object->getDateFromForCache());
	+ }
	+
	+ return $xactions;
	+ }
	+

	protected function validateAllTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {
	$start_date_xaction = PhabricatorCalendarEventTransaction::TYPE_START_DATE;
	$end_date_xaction = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
	$start_date = $object->getDateFrom();
	$end_date = $object->getDateTo();
	$errors = array();

	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $start_date_xaction) {
	$start_date = $xaction->getNewValue()->getEpoch();
	} else if ($xaction->getTransactionType() == $end_date_xaction) {
	$end_date = $xaction->getNewValue()->getEpoch();
	}
	}
	if ($start_date > $end_date) {
	$type = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('End date must be after start date.'),
	null);
	}

	return $errors;
	}

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

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

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

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

	$error->setIsMissingFieldError(true);
	$errors[] = $error;
	}
	break;
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	foreach ($xactions as $xaction) {
	$date_value = $xaction->getNewValue();
	if (!$date_value->isValid()) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('Invalid date.'),
	$xaction);
	}
	}
	break;
	}

	return $errors;
	}

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

	protected function supportsSearch() {
	return true;
	}

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

	$xactions = mfilter($xactions, 'shouldHide', true);
	return $xactions;
	}

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

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

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

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

	$phids = array_unique($phids);

	return $phids;
	}

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

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

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

	return id(new PhabricatorMetaMTAMail())
	->setSubject("E{$id}: {$name}")
	->addHeader('Thread-Topic', "E{$id}: ".$object->getName());
	}

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

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

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

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


	return $body;
	}


	}
	diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	index c476911ff3..d68c207371 100644
	--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	@@ -1,398 +1,411 @@
	<?php

	final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
	implements PhabricatorPolicyInterface,
	PhabricatorMarkupInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorSubscribableInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorDestructibleInterface,
	PhabricatorMentionableInterface,
	PhabricatorFlaggableInterface {

	protected $name;
	protected $userPHID;
	protected $dateFrom;
	protected $dateTo;
	protected $status;
	protected $description;
	protected $isCancelled;
	protected $isAllDay;
	protected $mailKey;

	protected $viewPolicy;
	protected $editPolicy;

	private $invitees = self::ATTACHABLE;
	private $appliedViewer;

	const STATUS_AWAY = 1;
	const STATUS_SPORADIC = 2;

	public static function initializeNewCalendarEvent(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorCalendarApplication'))
	->executeOne();

	return id(new PhabricatorCalendarEvent())
	->setUserPHID($actor->getPHID())
	->setIsCancelled(0)
	->setIsAllDay(0)
	->setViewPolicy($actor->getPHID())
	->setEditPolicy($actor->getPHID())
	->attachInvitees(array())
	->applyViewerTimezone($actor);
	}

	public function applyViewerTimezone(PhabricatorUser $viewer) {
	if ($this->appliedViewer) {
	throw new Exception(pht('Viewer timezone is already applied!'));
	}

	$this->appliedViewer = $viewer;

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

	$zone = $viewer->getTimeZone();


	$this->setDateFrom(
	$this->getDateEpochForTimeZone(
	$this->getDateFrom(),
	new DateTimeZone('Pacific/Kiritimati'),
	'Y-m-d',
	null,
	$zone));

	$this->setDateTo(
	$this->getDateEpochForTimeZone(
	$this->getDateTo(),
	new DateTimeZone('Pacific/Midway'),
	'Y-m-d 23:59:00',
	'-1 day',
	$zone));

	return $this;
	}


	public function removeViewerTimezone(PhabricatorUser $viewer) {
	if (!$this->appliedViewer) {
	throw new Exception(pht('Viewer timezone is not applied!'));
	}

	if ($viewer->getPHID() != $this->appliedViewer->getPHID()) {
	throw new Exception(pht('Removed viewer must match applied viewer!'));
	}

	$this->appliedViewer = null;

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

	$zone = $viewer->getTimeZone();

	$this->setDateFrom(
	$this->getDateEpochForTimeZone(
	$this->getDateFrom(),
	$zone,
	'Y-m-d',
	null,
	new DateTimeZone('Pacific/Kiritimati')));

	$this->setDateTo(
	$this->getDateEpochForTimeZone(
	$this->getDateTo(),
	$zone,
	'Y-m-d',
	'+1 day',
	new DateTimeZone('Pacific/Midway')));

	return $this;
	}

	private function getDateEpochForTimeZone(
	$epoch,
	$src_zone,
	$format,
	$adjust,
	$dst_zone) {

	$src = new DateTime('@'.$epoch);
	$src->setTimeZone($src_zone);

	if (strlen($adjust)) {
	$adjust = ' '.$adjust;
	}

	$dst = new DateTime($src->format($format).$adjust, $dst_zone);
	return $dst->format('U');
	}

	public function save() {
	if ($this->appliedViewer) {
	throw new Exception(
	pht(
	'Can not save event with viewer timezone still applied!'));
	}

	if (!$this->mailKey) {
	$this->mailKey = Filesystem::readRandomCharacters(20);
	}

	return parent::save();
	}

	+ /**
	+ * Get the event start epoch for evaluating invitee availability.
	+ *
	+ * When assessing availability, we pretend events start earlier than they
	+ * really. This allows us to mark users away for the entire duration of a
	+ * series of back-to-back meetings, even if they don't strictly overlap.
	+ *
	+ * @return int Event start date for availability caches.
	+ */
	+ public function getDateFromForCache() {
	+ return ($this->getDateFrom() - phutil_units('15 minutes in seconds'));
	+ }
	+
	private static $statusTexts = array(
	self::STATUS_AWAY => 'away',
	self::STATUS_SPORADIC => 'sporadic',
	);

	public function setTextStatus($status) {
	$statuses = array_flip(self::$statusTexts);
	return $this->setStatus($statuses[$status]);
	}

	public function getTextStatus() {
	return self::$statusTexts[$this->status];
	}

	public function getStatusOptions() {
	return array(
	self::STATUS_AWAY => pht('Away'),
	self::STATUS_SPORADIC => pht('Sporadic'),
	);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'text',
	'dateFrom' => 'epoch',
	'dateTo' => 'epoch',
	'status' => 'uint32',
	'description' => 'text',
	'isCancelled' => 'bool',
	'isAllDay' => 'bool',
	'mailKey' => 'bytes20',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'userPHID_dateFrom' => array(
	'columns' => array('userPHID', 'dateTo'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorCalendarEventPHIDType::TYPECONST);
	}

	public function getMonogram() {
	return 'E'.$this->getID();
	}

	public function getTerseSummary(PhabricatorUser $viewer) {
	$until = phabricator_date($this->dateTo, $viewer);
	if ($this->status == self::STATUS_SPORADIC) {
	return pht('Sporadic until %s', $until);
	} else {
	return pht('Away until %s', $until);
	}
	}

	public static function getNameForStatus($value) {
	switch ($value) {
	case self::STATUS_AWAY:
	return pht('Away');
	case self::STATUS_SPORADIC:
	return pht('Sporadic');
	default:
	return pht('Unknown');
	}
	}

	public function getInvitees() {
	return $this->assertAttached($this->invitees);
	}

	public function attachInvitees(array $invitees) {
	$this->invitees = $invitees;
	return $this;
	}

	public function getUserInviteStatus($phid) {
	$invitees = $this->getInvitees();
	$invitees = mpull($invitees, null, 'getInviteePHID');

	$invited = idx($invitees, $phid);
	if (!$invited) {
	return PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	}
	$invited = $invited->getStatus();
	return $invited;
	}

	public function getIsUserAttending($phid) {
	$attending_status = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;

	$old_status = $this->getUserInviteStatus($phid);
	$is_attending = ($old_status == $attending_status);

	return $is_attending;
	}

	/* -( Markup Interface )--------------------------------------------------- */


	/**
	* @task markup
	*/
	public function getMarkupFieldKey($field) {
	$hash = PhabricatorHash::digest($this->getMarkupText($field));
	$id = $this->getID();
	return "calendar:T{$id}:{$field}:{$hash}";
	}


	/**
	* @task markup
	*/
	public function getMarkupText($field) {
	return $this->getDescription();
	}


	/**
	* @task markup
	*/
	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newCalendarMarkupEngine();
	}


	/**
	* @task markup
	*/
	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {
	return $output;
	}


	/**
	* @task markup
	*/
	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}

	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	// The owner of a task can always view and edit it.
	$user_phid = $this->getUserPHID();
	if ($user_phid) {
	$viewer_phid = $viewer->getPHID();
	if ($viewer_phid == $user_phid) {
	return true;
	}
	}

	if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
	$status = $this->getUserInviteStatus($viewer->getPHID());
	if ($status == PhabricatorCalendarEventInvitee::STATUS_INVITED \|\|
	$status == PhabricatorCalendarEventInvitee::STATUS_ATTENDING \|\|
	$status == PhabricatorCalendarEventInvitee::STATUS_DECLINED) {
	return true;
	}
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	return pht('The owner of an event can always view and edit it,
	and invitees can always view it.');
	}

	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhabricatorCalendarEventEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhabricatorCalendarEventTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}

	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	return ($phid == $this->getUserPHID());
	}

	public function shouldShowSubscribersProperty() {
	return true;
	}

	public function shouldAllowSubscription($phid) {
	return true;
	}

	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	return array($this->getUserPHID());
	}

	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}
	}
	diff --git a/src/applications/people/query/PhabricatorPeopleQuery.php b/src/applications/people/query/PhabricatorPeopleQuery.php
	index 2bcb62c2bb..1b4c7c5450 100644
	--- a/src/applications/people/query/PhabricatorPeopleQuery.php
	+++ b/src/applications/people/query/PhabricatorPeopleQuery.php
	@@ -1,452 +1,456 @@
	<?php

	final class PhabricatorPeopleQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $usernames;
	private $realnames;
	private $emails;
	private $phids;
	private $ids;
	private $dateCreatedAfter;
	private $dateCreatedBefore;
	private $isAdmin;
	private $isSystemAgent;
	private $isDisabled;
	private $isApproved;
	private $nameLike;
	private $nameTokens;

	private $needPrimaryEmail;
	private $needProfile;
	private $needProfileImage;
	private $needAvailability;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

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

	public function withEmails(array $emails) {
	$this->emails = $emails;
	return $this;
	}

	public function withRealnames(array $realnames) {
	$this->realnames = $realnames;
	return $this;
	}

	public function withUsernames(array $usernames) {
	$this->usernames = $usernames;
	return $this;
	}

	public function withDateCreatedBefore($date_created_before) {
	$this->dateCreatedBefore = $date_created_before;
	return $this;
	}

	public function withDateCreatedAfter($date_created_after) {
	$this->dateCreatedAfter = $date_created_after;
	return $this;
	}

	public function withIsAdmin($admin) {
	$this->isAdmin = $admin;
	return $this;
	}

	public function withIsSystemAgent($system_agent) {
	$this->isSystemAgent = $system_agent;
	return $this;
	}

	public function withIsDisabled($disabled) {
	$this->isDisabled = $disabled;
	return $this;
	}

	public function withIsApproved($approved) {
	$this->isApproved = $approved;
	return $this;
	}

	public function withNameLike($like) {
	$this->nameLike = $like;
	return $this;
	}

	public function withNameTokens(array $tokens) {
	$this->nameTokens = array_values($tokens);
	return $this;
	}

	public function needPrimaryEmail($need) {
	$this->needPrimaryEmail = $need;
	return $this;
	}

	public function needProfile($need) {
	$this->needProfile = $need;
	return $this;
	}

	public function needProfileImage($need) {
	$this->needProfileImage = $need;
	return $this;
	}

	public function needAvailability($need) {
	$this->needAvailability = $need;
	return $this;
	}

	protected function loadPage() {
	$table = new PhabricatorUser();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T user %Q %Q %Q %Q %Q',
	$table->getTableName(),
	$this->buildJoinsClause($conn_r),
	$this->buildWhereClause($conn_r),
	$this->buildGroupClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	if ($this->needPrimaryEmail) {
	$table->putInSet(new LiskDAOSet());
	}

	return $table->loadAllFromArray($data);
	}

	protected function didFilterPage(array $users) {
	if ($this->needProfile) {
	$user_list = mpull($users, null, 'getPHID');
	$profiles = new PhabricatorUserProfile();
	$profiles = $profiles->loadAllWhere('userPHID IN (%Ls)',
	array_keys($user_list));

	$profiles = mpull($profiles, null, 'getUserPHID');
	foreach ($user_list as $user_phid => $user) {
	$profile = idx($profiles, $user_phid);
	if (!$profile) {
	$profile = new PhabricatorUserProfile();
	$profile->setUserPHID($user_phid);
	}

	$user->attachUserProfile($profile);
	}
	}

	if ($this->needProfileImage) {
	$rebuild = array();
	foreach ($users as $user) {
	$image_uri = $user->getProfileImageCache();
	if ($image_uri) {
	// This user has a valid cache, so we don't need to fetch any
	// data or rebuild anything.

	$user->attachProfileImageURI($image_uri);
	continue;
	}

	// This user's cache is invalid or missing, so we're going to rebuild
	// it.
	$rebuild[] = $user;
	}

	if ($rebuild) {
	$file_phids = mpull($rebuild, 'getProfileImagePHID');
	$file_phids = array_filter($file_phids);

	if ($file_phids) {
	// NOTE: We're using the omnipotent user here because older profile
	// images do not have the 'profile' flag, so they may not be visible
	// to the executing viewer. At some point, we could migrate to add
	// this flag and then use the real viewer, or just use the real
	// viewer after enough time has passed to limit the impact of old
	// data. The consequence of missing here is that we cache a default
	// image when a real image exists.
	$files = id(new PhabricatorFileQuery())
	->setParentQuery($this)
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');
	} else {
	$files = array();
	}

	foreach ($rebuild as $user) {
	$image_phid = $user->getProfileImagePHID();
	if (isset($files[$image_phid])) {
	$image_uri = $files[$image_phid]->getBestURI();
	} else {
	$image_uri = PhabricatorUser::getDefaultProfileImageURI();
	}

	$user->writeProfileImageCache($image_uri);
	$user->attachProfileImageURI($image_uri);
	}
	}
	}

	if ($this->needAvailability) {
	- // TODO: Add caching.
	- $rebuild = $users;
	+ $rebuild = array();
	+ foreach ($users as $user) {
	+ $cache = $user->getAvailabilityCache();
	+ if ($cache !== null) {
	+ $user->attachAvailability($cache);
	+ } else {
	+ $rebuild[] = $user;
	+ }
	+ }
	+
	if ($rebuild) {
	$this->rebuildAvailabilityCache($rebuild);
	}
	}

	return $users;
	}

	protected function buildGroupClause(AphrontDatabaseConnection $conn) {
	if ($this->nameTokens) {
	return qsprintf(
	$conn,
	'GROUP BY user.id');
	} else {
	return $this->buildApplicationSearchGroupClause($conn);
	}
	}

	private function buildJoinsClause($conn_r) {
	$joins = array();

	if ($this->emails) {
	$email_table = new PhabricatorUserEmail();
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T email ON email.userPHID = user.PHID',
	$email_table->getTableName());
	}

	if ($this->nameTokens) {
	foreach ($this->nameTokens as $key => $token) {
	$token_table = 'token_'.$key;
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T %T ON %T.userID = user.id AND %T.token LIKE %>',
	PhabricatorUser::NAMETOKEN_TABLE,
	$token_table,
	$token_table,
	$token_table,
	$token);
	}
	}

	$joins[] = $this->buildApplicationSearchJoinClause($conn_r);

	$joins = implode(' ', $joins);
	return $joins;
	}

	protected function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->usernames !== null) {
	$where[] = qsprintf(
	$conn_r,
	'user.userName IN (%Ls)',
	$this->usernames);
	}

	if ($this->emails !== null) {
	$where[] = qsprintf(
	$conn_r,
	'email.address IN (%Ls)',
	$this->emails);
	}

	if ($this->realnames !== null) {
	$where[] = qsprintf(
	$conn_r,
	'user.realName IN (%Ls)',
	$this->realnames);
	}

	if ($this->phids !== null) {
	$where[] = qsprintf(
	$conn_r,
	'user.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->ids !== null) {
	$where[] = qsprintf(
	$conn_r,
	'user.id IN (%Ld)',
	$this->ids);
	}

	if ($this->dateCreatedAfter) {
	$where[] = qsprintf(
	$conn_r,
	'user.dateCreated >= %d',
	$this->dateCreatedAfter);
	}

	if ($this->dateCreatedBefore) {
	$where[] = qsprintf(
	$conn_r,
	'user.dateCreated <= %d',
	$this->dateCreatedBefore);
	}

	if ($this->isAdmin) {
	$where[] = qsprintf(
	$conn_r,
	'user.isAdmin = 1');
	}

	if ($this->isDisabled !== null) {
	$where[] = qsprintf(
	$conn_r,
	'user.isDisabled = %d',
	(int)$this->isDisabled);
	}

	if ($this->isApproved !== null) {
	$where[] = qsprintf(
	$conn_r,
	'user.isApproved = %d',
	(int)$this->isApproved);
	}

	if ($this->isSystemAgent) {
	$where[] = qsprintf(
	$conn_r,
	'user.isSystemAgent = 1');
	}

	if (strlen($this->nameLike)) {
	$where[] = qsprintf(
	$conn_r,
	'user.username LIKE %~ OR user.realname LIKE %~',
	$this->nameLike,
	$this->nameLike);
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

	protected function getPrimaryTableAlias() {
	return 'user';
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorPeopleApplication';
	}

	public function getOrderableColumns() {
	return parent::getOrderableColumns() + array(
	'username' => array(
	'table' => 'user',
	'column' => 'username',
	'type' => 'string',
	'reverse' => true,
	'unique' => true,
	),
	);
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$user = $this->loadCursorObject($cursor);
	return array(
	'id' => $user->getID(),
	'username' => $user->getUsername(),
	);
	}

	private function rebuildAvailabilityCache(array $rebuild) {
	$rebuild = mpull($rebuild, null, 'getPHID');

	// Limit the window we look at because far-future events are largely
	// irrelevant and this makes the cache cheaper to build and allows it to
	// self-heal over time.
	$min_range = PhabricatorTime::getNow();
	$max_range = $min_range + phutil_units('72 hours in seconds');

	$events = id(new PhabricatorCalendarEventQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withInvitedPHIDs(array_keys($rebuild))
	->withIsCancelled(false)
	->withDateRange($min_range, $max_range)
	->execute();

	// Group all the events by invited user. Only examine events that users
	// are actually attending.
	$map = array();
	foreach ($events as $event) {
	foreach ($event->getInvitees() as $invitee) {
	if (!$invitee->isAttending()) {
	continue;
	}

	$invitee_phid = $invitee->getInviteePHID();
	if (!isset($rebuild[$invitee_phid])) {
	continue;
	}

	$map[$invitee_phid][] = $event;
	}
	}

	- // Margin between meetings: pretend meetings start earlier than they do
	- // so we mark you away for the entire time if you have a series of
	- // back-to-back meetings, even if they don't strictly overlap.
	- $margin = phutil_units('15 minutes in seconds');
	-
	foreach ($rebuild as $phid => $user) {
	$events = idx($map, $phid, array());

	$cursor = $min_range;
	if ($events) {
	// Find the next time when the user has no meetings. If we move forward
	// because of an event, we check again for events after that one ends.
	while (true) {
	foreach ($events as $event) {
	- $from = ($event->getDateFrom() - $margin);
	+ $from = $event->getDateFromForCache();
	$to = $event->getDateTo();
	if (($from <= $cursor) && ($to > $cursor)) {
	$cursor = $to;
	continue 2;
	}
	}
	break;
	}
	}

	if ($cursor > $min_range) {
	$availability = array(
	'until' => $cursor,
	);
	$availability_ttl = $cursor;
	} else {
	- $availability = null;
	+ $availability = array(
	+ 'until' => null,
	+ );
	$availability_ttl = $max_range;
	}

	// Never TTL the cache to longer than the maximum range we examined.
	$availability_ttl = min($availability_ttl, $max_range);

	- // TODO: Write the cache.
	-
	+ $user->writeAvailabilityCache($availability, $availability_ttl);
	$user->attachAvailability($availability);
	}
	}

	}
	diff --git a/src/applications/people/storage/PhabricatorUser.php b/src/applications/people/storage/PhabricatorUser.php
	index 89de29747b..0c7ef73b0e 100644
	--- a/src/applications/people/storage/PhabricatorUser.php
	+++ b/src/applications/people/storage/PhabricatorUser.php
	@@ -1,1103 +1,1153 @@
	<?php

	/**
	* @task availability Availability
	* @task image-cache Profile Image Cache
	* @task factors Multi-Factor Authentication
	* @task handles Managing Handles
	*/
	final class PhabricatorUser
	extends PhabricatorUserDAO
	implements
	PhutilPerson,
	PhabricatorPolicyInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorDestructibleInterface,
	PhabricatorSSHPublicKeyInterface {

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

	protected $userName;
	protected $realName;
	protected $sex;
	protected $translation;
	protected $passwordSalt;
	protected $passwordHash;
	protected $profileImagePHID;
	protected $profileImageCache;
	+ protected $availabilityCache;
	+ protected $availabilityCacheTTL;
	protected $timezoneIdentifier = '';

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

	protected $conduitCertificate;

	protected $isSystemAgent = 0;
	protected $isAdmin = 0;
	protected $isDisabled = 0;
	protected $isEmailVerified = 0;
	protected $isApproved = 0;
	protected $isEnrolledInMultiFactor = 0;

	protected $accountSecret;

	private $profileImage = self::ATTACHABLE;
	private $profile = null;
	private $availability = self::ATTACHABLE;
	private $preferences = null;
	private $omnipotent = false;
	private $customFields = self::ATTACHABLE;

	private $alternateCSRFString = self::ATTACHABLE;
	private $session = self::ATTACHABLE;

	private $authorities = array();
	private $handlePool;

	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;
	case 'isEmailVerified':
	return (bool)$this->isEmailVerified;
	case 'isApproved':
	return (bool)$this->isApproved;
	default:
	return parent::readField($field);
	}
	}


	/**
	* Is this a live account which has passed required approvals? Returns true
	* if this is an enabled, verified (if required), approved (if required)
	* account, and false otherwise.
	*
	* @return bool True if this is a standard, usable account.
	*/
	public function isUserActivated() {
	if ($this->isOmnipotent()) {
	return true;
	}

	if ($this->getIsDisabled()) {
	return false;
	}

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

	if (PhabricatorUserEmail::isEmailVerificationRequired()) {
	if (!$this->getIsEmailVerified()) {
	return false;
	}
	}

	return true;
	}

	/**
	* Returns `true` if this is a standard user who is logged in. Returns `false`
	* for logged out, anonymous, or external users.
	*
	* @return bool `true` if the user is a standard user who is logged in with
	* a normal session.
	*/
	public function getIsStandardUser() {
	$type_user = PhabricatorPeopleUserPHIDType::TYPECONST;
	return $this->getPHID() && (phid_get_type($this->getPHID()) == $type_user);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'userName' => 'sort64',
	'realName' => 'text128',
	'sex' => 'text4?',
	'translation' => 'text64?',
	'passwordSalt' => 'text32?',
	'passwordHash' => 'text128?',
	'profileImagePHID' => 'phid?',
	'consoleEnabled' => 'bool',
	'consoleVisible' => 'bool',
	'consoleTab' => 'text64',
	'conduitCertificate' => 'text255',
	'isSystemAgent' => 'bool',
	'isDisabled' => 'bool',
	'isAdmin' => 'bool',
	'timezoneIdentifier' => 'text255',
	'isEmailVerified' => 'uint32',
	'isApproved' => 'uint32',
	'accountSecret' => 'bytes64',
	'isEnrolledInMultiFactor' => 'bool',
	'profileImageCache' => 'text255?',
	+ 'availabilityCache' => 'text255?',
	+ 'availabilityCacheTTL' => 'uint32?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'userName' => array(
	'columns' => array('userName'),
	'unique' => true,
	),
	'realName' => array(
	'columns' => array('realName'),
	),
	'key_approved' => array(
	'columns' => array('isApproved'),
	),
	),
	self::CONFIG_NO_MUTATE => array(
	'profileImageCache' => true,
	+ 'availabilityCache' => true,
	+ 'availabilityCacheTTL' => true,
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorPeopleUserPHIDType::TYPECONST);
	}

	public function setPassword(PhutilOpaqueEnvelope $envelope) {
	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($envelope->openEnvelope())) {
	$this->setPasswordHash('');
	} else {
	$this->setPasswordSalt(md5(Filesystem::readRandomBytes(32)));
	$hash = $this->hashPassword($envelope);
	$this->setPasswordHash($hash->openEnvelope());
	}
	return $this;
	}

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

	public function getMonogram() {
	return '@'.$this->getUsername();
	}

	public function isLoggedIn() {
	return !($this->getPHID() === null);
	}

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

	if (!strlen($this->getAccountSecret())) {
	$this->setAccountSecret(Filesystem::readRandomCharacters(64));
	}

	$result = parent::save();

	if ($this->profile) {
	$this->profile->save();
	}

	$this->updateNameTokens();

	id(new PhabricatorSearchIndexer())
	->queueDocumentForIndexing($this->getPHID());

	return $result;
	}

	public function attachSession(PhabricatorAuthSession $session) {
	$this->session = $session;
	return $this;
	}

	public function getSession() {
	return $this->assertAttached($this->session);
	}

	public function hasSession() {
	return ($this->session !== self::ATTACHABLE);
	}

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

	public function comparePassword(PhutilOpaqueEnvelope $envelope) {
	if (!strlen($envelope->openEnvelope())) {
	return false;
	}
	if (!strlen($this->getPasswordHash())) {
	return false;
	}

	return PhabricatorPasswordHasher::comparePassword(
	$this->getPasswordHashInput($envelope),
	new PhutilOpaqueEnvelope($this->getPasswordHash()));
	}

	private function getPasswordHashInput(PhutilOpaqueEnvelope $password) {
	$input =
	$this->getUsername().
	$password->openEnvelope().
	$this->getPHID().
	$this->getPasswordSalt();

	return new PhutilOpaqueEnvelope($input);
	}

	private function hashPassword(PhutilOpaqueEnvelope $password) {
	$hasher = PhabricatorPasswordHasher::getBestHasher();

	$input_envelope = $this->getPasswordHashInput($password);
	return $hasher->getPasswordHashForStorage($input_envelope);
	}

	const CSRF_CYCLE_FREQUENCY = 3600;
	const CSRF_SALT_LENGTH = 8;
	const CSRF_TOKEN_LENGTH = 16;
	const CSRF_BREACH_PREFIX = 'B@';

	const EMAIL_CYCLE_FREQUENCY = 86400;
	const EMAIL_TOKEN_LENGTH = 24;

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

	/**
	* @phutil-external-symbol class PhabricatorStartup
	*/
	public function getCSRFToken() {
	$salt = PhabricatorStartup::getGlobal('csrf.salt');
	if (!$salt) {
	$salt = Filesystem::readRandomCharacters(self::CSRF_SALT_LENGTH);
	PhabricatorStartup::setGlobal('csrf.salt', $salt);
	}

	// Generate a token hash to mitigate BREACH attacks against SSL. See
	// discussion in T3684.
	$token = $this->getRawCSRFToken();
	$hash = PhabricatorHash::digest($token, $salt);
	return 'B@'.$salt.substr($hash, 0, self::CSRF_TOKEN_LENGTH);
	}

	public function validateCSRFToken($token) {
	$salt = null;
	$version = 'plain';

	// This is a BREACH-mitigating token. See T3684.
	$breach_prefix = self::CSRF_BREACH_PREFIX;
	$breach_prelen = strlen($breach_prefix);

	if (!strncmp($token, $breach_prefix, $breach_prelen)) {
	$version = 'breach';
	$salt = substr($token, $breach_prelen, self::CSRF_SALT_LENGTH);
	$token = substr($token, $breach_prelen + self::CSRF_SALT_LENGTH);
	}

	// 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->getRawCSRFToken($ii);
	switch ($version) {
	// TODO: We can remove this after the BREACH version has been in the
	// wild for a while.
	case 'plain':
	if ($token == $valid) {
	return true;
	}
	break;
	case 'breach':
	$digest = PhabricatorHash::digest($valid, $salt);
	if (substr($digest, 0, self::CSRF_TOKEN_LENGTH) == $token) {
	return true;
	}
	break;
	default:
	throw new Exception('Unknown CSRF token format!');
	}
	}

	return false;
	}

	private function generateToken($epoch, $frequency, $key, $len) {
	if ($this->getPHID()) {
	$vec = $this->getPHID().$this->getAccountSecret();
	} else {
	$vec = $this->getAlternateCSRFString();
	}

	if ($this->hasSession()) {
	$vec = $vec.$this->getSession()->getSessionKey();
	}

	$time_block = floor($epoch / $frequency);
	$vec = $vec.$key.$time_block;

	return substr(PhabricatorHash::digest($vec), 0, $len);
	}

	public function attachUserProfile(PhabricatorUserProfile $profile) {
	$this->profile = $profile;
	return $this;
	}

	public function loadUserProfile() {
	if ($this->profile) {
	return $this->profile;
	}

	$profile_dao = new PhabricatorUserProfile();
	$this->profile = $profile_dao->loadOneWhere('userPHID = %s',
	$this->getPHID());

	if (!$this->profile) {
	$profile_dao->setUserPHID($this->getPHID());
	$this->profile = $profile_dao;
	}

	return $this->profile;
	}

	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 = null;
	if ($this->getPHID()) {
	$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 => '',
	PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE => 0,
	);

	$preferences->setPreferences($default_dict);
	}

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

	public function loadEditorLink($path, $line, $callsign) {
	$editor = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_EDITOR);

	if (is_array($path)) {
	$multiedit = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MULTIEDIT);
	switch ($multiedit) {
	case '':
	$path = implode(' ', $path);
	break;
	case 'disable':
	return null;
	}
	}

	if (!strlen($editor)) {
	return null;
	}

	$uri = strtr($editor, array(
	'%%' => '%',
	'%f' => phutil_escape_uri($path),
	'%l' => phutil_escape_uri($line),
	'%r' => phutil_escape_uri($callsign),
	));

	// The resulting URI must have an allowed protocol. Otherwise, we'll return
	// a link to an error page explaining the misconfiguration.

	$ok = PhabricatorHelpEditorProtocolController::hasAllowedProtocol($uri);
	if (!$ok) {
	return '/help/editorprotocol/';
	}

	return (string)$uri;
	}

	public function getAlternateCSRFString() {
	return $this->assertAttached($this->alternateCSRFString);
	}

	public function attachAlternateCSRFString($string) {
	$this->alternateCSRFString = $string;
	return $this;
	}

	/**
	* 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() {
	$table = self::NAMETOKEN_TABLE;
	$conn_w = $this->establishConnection('w');

	$tokens = PhabricatorTypeaheadDatasource::tokenizeString(
	$this->getUserName().' '.$this->getRealName());

	$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('/');

	$engine = new PhabricatorAuthSessionEngine();
	$uri = $engine->getOneTimeLoginURI(
	$this,
	$this->loadPrimaryEmail(),
	PhabricatorAuthSessionEngine::ONETIME_WELCOME);

	$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()))
	->setForceDelivery(true)
	->setSubject('[Phabricator] Welcome to Phabricator')
	->setBody($body)
	->saveAndSend();
	}

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

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

	$password_instructions = null;
	if (PhabricatorPasswordAuthProvider::getPasswordProvider()) {
	$engine = new PhabricatorAuthSessionEngine();
	$uri = $engine->getOneTimeLoginURI(
	$this,
	null,
	PhabricatorAuthSessionEngine::ONETIME_USERNAME);
	$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()))
	->setForceDelivery(true)
	->setSubject('[Phabricator] Username Changed')
	->setBody($body)
	->saveAndSend();
	}

	public static function describeValidUsername() {
	return pht(
	'Usernames must contain only numbers, letters, period, underscore and '.
	'hyphen, and can not end with a period. They must have no more than %d '.
	'characters.',
	new PhutilNumber(self::MAXIMUM_USERNAME_LENGTH));
	}

	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.

	if (strlen($username) > self::MAXIMUM_USERNAME_LENGTH) {
	return false;
	}

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

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

	public function attachProfileImageURI($uri) {
	$this->profileImage = $uri;
	return $this;
	}

	public function getProfileImageURI() {
	return $this->assertAttached($this->profileImage);
	}

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

	public function getTimeZone() {
	return new DateTimeZone($this->getTimezoneIdentifier());
	}

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


	/**
	* Grant a user a source of authority, to let them bypass policy checks they
	* could not otherwise.
	*/
	public function grantAuthority($authority) {
	$this->authorities[] = $authority;
	return $this;
	}


	/**
	* Get authorities granted to the user.
	*/
	public function getAuthorities() {
	return $this->authorities;
	}


	/* -( Availability )------------------------------------------------------- */


	/**
	* @task availability
	*/
	- public function attachAvailability($availability) {
	+ public function attachAvailability(array $availability) {
	$this->availability = $availability;
	return $this;
	}


	/**
	* Get the timestamp the user is away until, if they are currently away.
	*
	* @return int\|null Epoch timestamp, or `null` if the user is not away.
	* @task availability
	*/
	public function getAwayUntil() {
	$availability = $this->availability;

	$this->assertAttached($availability);
	if (!$availability) {
	return null;
	}

	return idx($availability, 'until');
	}


	/**
	* Describe the user's availability.
	*
	* @param PhabricatorUser Viewing user.
	* @return string Human-readable description of away status.
	* @task availability
	*/
	public function getAvailabilityDescription(PhabricatorUser $viewer) {
	$until = $this->getAwayUntil();
	if ($until) {
	return pht('Away until %s', phabricator_datetime($until, $viewer));
	} else {
	return pht('Available');
	}
	}


	+ /**
	+ * Get cached availability, if present.
	+ *
	+ * @return wild\|null Cache data, or null if no cache is available.
	+ * @task availability
	+ */
	+ public function getAvailabilityCache() {
	+ $now = PhabricatorTime::getNow();
	+ if ($this->availabilityCacheTTL <= $now) {
	+ return null;
	+ }
	+
	+ try {
	+ return phutil_json_decode($this->availabilityCache);
	+ } catch (Exception $ex) {
	+ return null;
	+ }
	+ }
	+
	+
	+ /**
	+ * Write to the availability cache.
	+ *
	+ * @param wild Availability cache data.
	+ * @param int\|null Cache TTL.
	+ * @return this
	+ * @task availability
	+ */
	+ public function writeAvailabilityCache(array $availability, $ttl) {
	+ $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	+ queryfx(
	+ $this->establishConnection('w'),
	+ 'UPDATE %T SET availabilityCache = %s, availabilityCacheTTL = %nd
	+ WHERE id = %d',
	+ $this->getTableName(),
	+ json_encode($availability),
	+ $ttl,
	+ $this->getID());
	+ unset($unguarded);
	+
	+ return $this;
	+ }
	+
	+
	/* -( Profile Image Cache )------------------------------------------------ */


	/**
	* Get this user's cached profile image URI.
	*
	* @return string\|null Cached URI, if a URI is cached.
	* @task image-cache
	*/
	public function getProfileImageCache() {
	$version = $this->getProfileImageVersion();

	$parts = explode(',', $this->profileImageCache, 2);
	if (count($parts) !== 2) {
	return null;
	}

	if ($parts[0] !== $version) {
	return null;
	}

	return $parts[1];
	}


	/**
	* Generate a new cache value for this user's profile image.
	*
	* @return string New cache value.
	* @task image-cache
	*/
	public function writeProfileImageCache($uri) {
	$version = $this->getProfileImageVersion();
	$cache = "{$version},{$uri}";

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET profileImageCache = %s WHERE id = %d',
	$this->getTableName(),
	$cache,
	$this->getID());
	unset($unguarded);
	}


	/**
	* Get a version identifier for a user's profile image.
	*
	* This version will change if the image changes, or if any of the
	* environment configuration which goes into generating a URI changes.
	*
	* @return string Cache version.
	* @task image-cache
	*/
	private function getProfileImageVersion() {
	$parts = array(
	PhabricatorEnv::getCDNURI('/'),
	PhabricatorEnv::getEnvConfig('cluster.instance'),
	$this->getProfileImagePHID(),
	);
	$parts = serialize($parts);
	return PhabricatorHash::digestForIndex($parts);
	}


	/* -( Multi-Factor Authentication )---------------------------------------- */


	/**
	* Update the flag storing this user's enrollment in multi-factor auth.
	*
	* With certain settings, we need to check if a user has MFA on every page,
	* so we cache MFA enrollment on the user object for performance. Calling this
	* method synchronizes the cache by examining enrollment records. After
	* updating the cache, use @{method:getIsEnrolledInMultiFactor} to check if
	* the user is enrolled.
	*
	* This method should be called after any changes are made to a given user's
	* multi-factor configuration.
	*
	* @return void
	* @task factors
	*/
	public function updateMultiFactorEnrollment() {
	$factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());

	$enrolled = count($factors) ? 1 : 0;
	if ($enrolled !== $this->isEnrolledInMultiFactor) {
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET isEnrolledInMultiFactor = %d WHERE id = %d',
	$this->getTableName(),
	$enrolled,
	$this->getID());
	unset($unguarded);

	$this->isEnrolledInMultiFactor = $enrolled;
	}
	}


	/**
	* Check if the user is enrolled in multi-factor authentication.
	*
	* Enrolled users have one or more multi-factor authentication sources
	* attached to their account. For performance, this value is cached. You
	* can use @{method:updateMultiFactorEnrollment} to update the cache.
	*
	* @return bool True if the user is enrolled.
	* @task factors
	*/
	public function getIsEnrolledInMultiFactor() {
	return $this->isEnrolledInMultiFactor;
	}


	/* -( Omnipotence )-------------------------------------------------------- */


	/**
	* Returns true if this user is omnipotent. Omnipotent users bypass all policy
	* checks.
	*
	* @return bool True if the user bypasses policy checks.
	*/
	public function isOmnipotent() {
	return $this->omnipotent;
	}


	/**
	* Get an omnipotent user object for use in contexts where there is no acting
	* user, notably daemons.
	*
	* @return PhabricatorUser An omnipotent user.
	*/
	public static function getOmnipotentUser() {
	static $user = null;
	if (!$user) {
	$user = new PhabricatorUser();
	$user->omnipotent = true;
	$user->makeEphemeral();
	}
	return $user;
	}


	/* -( Managing Handles )--------------------------------------------------- */


	/**
	* Get a @{class:PhabricatorHandleList} which benefits from this viewer's
	* internal handle pool.
	*
	* @param list<phid> List of PHIDs to load.
	* @return PhabricatorHandleList Handle list object.
	* @task handle
	*/
	public function loadHandles(array $phids) {
	if ($this->handlePool === null) {
	$this->handlePool = id(new PhabricatorHandlePool())
	->setViewer($this);
	}

	return $this->handlePool->newHandleList($phids);
	}


	/**
	* Get a @{class:PHUIHandleView} for a single handle.
	*
	* This benefits from the viewer's internal handle pool.
	*
	* @param phid PHID to render a handle for.
	* @return PHUIHandleView View of the handle.
	* @task handle
	*/
	public function renderHandle($phid) {
	return $this->loadHandles(array($phid))->renderHandle($phid);
	}


	/**
	* Get a @{class:PHUIHandleListView} for a list of handles.
	*
	* This benefits from the viewer's internal handle pool.
	*
	* @param list<phid> List of PHIDs to render.
	* @return PHUIHandleListView View of the handles.
	* @task handle
	*/
	public function renderHandleList(array $phids) {
	return $this->loadHandles($phids)->renderList();
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::POLICY_PUBLIC;
	case PhabricatorPolicyCapability::CAN_EDIT:
	if ($this->getIsSystemAgent()) {
	return PhabricatorPolicies::POLICY_ADMIN;
	} else {
	return PhabricatorPolicies::POLICY_NOONE;
	}
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getPHID() && ($viewer->getPHID() === $this->getPHID());
	}

	public function describeAutomaticCapability($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_EDIT:
	return pht('Only you can edit your information.');
	default:
	return null;
	}
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('user.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'PhabricatorUserCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();

	$externals = id(new PhabricatorExternalAccount())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($externals as $external) {
	$external->delete();
	}

	$prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($prefs as $pref) {
	$pref->delete();
	}

	$profiles = id(new PhabricatorUserProfile())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($profiles as $profile) {
	$profile->delete();
	}

	$keys = id(new PhabricatorAuthSSHKey())->loadAllWhere(
	'objectPHID = %s',
	$this->getPHID());
	foreach ($keys as $key) {
	$key->delete();
	}

	$emails = id(new PhabricatorUserEmail())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($emails as $email) {
	$email->delete();
	}

	$sessions = id(new PhabricatorAuthSession())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($sessions as $session) {
	$session->delete();
	}

	$factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($factors as $factor) {
	$factor->delete();
	}

	$this->saveTransaction();
	}


	/* -( PhabricatorSSHPublicKeyInterface )----------------------------------- */


	public function getSSHPublicKeyManagementURI(PhabricatorUser $viewer) {
	if ($viewer->getPHID() == $this->getPHID()) {
	// If the viewer is managing their own keys, take them to the normal
	// panel.
	return '/settings/panel/ssh/';
	} else {
	// Otherwise, take them to the administrative panel for this user.
	return '/settings/'.$this->getID().'/panel/ssh/';
	}
	}

	public function getSSHKeyDefaultName() {
	return 'id_rsa_phabricator';
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Dec 3, 3:16 PM (9 h, 53 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 433658
Default Alt Text: (70 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions