No OneTemporary
Actions

Size

70 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	index 93642a959c..63d33beab4 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	@@ -1,263 +1,256 @@
	<?php

	final class PhabricatorCalendarEventEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'calendar.event';

	public function getEngineName() {
	return pht('Calendar Events');
	}

	public function getSummaryHeader() {
	return pht('Configure Calendar Event Forms');
	}

	public function getSummaryText() {
	return pht('Configure how users create and edit events.');
	}

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

	protected function newEditableObject() {
	return PhabricatorCalendarEvent::initializeNewCalendarEvent(
	$this->getViewer());
	}

	protected function newObjectQuery() {
	return new PhabricatorCalendarEventQuery();
	}

	protected function getObjectCreateTitleText($object) {
	return pht('Create New Event');
	}

	protected function getObjectEditTitleText($object) {
	return pht('Edit Event: %s', $object->getName());
	}

	protected function getObjectEditShortText($object) {
	return $object->getMonogram();
	}

	protected function getObjectCreateShortText() {
	return pht('Create Event');
	}

	protected function getObjectName() {
	return pht('Event');
	}

	protected function getObjectViewURI($object) {
	return $object->getURI();
	}

	protected function getEditorURI() {
	return $this->getApplication()->getApplicationURI('event/edit/');
	}

	protected function buildCustomEditFields($object) {
	$viewer = $this->getViewer();

	if ($this->getIsCreate()) {
	$invitee_phids = array($viewer->getPHID());
	} else {
	$invitee_phids = $object->getInviteePHIDsForEdit();
	}

	$frequency_options = array(
	PhabricatorCalendarEvent::FREQUENCY_DAILY => pht('Daily'),
	PhabricatorCalendarEvent::FREQUENCY_WEEKLY => pht('Weekly'),
	PhabricatorCalendarEvent::FREQUENCY_MONTHLY => pht('Monthly'),
	PhabricatorCalendarEvent::FREQUENCY_YEARLY => pht('Yearly'),
	);

	$fields = array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the event.'))
	->setIsRequired(true)
	->setTransactionType(
	PhabricatorCalendarEventNameTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Rename the event.'))
	->setConduitTypeDescription(pht('New event name.'))
	->setValue($object->getName()),
	id(new PhabricatorRemarkupEditField())
	->setKey('description')
	->setLabel(pht('Description'))
	->setDescription(pht('Description of the event.'))
	->setTransactionType(
	PhabricatorCalendarEventDescriptionTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Update the event description.'))
	->setConduitTypeDescription(pht('New event description.'))
	->setValue($object->getDescription()),
	id(new PhabricatorBoolEditField())
	->setKey('cancelled')
	->setOptions(pht('Active'), pht('Cancelled'))
	->setLabel(pht('Cancelled'))
	->setDescription(pht('Cancel the event.'))
	->setTransactionType(
	PhabricatorCalendarEventCancelTransaction::TRANSACTIONTYPE)
	->setIsConduitOnly(true)
	->setConduitDescription(pht('Cancel or restore the event.'))
	->setConduitTypeDescription(pht('True to cancel the event.'))
	->setValue($object->getIsCancelled()),
	id(new PhabricatorUsersEditField())
	->setKey('hostPHID')
	->setAliases(array('host'))
	->setLabel(pht('Host'))
	->setDescription(pht('Host of the event.'))
	->setTransactionType(
	PhabricatorCalendarEventHostTransaction::TRANSACTIONTYPE)
	->setIsConduitOnly($this->getIsCreate())
	->setConduitDescription(pht('Change the host of the event.'))
	->setConduitTypeDescription(pht('New event host.'))
	->setSingleValue($object->getHostPHID()),
	id(new PhabricatorDatasourceEditField())
	->setKey('inviteePHIDs')
	->setAliases(array('invite', 'invitee', 'invitees', 'inviteePHID'))
	->setLabel(pht('Invitees'))
	->setDatasource(new PhabricatorMetaMTAMailableDatasource())
	->setTransactionType(
	PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Users invited to the event.'))
	->setConduitDescription(pht('Change invited users.'))
	->setConduitTypeDescription(pht('New event invitees.'))
	->setValue($invitee_phids)
	->setCommentActionLabel(pht('Change Invitees')),
	);

	if ($this->getIsCreate()) {
	$fields[] = id(new PhabricatorBoolEditField())
	->setKey('isRecurring')
	->setLabel(pht('Recurring'))
	->setOptions(pht('One-Time Event'), pht('Recurring Event'))
	->setTransactionType(
	PhabricatorCalendarEventRecurringTransaction::TRANSACTIONTYPE)
	->setDescription(pht('One time or recurring event.'))
	->setConduitDescription(pht('Make the event recurring.'))
	->setConduitTypeDescription(pht('Mark the event as a recurring event.'))
	->setValue($object->getIsRecurring());

	$fields[] = id(new PhabricatorSelectEditField())
	->setKey('frequency')
	->setLabel(pht('Frequency'))
	->setOptions($frequency_options)
	->setTransactionType(
	PhabricatorCalendarEventFrequencyTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Recurring event frequency.'))
	->setConduitDescription(pht('Change the event frequency.'))
	->setConduitTypeDescription(pht('New event frequency.'))
	->setValue($object->getFrequencyRule());
	}

	if ($this->getIsCreate() \|\| $object->getIsRecurring()) {
	- $until_datetime = $object->newUntilDateTime();
	- if ($until_datetime) {
	- $until_epoch = $until_datetime->getEpoch();
	- } else {
	- $until_epoch = null;
	- }
	-
	$fields[] = id(new PhabricatorEpochEditField())
	->setAllowNull(true)
	->setKey('until')
	->setLabel(pht('Repeat Until'))
	->setTransactionType(
	PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Last instance of the event.'))
	->setConduitDescription(pht('Change when the event repeats until.'))
	->setConduitTypeDescription(pht('New final event time.'))
	- ->setValue($until_epoch);
	+ ->setValue($object->getUntilDateTimeEpoch());
	}

	$fields[] = id(new PhabricatorBoolEditField())
	->setKey('isAllDay')
	->setLabel(pht('All Day'))
	->setOptions(pht('Normal Event'), pht('All Day Event'))
	->setTransactionType(
	PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Marks this as an all day event.'))
	->setConduitDescription(pht('Make the event an all day event.'))
	->setConduitTypeDescription(pht('Mark the event as an all day event.'))
	->setValue($object->getIsAllDay());

	$fields[] = id(new PhabricatorEpochEditField())
	->setKey('start')
	->setLabel(pht('Start'))
	->setTransactionType(
	PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Start time of the event.'))
	->setConduitDescription(pht('Change the start time of the event.'))
	->setConduitTypeDescription(pht('New event start time.'))
	->setValue($object->getStartDateTimeEpoch());

	$fields[] = id(new PhabricatorEpochEditField())
	->setKey('end')
	->setLabel(pht('End'))
	->setTransactionType(
	PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('End time of the event.'))
	->setConduitDescription(pht('Change the end time of the event.'))
	->setConduitTypeDescription(pht('New event end time.'))
	->setValue($object->getEndDateTimeEpoch());

	$fields[] = id(new PhabricatorIconSetEditField())
	->setKey('icon')
	->setLabel(pht('Icon'))
	->setIconSet(new PhabricatorCalendarIconSet())
	->setTransactionType(
	PhabricatorCalendarEventIconTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Event icon.'))
	->setConduitDescription(pht('Change the event icon.'))
	->setConduitTypeDescription(pht('New event icon.'))
	->setValue($object->getIcon());

	return $fields;
	}

	protected function willBuildEditForm($object, array $fields) {
	$all_day_field = idx($fields, 'isAllDay');
	$start_field = idx($fields, 'start');
	$end_field = idx($fields, 'end');

	if ($all_day_field) {
	$is_all_day = $all_day_field->getValueForTransaction();

	$control_ids = array();
	if ($start_field) {
	$control_ids[] = $start_field->getControlID();
	}
	if ($end_field) {
	$control_ids[] = $end_field->getControlID();
	}

	Javelin::initBehavior(
	'event-all-day',
	array(
	'allDayID' => $all_day_field->getControlID(),
	'controlIDs' => $control_ids,
	));

	} else {
	$is_all_day = $object->getIsAllDay();
	}

	if ($is_all_day) {
	if ($start_field) {
	$start_field->setHideTime(true);
	}

	if ($end_field) {
	$end_field->setHideTime(true);
	}
	}



	return $fields;
	}
	}
	diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	index d87746f347..5dd9b463c6 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	@@ -1,331 +1,331 @@
	<?php

	final class PhabricatorCalendarEventEditor
	extends PhabricatorApplicationTransactionEditor {

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

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

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

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

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

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

	$actor = $this->getActor();
	$event->copyFromParent($actor);
	$event->setIsStub(0);

	$invitees = $event->getParentEvent()->getInvitees();

	$new_invitees = array();
	foreach ($invitees as $invitee) {
	$invitee = id(new PhabricatorCalendarEventInvitee())
	->setEventPHID($event->getPHID())
	->setInviteePHID($invitee->getInviteePHID())
	->setInviterPHID($invitee->getInviterPHID())
	->setStatus($invitee->getStatus())
	->save();

	$new_invitees[] = $invitee;
	}

	$event->save();
	$event->attachInvitees($new_invitees);
	}

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

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

	return $types;
	}

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

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

	return $copy;
	}


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

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

	$invalidate_all = false;
	$invalidate_phids = array();
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventCancelTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE:
	// For these kinds of changes, we need to invalidate the availabilty
	// caches for all attendees.
	$invalidate_all = true;
	break;
	case PhabricatorCalendarEventAcceptTransaction::TRANSACTIONTYPE:
	case PhabricatorCalendarEventDeclineTransaction::TRANSACTIONTYPE:
	$acting_phid = $this->getActingAsPHID();
	$invalidate_phids[$acting_phid] = $acting_phid;
	break;
	case PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE:
	foreach ($xaction->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) {
	$object->applyViewerTimezone($this->getActor());

	$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());
	+ $object->getStartDateTimeEpochForCache());
	}

	return $xactions;
	}


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

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

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

	$errors = array();

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

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

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

	return $errors;
	}

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

	protected function supportsSearch() {
	return true;
	}

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

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

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

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

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

	$phids = array_unique($phids);

	return $phids;
	}

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

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

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

	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->addRemarkupSection(
	pht('EVENT DESCRIPTION'),
	$description);
	}

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

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

	return $body;
	}

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

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

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

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

	$event_node = $event->newIntermediateEventNode($actor);

	$document_node = id(new PhutilCalendarDocumentNode())
	->appendChild($event_node);

	$root_node = id(new PhutilCalendarRootNode())
	->appendChild($document_node);

	$ics_data = id(new PhutilICSWriter())
	->writeICSDocument($root_node);

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

	return $ics_attachment;
	}

	}
	diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	index 6e4d0ce04e..2ddc71115f 100644
	--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	@@ -1,1052 +1,1062 @@
	<?php

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

	protected $name;
	protected $hostPHID;
	protected $dateFrom;
	protected $dateTo;
	protected $allDayDateFrom;
	protected $allDayDateTo;
	protected $description;
	protected $isCancelled;
	protected $isAllDay;
	protected $icon;
	protected $mailKey;
	protected $isStub;

	protected $isRecurring = 0;
	protected $recurrenceFrequency = array();
	protected $recurrenceEndDate;

	private $isGhostEvent = false;
	protected $instanceOfEventPHID;
	protected $sequenceIndex;

	protected $viewPolicy;
	protected $editPolicy;

	protected $spacePHID;

	protected $utcInitialEpoch;
	protected $utcUntilEpoch;
	protected $utcInstanceEpoch;
	protected $parameters = array();

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

	private $viewerTimezone;

	// Frequency Constants
	const FREQUENCY_DAILY = 'daily';
	const FREQUENCY_WEEKLY = 'weekly';
	const FREQUENCY_MONTHLY = 'monthly';
	const FREQUENCY_YEARLY = 'yearly';

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

	$view_default = PhabricatorCalendarEventDefaultViewCapability::CAPABILITY;
	$edit_default = PhabricatorCalendarEventDefaultEditCapability::CAPABILITY;
	$view_policy = $app->getPolicy($view_default);
	$edit_policy = $app->getPolicy($edit_default);

	$now = PhabricatorTime::getNow();

	$start = new DateTime('@'.$now);
	$start->setTimeZone($actor->getTimeZone());

	$start->setTime($start->format('H'), 0, 0);
	$start->modify('+1 hour');
	$end = id(clone $start)->modify('+1 hour');

	$epoch_min = $start->format('U');
	$epoch_max = $end->format('U');

	$now_date = new DateTime('@'.$now);
	$now_min = id(clone $now_date)->setTime(0, 0)->format('U');
	$now_max = id(clone $now_date)->setTime(23, 59)->format('U');

	$default_icon = 'fa-calendar';

	$datetime_start = PhutilCalendarAbsoluteDateTime::newFromEpoch(
	$now,
	$actor->getTimezoneIdentifier());
	$datetime_end = $datetime_start->newRelativeDateTime('PT1H');

	return id(new PhabricatorCalendarEvent())
	->setHostPHID($actor->getPHID())
	->setIsCancelled(0)
	->setIsAllDay(0)
	->setIsStub(0)
	->setIsRecurring(0)
	->setRecurrenceFrequency(
	array(
	'rule' => self::FREQUENCY_WEEKLY,
	))
	->setIcon($default_icon)
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setSpacePHID($actor->getDefaultSpacePHID())
	->attachInvitees(array())
	->setDateFrom($epoch_min)
	->setDateTo($epoch_max)
	->setAllDayDateFrom($now_min)
	->setAllDayDateTo($now_max)
	->setStartDateTime($datetime_start)
	->setEndDateTime($datetime_end)
	->applyViewerTimezone($actor);
	}

	private function newChild(PhabricatorUser $actor, $sequence) {
	if (!$this->isParentEvent()) {
	throw new Exception(
	pht(
	'Unable to generate a new child event for an event which is not '.
	'a recurring parent event!'));
	}

	$child = id(new self())
	->setIsCancelled(0)
	->setIsStub(0)
	->setInstanceOfEventPHID($this->getPHID())
	->setSequenceIndex($sequence)
	->setIsRecurring(true)
	->setRecurrenceFrequency($this->getRecurrenceFrequency())
	->attachParentEvent($this);

	return $child->copyFromParent($actor);
	}

	protected function readField($field) {
	static $inherit = array(
	'hostPHID' => true,
	'isAllDay' => true,
	'icon' => true,
	'spacePHID' => true,
	'viewPolicy' => true,
	'editPolicy' => true,
	'name' => true,
	'description' => true,
	);

	// Read these fields from the parent event instead of this event. For
	// example, we want any changes to the parent event's name to apply to
	// the child.
	if (isset($inherit[$field])) {
	if ($this->getIsStub()) {
	// TODO: This should be unconditional, but the execution order of
	// CalendarEventQuery and applyViewerTimezone() are currently odd.
	if ($this->parentEvent !== self::ATTACHABLE) {
	return $this->getParentEvent()->readField($field);
	}
	}
	}

	return parent::readField($field);
	}


	public function copyFromParent(PhabricatorUser $actor) {
	if (!$this->isChildEvent()) {
	throw new Exception(
	pht(
	'Unable to copy from parent event: this is not a child event.'));
	}

	$parent = $this->getParentEvent();

	$this
	->setHostPHID($parent->getHostPHID())
	->setIsAllDay($parent->getIsAllDay())
	->setIcon($parent->getIcon())
	->setSpacePHID($parent->getSpacePHID())
	->setViewPolicy($parent->getViewPolicy())
	->setEditPolicy($parent->getEditPolicy())
	->setName($parent->getName())
	->setDescription($parent->getDescription());

	$sequence = $this->getSequenceIndex();
	- $duration = $this->getDuration();
	+ $duration = $parent->getDuration();
	$epochs = $parent->getSequenceIndexEpochs($actor, $sequence, $duration);

	$this
	->setDateFrom($epochs['dateFrom'])
	->setDateTo($epochs['dateTo'])
	->setAllDayDateFrom($epochs['allDayDateFrom'])
	->setAllDayDateTo($epochs['allDayDateTo']);

	return $this;
	}

	public function isValidSequenceIndex(PhabricatorUser $viewer, $sequence) {
	try {
	$this->getSequenceIndexEpochs($viewer, $sequence, $this->getDuration());
	return true;
	} catch (Exception $ex) {
	return false;
	}
	}

	private function getSequenceIndexEpochs(
	PhabricatorUser $viewer,
	$sequence,
	$duration) {

	$frequency = $this->getFrequencyUnit();
	$modify_key = '+'.$sequence.' '.$frequency;

	$date = $this->getDateFrom();
	$date_time = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
	$date_time->modify($modify_key);
	$date = $date_time->format('U');

	$end_date = $this->getRecurrenceEndDate();
	if ($end_date && $date > $end_date) {
	throw new Exception(
	pht(
	'Sequence "%s" is invalid for this event: it would occur after '.
	'the event stops repeating.',
	$sequence));
	}

	$utc = new DateTimeZone('UTC');

	$allday_from = $this->getAllDayDateFrom();
	$allday_date = new DateTime('@'.$allday_from, $utc);
	$allday_date->setTimeZone($utc);
	$allday_date->modify($modify_key);

	$allday_min = $allday_date->format('U');
	$allday_duration = ($this->getAllDayDateTo() - $allday_from);

	return array(
	'dateFrom' => $date,
	'dateTo' => $date + $duration,
	'allDayDateFrom' => $allday_min,
	'allDayDateTo' => $allday_min + $allday_duration,
	);
	}

	public function newStub(PhabricatorUser $actor, $sequence) {
	$stub = $this->newChild($actor, $sequence);

	$stub->setIsStub(1);

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$stub->save();
	unset($unguarded);

	$stub->applyViewerTimezone($actor);

	return $stub;
	}

	public function newGhost(PhabricatorUser $actor, $sequence) {
	$ghost = $this->newChild($actor, $sequence);

	$ghost
	->setIsGhostEvent(true)
	->makeEphemeral();

	$ghost->applyViewerTimezone($actor);

	return $ghost;
	}

	public function applyViewerTimezone(PhabricatorUser $viewer) {
	$this->viewerTimezone = $viewer->getTimezoneIdentifier();
	return $this;
	}

	public function getDuration() {
	- return $this->getDateTo() - $this->getDateFrom();
	+ return ($this->getEndDateTimeEpoch() - $this->getStartDateTimeEpoch());
	}

	public 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 updateUTCEpochs() {
	// The "intitial" epoch is the start time of the event, in UTC.
	$start_date = $this->newStartDateTime()
	->setViewerTimezone('UTC');
	$start_epoch = $start_date->getEpoch();
	$this->setUTCInitialEpoch($start_epoch);

	// The "until" epoch is the last UTC epoch on which any instance of this
	// event occurs. For infinitely recurring events, it is `null`.

	if (!$this->getIsRecurring()) {
	$end_date = $this->newEndDateTime()
	->setViewerTimezone('UTC');
	$until_epoch = $end_date->getEpoch();
	} else {
	$until_epoch = null;
	$until_date = $this->newUntilDateTime()
	->setViewerTimezone('UTC');
	if ($until_date) {
	$duration = $this->newDuration();
	$until_epoch = id(new PhutilCalendarRelativeDateTime())
	->setOrigin($until_date)
	->setDuration($duration)
	->getEpoch();
	}
	}
	$this->setUTCUntilEpoch($until_epoch);

	// The "instance" epoch is a property of instances of recurring events.
	// It's the original UTC epoch on which the instance started. Usually that
	// is the same as the start date, but they may be different if the instance
	// has been edited.

	// The ICS format uses this value (original start time) to identify event
	// instances, and must do so because it allows additional arbitrary
	// instances to be added (with "RDATE").

	$instance_epoch = null;
	$instance_date = $this->newInstanceDateTime();
	if ($instance_date) {
	$instance_epoch = $instance_date
	->setViewerTimezone('UTC')
	->getEpoch();
	}
	$this->setUTCInstanceEpoch($instance_epoch);

	return $this;
	}

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

	$this->updateUTCEpochs();

	return parent::save();
	}

	/**
	* Get the event start epoch for evaluating invitee availability.
	*
	* When assessing availability, we pretend events start earlier than they
	* really do. 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() {
	+ public function getStartDateTimeEpochForCache() {
	$epoch = $this->getStartDateTimeEpoch();
	$window = phutil_units('15 minutes in seconds');
	return ($epoch - $window);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'text',
	'dateFrom' => 'epoch',
	'dateTo' => 'epoch',
	'allDayDateFrom' => 'epoch',
	'allDayDateTo' => 'epoch',
	'description' => 'text',
	'isCancelled' => 'bool',
	'isAllDay' => 'bool',
	'icon' => 'text32',
	'mailKey' => 'bytes20',
	'isRecurring' => 'bool',
	'recurrenceEndDate' => 'epoch?',
	'instanceOfEventPHID' => 'phid?',
	'sequenceIndex' => 'uint32?',
	'isStub' => 'bool',
	'utcInitialEpoch' => 'epoch',
	'utcUntilEpoch' => 'epoch?',
	'utcInstanceEpoch' => 'epoch?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_date' => array(
	'columns' => array('dateFrom', 'dateTo'),
	),
	'key_instance' => array(
	'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
	'unique' => true,
	),
	'key_epoch' => array(
	'columns' => array('utcInitialEpoch', 'utcUntilEpoch'),
	),
	'key_rdate' => array(
	'columns' => array('instanceOfEventPHID', 'utcInstanceEpoch'),
	'unique' => true,
	),
	),
	self::CONFIG_SERIALIZATION => array(
	'recurrenceFrequency' => self::SERIALIZATION_JSON,
	'parameters' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

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

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

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

	public function getInviteePHIDsForEdit() {
	$invitees = array();

	foreach ($this->getInvitees() as $invitee) {
	if ($invitee->isUninvited()) {
	continue;
	}
	$invitees[] = $invitee->getInviteePHID();
	}

	return $invitees;
	}

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

	public function getIsUserInvited($phid) {
	$uninvited_status = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	$declined_status = PhabricatorCalendarEventInvitee::STATUS_DECLINED;
	$status = $this->getUserInviteStatus($phid);
	if ($status == $uninvited_status \|\| $status == $declined_status) {
	return false;
	}
	return true;
	}

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

	public function setIsGhostEvent($is_ghost_event) {
	$this->isGhostEvent = $is_ghost_event;
	return $this;
	}

	public function getFrequencyRule() {
	return idx($this->recurrenceFrequency, 'rule');
	}

	public function getFrequencyUnit() {
	$frequency = $this->getFrequencyRule();

	switch ($frequency) {
	case 'daily':
	return 'day';
	case 'weekly':
	return 'week';
	case 'monthly':
	return 'month';
	case 'yearly':
	return 'year';
	default:
	return 'day';
	}
	}

	public function getURI() {
	if ($this->getIsGhostEvent()) {
	$base = $this->getParentEvent()->getURI();
	$sequence = $this->getSequenceIndex();
	return "{$base}/{$sequence}/";
	}

	return '/'.$this->getMonogram();
	}

	public function getParentEvent() {
	return $this->assertAttached($this->parentEvent);
	}

	public function attachParentEvent($event) {
	$this->parentEvent = $event;
	return $this;
	}

	public function isParentEvent() {
	return ($this->getIsRecurring() && !$this->getInstanceOfEventPHID());
	}

	public function isChildEvent() {
	return ($this->instanceOfEventPHID !== null);
	}

	public function isCancelledEvent() {
	if ($this->getIsCancelled()) {
	return true;
	}

	if ($this->isChildEvent()) {
	if ($this->getParentEvent()->getIsCancelled()) {
	return true;
	}
	}

	return false;
	}

	public function renderEventDate(
	PhabricatorUser $viewer,
	$show_end) {

	$start = $this->newStartDateTime();
	$end = $this->newEndDateTime();

	if ($show_end) {
	$min_date = $start->newPHPDateTime();
	$max_date = $end->newPHPDateTime();

	$min_day = $min_date->format('Y m d');
	$max_day = $max_date->format('Y m d');

	$show_end_date = ($min_day != $max_day);
	} else {
	$show_end_date = false;
	}

	$min_epoch = $start->getEpoch();
	$max_epoch = $end->getEpoch();

	if ($this->getIsAllDay()) {
	if ($show_end_date) {
	return pht(
	'%s - %s, All Day',
	phabricator_date($min_epoch, $viewer),
	phabricator_date($max_epoch, $viewer));
	} else {
	return pht(
	'%s, All Day',
	phabricator_date($min_epoch, $viewer));
	}
	} else if ($show_end_date) {
	return pht(
	'%s - %s',
	phabricator_datetime($min_epoch, $viewer),
	phabricator_datetime($max_epoch, $viewer));
	} else if ($show_end) {
	return pht(
	'%s - %s',
	phabricator_datetime($min_epoch, $viewer),
	phabricator_time($max_epoch, $viewer));
	} else {
	return pht(
	'%s',
	phabricator_datetime($min_epoch, $viewer));
	}
	}


	public function getDisplayIcon(PhabricatorUser $viewer) {
	if ($this->isCancelledEvent()) {
	return 'fa-times';
	}

	if ($viewer->isLoggedIn()) {
	$status = $this->getUserInviteStatus($viewer->getPHID());
	switch ($status) {
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	return 'fa-check-circle';
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	return 'fa-user-plus';
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	return 'fa-times';
	}
	}

	return $this->getIcon();
	}

	public function getDisplayIconColor(PhabricatorUser $viewer) {
	if ($this->isCancelledEvent()) {
	return 'red';
	}

	if ($viewer->isLoggedIn()) {
	$status = $this->getUserInviteStatus($viewer->getPHID());
	switch ($status) {
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	return 'green';
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	return 'green';
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	return 'grey';
	}
	}

	return 'bluegrey';
	}

	public function getDisplayIconLabel(PhabricatorUser $viewer) {
	if ($this->isCancelledEvent()) {
	return pht('Cancelled');
	}

	if ($viewer->isLoggedIn()) {
	$status = $this->getUserInviteStatus($viewer->getPHID());
	switch ($status) {
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	return pht('Attending');
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	return pht('Invited');
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	return pht('Declined');
	}
	}

	return null;
	}

	public function getICSFilename() {
	return $this->getMonogram().'.ics';
	}

	public function newIntermediateEventNode(PhabricatorUser $viewer) {
	$base_uri = new PhutilURI(PhabricatorEnv::getProductionURI('/'));
	$domain = $base_uri->getDomain();

	$uid = $this->getPHID().'@'.$domain;

	$created = $this->getDateCreated();
	$created = PhutilCalendarAbsoluteDateTime::newFromEpoch($created);

	$modified = $this->getDateModified();
	$modified = PhutilCalendarAbsoluteDateTime::newFromEpoch($modified);

	$date_start = $this->newStartDateTime();
	$date_end = $this->newEndDateTime();

	if ($this->getIsAllDay()) {
	$date_start->setIsAllDay(true);
	$date_end->setIsAllDay(true);
	}

	$host_phid = $this->getHostPHID();

	$invitees = $this->getInvitees();
	foreach ($invitees as $key => $invitee) {
	if ($invitee->isUninvited()) {
	unset($invitees[$key]);
	}
	}

	$phids = array();
	$phids[] = $host_phid;
	foreach ($invitees as $invitee) {
	$phids[] = $invitee->getInviteePHID();
	}

	$handles = $viewer->loadHandles($phids);

	$host_handle = $handles[$host_phid];
	$host_name = $host_handle->getFullName();
	$host_uri = $host_handle->getURI();
	$host_uri = PhabricatorEnv::getURI($host_uri);

	$organizer = id(new PhutilCalendarUserNode())
	->setName($host_name)
	->setURI($host_uri);

	$attendees = array();
	foreach ($invitees as $invitee) {
	$invitee_phid = $invitee->getInviteePHID();
	$invitee_handle = $handles[$invitee_phid];
	$invitee_name = $invitee_handle->getFullName();
	$invitee_uri = $invitee_handle->getURI();
	$invitee_uri = PhabricatorEnv::getURI($invitee_uri);

	switch ($invitee->getStatus()) {
	case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
	$status = PhutilCalendarUserNode::STATUS_ACCEPTED;
	break;
	case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
	$status = PhutilCalendarUserNode::STATUS_DECLINED;
	break;
	case PhabricatorCalendarEventInvitee::STATUS_INVITED:
	default:
	$status = PhutilCalendarUserNode::STATUS_INVITED;
	break;
	}

	$attendees[] = id(new PhutilCalendarUserNode())
	->setName($invitee_name)
	->setURI($invitee_uri)
	->setStatus($status);
	}

	$node = id(new PhutilCalendarEventNode())
	->setUID($uid)
	->setName($this->getName())
	->setDescription($this->getDescription())
	->setCreatedDateTime($created)
	->setModifiedDateTime($modified)
	->setStartDateTime($date_start)
	->setEndDateTime($date_end)
	->setOrganizer($organizer)
	->setAttendees($attendees);

	return $node;
	}

	public function newStartDateTime() {
	$datetime = $this->getParameter('startDateTime');
	if ($datetime) {
	return $this->newDateTimeFromDictionary($datetime);
	}

	$epoch = $this->getDateFrom();
	return $this->newDateTimeFromEpoch($epoch);
	}

	public function getStartDateTimeEpoch() {
	return $this->newStartDateTime()->getEpoch();
	}

	public function newEndDateTime() {
	$datetime = $this->getParameter('endDateTime');
	if ($datetime) {
	return $this->newDateTimeFromDictionary($datetime);
	}

	$epoch = $this->getDateTo();
	return $this->newDateTimeFromEpoch($epoch);
	}

	public function getEndDateTimeEpoch() {
	return $this->newEndDateTime()->getEpoch();
	}

	public function newUntilDateTime() {
	$datetime = $this->getParameter('untilDateTime');
	if ($datetime) {
	return $this->newDateTimeFromDictionary($datetime);
	}

	$epoch = $this->getRecurrenceEndDate();
	if (!$epoch) {
	return null;
	}
	return $this->newDateTimeFromEpoch($epoch);
	}

	+ public function getUntilDateTimeEpoch() {
	+ $datetime = $this->newUntilDateTime();
	+
	+ if (!$datetime) {
	+ return null;
	+ }
	+
	+ return $datetime->getEpoch();
	+ }
	+
	public function newDuration() {
	return id(new PhutilCalendarDuration())
	->setSeconds($this->getDuration());
	}

	public function newInstanceDateTime() {
	if (!$this->getIsRecurring()) {
	return null;
	}

	$epochs = $this->getParent()->getSequenceIndexEpochs(
	new PhabricatorUser(),
	$this->getSequenceIndex(),
	$this->getDuration());

	$epoch = $epochs['dateFrom'];
	return $this->newDateTimeFromEpoch($epoch);
	}

	private function newDateTimeFromEpoch($epoch) {
	$datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch($epoch);

	if ($this->getIsAllDay()) {
	$datetime->setIsAllDay(true);
	}

	return $this->newDateTimeFromDateTime($datetime);
	}

	private function newDateTimeFromDictionary(array $dict) {
	$datetime = PhutilCalendarAbsoluteDateTime::newFromDictionary($dict);
	return $this->newDateTimeFromDateTime($datetime);
	}

	private function newDateTimeFromDateTime(PhutilCalendarDateTime $datetime) {
	$viewer_timezone = $this->viewerTimezone;
	if ($viewer_timezone) {
	$datetime->setViewerTimezone($viewer_timezone);
	}

	return $datetime;
	}

	public function getParameter($key, $default = null) {
	return idx($this->parameters, $key, $default);
	}

	public function setParameter($key, $value) {
	$this->parameters[$key] = $value;
	return $this;
	}

	public function setStartDateTime(PhutilCalendarDateTime $datetime) {
	return $this->setParameter(
	'startDateTime',
	$datetime->newAbsoluteDateTime()->toDictionary());
	}

	public function setEndDateTime(PhutilCalendarDateTime $datetime) {
	return $this->setParameter(
	'endDateTime',
	$datetime->newAbsoluteDateTime()->toDictionary());
	}

	public function setUntilDateTime(PhutilCalendarDateTime $datetime) {
	return $this->setParameter(
	'untilDateTime',
	$datetime->newAbsoluteDateTime()->toDictionary());
	}

	/* -( 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 host of an event can always view and edit it.
	$user_phid = $this->getHostPHID();
	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 host of an event can always view and edit it. Users who are '.
	'invited to an event 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->getHostPHID());
	}

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


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

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


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

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

	/* -( PhabricatorSpacesInterface )----------------------------------------- */


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


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new PhabricatorCalendarEventFulltextEngine();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('name')
	->setType('string')
	->setDescription(pht('The name of the event.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('description')
	->setType('string')
	->setDescription(pht('The event description.')),
	);
	}

	public function getFieldValuesForConduit() {
	return array(
	'name' => $this->getName(),
	'description' => $this->getDescription(),
	);
	}

	public function getConduitSearchAttachments() {
	return array();
	}

	}
	diff --git a/src/applications/calendar/xaction/PhabricatorCalendarEventEndDateTransaction.php b/src/applications/calendar/xaction/PhabricatorCalendarEventEndDateTransaction.php
	index 91d9b396ff..2d5f10d290 100644
	--- a/src/applications/calendar/xaction/PhabricatorCalendarEventEndDateTransaction.php
	+++ b/src/applications/calendar/xaction/PhabricatorCalendarEventEndDateTransaction.php
	@@ -1,53 +1,54 @@
	<?php

	final class PhabricatorCalendarEventEndDateTransaction
	extends PhabricatorCalendarEventDateTransaction {

	const TRANSACTIONTYPE = 'calendar.enddate';

	public function generateOldValue($object) {
	- return $object->getDateTo();
	+ // TODO: Upgrade this.
	+ return $object->getEndDateTimeEpoch();
	}

	public function applyInternalEffects($object, $value) {
	$actor = $this->getActor();

	// TODO: DEPRECATED.
	$object->setDateTo($value);
	$object->setAllDayDateTo(
	$object->getDateEpochForTimezone(
	$value,
	$actor->getTimeZone(),
	'Y-m-d 23:59:00',
	null,
	new DateTimeZone('UTC')));

	$datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch(
	$value,
	$actor->getTimezoneIdentifier());
	$datetime->setIsAllDay($object->getIsAllDay());
	$object->setEndDateTime($datetime);
	}

	public function getTitle() {
	return pht(
	'%s changed the end date for this event from %s to %s.',
	$this->renderAuthor(),
	$this->renderOldDate(),
	$this->renderNewDate());
	}

	public function getTitleForFeed() {
	return pht(
	'%s changed the end date for %s from %s to %s.',
	$this->renderAuthor(),
	$this->renderObject(),
	$this->renderOldDate(),
	$this->renderNewDate());
	}

	protected function getInvalidDateMessage() {
	return pht('End date is invalid.');
	}

	}
	diff --git a/src/applications/calendar/xaction/PhabricatorCalendarEventStartDateTransaction.php b/src/applications/calendar/xaction/PhabricatorCalendarEventStartDateTransaction.php
	index 90e3b9c9c5..48318edf7e 100644
	--- a/src/applications/calendar/xaction/PhabricatorCalendarEventStartDateTransaction.php
	+++ b/src/applications/calendar/xaction/PhabricatorCalendarEventStartDateTransaction.php
	@@ -1,53 +1,54 @@
	<?php

	final class PhabricatorCalendarEventStartDateTransaction
	extends PhabricatorCalendarEventDateTransaction {

	const TRANSACTIONTYPE = 'calendar.startdate';

	public function generateOldValue($object) {
	- return $object->getDateFrom();
	+ // TODO: Upgrade this.
	+ return $object->getStartDateTimeEpoch();
	}

	public function applyInternalEffects($object, $value) {
	$actor = $this->getActor();

	// TODO: DEPRECATED.
	$object->setDateFrom($value);
	$object->setAllDayDateFrom(
	$object->getDateEpochForTimezone(
	$value,
	$actor->getTimeZone(),
	'Y-m-d',
	null,
	new DateTimeZone('UTC')));

	$datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch(
	$value,
	$actor->getTimezoneIdentifier());
	$datetime->setIsAllDay($object->getIsAllDay());
	$object->setStartDateTime($datetime);
	}

	public function getTitle() {
	return pht(
	'%s changed the start date for this event from %s to %s.',
	$this->renderAuthor(),
	$this->renderOldDate(),
	$this->renderNewDate());
	}

	public function getTitleForFeed() {
	return pht(
	'%s changed the start date for %s from %s to %s.',
	$this->renderAuthor(),
	$this->renderObject(),
	$this->renderOldDate(),
	$this->renderNewDate());
	}

	protected function getInvalidDateMessage() {
	return pht('Start date is invalid.');
	}

	}
	diff --git a/src/applications/calendar/xaction/PhabricatorCalendarEventUntilDateTransaction.php b/src/applications/calendar/xaction/PhabricatorCalendarEventUntilDateTransaction.php
	index 4cffda8ff6..736ed13704 100644
	--- a/src/applications/calendar/xaction/PhabricatorCalendarEventUntilDateTransaction.php
	+++ b/src/applications/calendar/xaction/PhabricatorCalendarEventUntilDateTransaction.php
	@@ -1,44 +1,45 @@
	<?php

	final class PhabricatorCalendarEventUntilDateTransaction
	extends PhabricatorCalendarEventDateTransaction {

	const TRANSACTIONTYPE = 'calendar.recurrenceenddate';

	public function generateOldValue($object) {
	- return $object->getRecurrenceEndDate();
	+ // TODO: Upgrade this.
	+ return $object->getUntilDateTimeEpoch();
	}

	public function applyInternalEffects($object, $value) {
	$actor = $this->getActor();

	// TODO: DEPRECATED.
	$object->setRecurrenceEndDate($value);

	$datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch(
	$value,
	$actor->getTimezoneIdentifier());
	$datetime->setIsAllDay($object->getIsAllDay());
	$object->setUntilDateTime($datetime);
	}

	public function getTitle() {
	return pht(
	'%s changed this event to repeat until %s.',
	$this->renderAuthor(),
	$this->renderNewDate());
	}

	public function getTitleForFeed() {
	return pht(
	'%s changed %s to repeat until %s.',
	$this->renderAuthor(),
	$this->renderObject(),
	$this->renderNewDate());
	}

	protected function getInvalidDateMessage() {
	return pht('Repeat until date is invalid.');
	}

	}
	diff --git a/src/applications/people/query/PhabricatorPeopleQuery.php b/src/applications/people/query/PhabricatorPeopleQuery.php
	index 5d5650c860..07fbc8b941 100644
	--- a/src/applications/people/query/PhabricatorPeopleQuery.php
	+++ b/src/applications/people/query/PhabricatorPeopleQuery.php
	@@ -1,581 +1,581 @@
	<?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 $isMailingList;
	private $isDisabled;
	private $isApproved;
	private $nameLike;
	private $nameTokens;

	private $needPrimaryEmail;
	private $needProfile;
	private $needProfileImage;
	private $needAvailability;
	private $needBadges;
	private $cacheKeys = array();

	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 withIsMailingList($mailing_list) {
	$this->isMailingList = $mailing_list;
	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) {
	$cache_key = PhabricatorUserProfileImageCacheType::KEY_URI;

	if ($need) {
	$this->cacheKeys[$cache_key] = true;
	} else {
	unset($this->cacheKeys[$cache_key]);
	}

	return $this;
	}

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

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

	public function needUserSettings($need) {
	$cache_key = PhabricatorUserPreferencesCacheType::KEY_PREFERENCES;

	if ($need) {
	$this->cacheKeys[$cache_key] = true;
	} else {
	unset($this->cacheKeys[$cache_key]);
	}

	return $this;
	}

	public function newResultObject() {
	return new PhabricatorUser();
	}

	protected function loadPage() {
	$table = new PhabricatorUser();
	$data = $this->loadStandardPageRows($table);

	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 = PhabricatorUserProfile::initializeNewProfile($user);
	}

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

	if ($this->needBadges) {
	$awards = id(new PhabricatorBadgesAwardQuery())
	->setViewer($this->getViewer())
	->withRecipientPHIDs(mpull($users, 'getPHID'))
	->execute();

	$awards = mgroup($awards, 'getRecipientPHID');

	foreach ($users as $user) {
	$user_awards = idx($awards, $user->getPHID(), array());
	$badge_phids = mpull($user_awards, 'getBadgePHID');
	$user->attachBadgePHIDs($badge_phids);
	}
	}

	if ($this->needAvailability) {
	$rebuild = array();
	foreach ($users as $user) {
	$cache = $user->getAvailabilityCache();
	if ($cache !== null) {
	$user->attachAvailability($cache);
	} else {
	$rebuild[] = $user;
	}
	}

	if ($rebuild) {
	$this->rebuildAvailabilityCache($rebuild);
	}
	}

	$this->fillUserCaches($users);

	return $users;
	}

	protected function shouldGroupQueryResultRows() {
	if ($this->nameTokens) {
	return true;
	}

	return parent::shouldGroupQueryResultRows();
	}

	protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
	$joins = parent::buildJoinClauseParts($conn);

	if ($this->emails) {
	$email_table = new PhabricatorUserEmail();
	$joins[] = qsprintf(
	$conn,
	'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,
	'JOIN %T %T ON %T.userID = user.id AND %T.token LIKE %>',
	PhabricatorUser::NAMETOKEN_TABLE,
	$token_table,
	$token_table,
	$token_table,
	$token);
	}
	}

	return $joins;
	}

	protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
	$where = parent::buildWhereClauseParts($conn);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// NOTE: We don't need to generate ghosts here, because we only care if
	// the user is attending, and you can't attend a ghost event: RSVP'ing
	// to it creates a real event.

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

	// We need to load these users' timezone settings to figure out their
	// availability if they're attending all-day events.
	$this->needUserSettings(true);
	$this->fillUserCaches($rebuild);

	foreach ($rebuild as $phid => $user) {
	$events = idx($map, $phid, array());

	// We loaded events with the omnipotent user, but want to shift them
	// into the user's timezone before building the cache because they will
	// be unavailable during their own local day.
	foreach ($events as $event) {
	$event->applyViewerTimezone($user);
	}

	$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->getDateFromForCache();
	+ $from = $event->getStartDateTimeEpochForCache();
	$to = $event->getEndDateTimeEpoch();
	if (($from <= $cursor) && ($to > $cursor)) {
	$cursor = $to;
	continue 2;
	}
	}
	break;
	}
	}

	if ($cursor > $min_range) {
	$availability = array(
	'until' => $cursor,
	);
	$availability_ttl = $cursor;
	} else {
	$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);

	$user->writeAvailabilityCache($availability, $availability_ttl);
	$user->attachAvailability($availability);
	}
	}

	private function fillUserCaches(array $users) {
	if (!$this->cacheKeys) {
	return;
	}

	$user_map = mpull($users, null, 'getPHID');
	$keys = array_keys($this->cacheKeys);

	$hashes = array();
	foreach ($keys as $key) {
	$hashes[] = PhabricatorHash::digestForIndex($key);
	}

	$types = PhabricatorUserCacheType::getAllCacheTypes();

	// First, pull any available caches. If we wanted to be particularly clever
	// we could do this with JOINs in the main query.

	$cache_table = new PhabricatorUserCache();
	$cache_conn = $cache_table->establishConnection('r');

	$cache_data = queryfx_all(
	$cache_conn,
	'SELECT cacheKey, userPHID, cacheData, cacheType FROM %T
	WHERE cacheIndex IN (%Ls) AND userPHID IN (%Ls)',
	$cache_table->getTableName(),
	$hashes,
	array_keys($user_map));

	$skip_validation = array();

	// After we read caches from the database, discard any which have data that
	// invalid or out of date. This allows cache types to implement TTLs or
	// versions instead of or in addition to explicit cache clears.
	foreach ($cache_data as $row_key => $row) {
	$cache_type = $row['cacheType'];

	if (isset($skip_validation[$cache_type])) {
	continue;
	}

	if (empty($types[$cache_type])) {
	unset($cache_data[$row_key]);
	continue;
	}

	$type = $types[$cache_type];
	if (!$type->shouldValidateRawCacheData()) {
	$skip_validation[$cache_type] = true;
	continue;
	}

	$user = $user_map[$row['userPHID']];
	$raw_data = $row['cacheData'];
	if (!$type->isRawCacheDataValid($user, $row['cacheKey'], $raw_data)) {
	unset($cache_data[$row_key]);
	continue;
	}
	}

	$need = array();

	$cache_data = igroup($cache_data, 'userPHID');
	foreach ($user_map as $user_phid => $user) {
	$raw_rows = idx($cache_data, $user_phid, array());
	$raw_data = ipull($raw_rows, 'cacheData', 'cacheKey');

	foreach ($keys as $key) {
	if (isset($raw_data[$key]) \|\| array_key_exists($key, $raw_data)) {
	continue;
	}
	$need[$key][$user_phid] = $user;
	}

	$user->attachRawCacheData($raw_data);
	}

	// If we missed any cache values, bulk-construct them now. This is
	// usually much cheaper than generating them on-demand for each user
	// record.

	if (!$need) {
	return;
	}

	$writes = array();
	foreach ($need as $cache_key => $need_users) {
	$type = PhabricatorUserCacheType::getCacheTypeForKey($cache_key);
	if (!$type) {
	continue;
	}

	$data = $type->newValueForUsers($cache_key, $need_users);

	foreach ($data as $user_phid => $raw_value) {
	$data[$user_phid] = $raw_value;
	$writes[] = array(
	'userPHID' => $user_phid,
	'key' => $cache_key,
	'type' => $type,
	'value' => $raw_value,
	);
	}

	foreach ($need_users as $user_phid => $user) {
	if (isset($data[$user_phid]) \|\| array_key_exists($user_phid, $data)) {
	$user->attachRawCacheData(
	array(
	$cache_key => $data[$user_phid],
	));
	}
	}
	}

	PhabricatorUserCache::writeCaches($writes);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Oct 31, 3:11 PM (18 m, 9 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 312306
Default Alt Text: (70 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions