No OneTemporary
Actions

Size

103 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	index b5b1c0cc48..91d3a9e336 100644
	--- a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	+++ b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	@@ -1,613 +1,644 @@
	<?php

	final class PhabricatorCalendarEventViewController
	extends PhabricatorCalendarController {

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getViewer();

	$event = $this->loadEvent();
	if (!$event) {
	return new Aphront404Response();
	}

	// If we looked up or generated a stub event, redirect to that event's
	// canonical URI.
	$id = $request->getURIData('id');
	if ($event->getID() != $id) {
	$uri = $event->getURI();
	return id(new AphrontRedirectResponse())->setURI($uri);
	}

	$monogram = $event->getMonogram();
	$page_title = $monogram.' '.$event->getName();
	$crumbs = $this->buildApplicationCrumbs();

	$start = $event->newStartDateTime()
	->newPHPDateTime();

	$crumbs->addTextCrumb(
	$start->format('F Y'),
	'/calendar/query/month/'.$start->format('Y/m/'));

	$crumbs->addTextCrumb(
	$start->format('D jS'),
	'/calendar/query/month/'.$start->format('Y/m/d/'));

	$crumbs->addTextCrumb($monogram);
	$crumbs->setBorder(true);

	$timeline = $this->buildTransactionTimeline(
	$event,
	new PhabricatorCalendarEventTransactionQuery());

	$header = $this->buildHeaderView($event);
	$subheader = $this->buildSubheaderView($event);
	$curtain = $this->buildCurtain($event);
	$details = $this->buildPropertySection($event);
	$recurring = $this->buildRecurringSection($event);
	$description = $this->buildDescriptionView($event);

	$comment_view = id(new PhabricatorCalendarEventEditEngine())
	->setViewer($viewer)
	->buildEditEngineCommentView($event);

	$timeline->setQuoteRef($monogram);
	$comment_view->setTransactionTimeline($timeline);

	$details_header = id(new PHUIHeaderView())
	->setHeader(pht('Details'));
	$recurring_header = $this->buildRecurringHeader($event);

	// NOTE: This is a bit hacky: for imported events, we're just hiding the
	// comment form without actually preventing comments. Users could still
	// submit a request to add comments to these events. This isn't really a
	// major problem since they can't do anything truly bad and there isn't an
	// easy way to selectively disable this or some other similar behaviors
	// today, but it would probably be nice to fully disable these
	// "pseudo-edits" (like commenting and probably subscribing and awarding
	// tokens) at some point.
	if ($event->isImportedEvent()) {
	$comment_view = null;
	$timeline->setShouldTerminate(true);
	}

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setSubheader($subheader)
	->setMainColumn(
	array(
	$timeline,
	$comment_view,
	))
	->setCurtain($curtain)
	->addPropertySection(pht('Description'), $description)
	->addPropertySection($recurring_header, $recurring)
	->addPropertySection($details_header, $details);

	return $this->newPage()
	->setTitle($page_title)
	->setCrumbs($crumbs)
	->setPageObjectPHIDs(array($event->getPHID()))
	->appendChild($view);
	}

	private function buildHeaderView(
	PhabricatorCalendarEvent $event) {
	$viewer = $this->getViewer();
	$id = $event->getID();

	if ($event->getIsCancelled()) {
	$icon = 'fa-ban';
	$color = 'red';
	$status = pht('Cancelled');
	} else {
	$icon = 'fa-check';
	$color = 'bluegrey';
	$status = pht('Active');
	}

	$header = id(new PHUIHeaderView())
	->setUser($viewer)
	->setHeader($event->getName())
	->setStatus($icon, $color, $status)
	->setPolicyObject($event)
	->setHeaderIcon($event->getIcon());

	if ($event->isImportedEvent()) {
	$header->addTag(
	id(new PHUITagView())
	->setType(PHUITagView::TYPE_SHADE)
	->setName(pht('Imported'))
	->setIcon('fa-download')
	->setHref($event->getImportSource()->getURI())
	->setShade('orange'));
	}

	foreach ($this->buildRSVPActions($event) as $action) {
	$header->addActionLink($action);
	}

	$options = PhabricatorCalendarEventInvitee::getAvailabilityMap();

	$is_attending = $event->getIsUserAttending($viewer->getPHID());
	if ($is_attending) {
	$invitee = $event->getInviteeForPHID($viewer->getPHID());

	$selected = $invitee->getDisplayAvailability($event);
	if (!$selected) {
	$selected = PhabricatorCalendarEventInvitee::AVAILABILITY_AVAILABLE;
	}

	$selected_option = idx($options, $selected);

	$availability_select = id(new PHUIButtonView())
	->setTag('a')
	->setIcon('fa-circle '.$selected_option['color'])
	->setText(pht('Availability: %s', $selected_option['name']));

	$dropdown = id(new PhabricatorActionListView())
	->setUser($viewer);

	foreach ($options as $key => $option) {
	$uri = "event/availability/{$id}/{$key}/";
	$uri = $this->getApplicationURI($uri);

	$dropdown->addAction(
	id(new PhabricatorActionView())
	->setName($option['name'])
	->setIcon('fa-circle '.$option['color'])
	->setHref($uri)
	->setWorkflow(true));
	}

	$availability_select->setDropdownMenu($dropdown);
	$header->addActionLink($availability_select);
	}

	return $header;
	}

	private function buildCurtain(PhabricatorCalendarEvent $event) {
	$viewer = $this->getRequest()->getUser();
	$id = $event->getID();
	$is_attending = $event->getIsUserAttending($viewer->getPHID());

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$event,
	PhabricatorPolicyCapability::CAN_EDIT);

	$edit_uri = "event/edit/{$id}/";
	$edit_uri = $this->getApplicationURI($edit_uri);
	$is_recurring = $event->getIsRecurring();
	$edit_label = pht('Edit Event');

	$curtain = $this->newCurtainView($event);

	if ($edit_label && $edit_uri) {
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName($edit_label)
	->setIcon('fa-pencil')
	->setHref($edit_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit \|\| $is_recurring));
	}

	$recurring_uri = "{$edit_uri}page/recurring/";
	$can_recurring = $can_edit && !$event->isChildEvent();

	if ($event->getIsRecurring()) {
	$recurring_label = pht('Edit Recurrence');
	} else {
	$recurring_label = pht('Make Recurring');
	}

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName($recurring_label)
	->setIcon('fa-repeat')
	->setHref($recurring_uri)
	->setDisabled(!$can_recurring)
	->setWorkflow(true));

	$can_attend = !$event->isImportedEvent();

	if ($is_attending) {
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Decline Event'))
	->setIcon('fa-user-times')
	->setHref($this->getApplicationURI("event/join/{$id}/"))
	->setDisabled(!$can_attend)
	->setWorkflow(true));
	} else {
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Join Event'))
	->setIcon('fa-user-plus')
	->setHref($this->getApplicationURI("event/join/{$id}/"))
	->setDisabled(!$can_attend)
	->setWorkflow(true));
	}

	$cancel_uri = $this->getApplicationURI("event/cancel/{$id}/");
	$cancel_disabled = !$can_edit;

	$cancel_label = pht('Cancel Event');
	$reinstate_label = pht('Reinstate Event');

	if ($event->getIsCancelled()) {
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName($reinstate_label)
	->setIcon('fa-plus')
	->setHref($cancel_uri)
	->setDisabled($cancel_disabled)
	->setWorkflow(true));
	} else {
	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName($cancel_label)
	->setIcon('fa-times')
	->setHref($cancel_uri)
	->setDisabled($cancel_disabled)
	->setWorkflow(true));
	}

	$ics_name = $event->getICSFilename();
	$export_uri = $this->getApplicationURI("event/export/{$id}/{$ics_name}");

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Export as .ics'))
	->setIcon('fa-download')
	->setHref($export_uri));

	return $curtain;
	}

	private function buildPropertySection(
	PhabricatorCalendarEvent $event) {
	$viewer = $this->getViewer();

	$properties = id(new PHUIPropertyListView())
	->setUser($viewer);

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

	if ($invitees) {
	$invitee_list = new PHUIStatusListView();

	$icon_invited = PHUIStatusItemView::ICON_OPEN;
	$icon_attending = PHUIStatusItemView::ICON_ACCEPT;
	$icon_declined = PHUIStatusItemView::ICON_REJECT;

	$status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	$status_attending = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
	$status_declined = PhabricatorCalendarEventInvitee::STATUS_DECLINED;

	$icon_map = array(
	$status_invited => $icon_invited,
	$status_attending => $icon_attending,
	$status_declined => $icon_declined,
	);

	$icon_color_map = array(
	$status_invited => null,
	$status_attending => 'green',
	$status_declined => 'red',
	);

	+ $viewer_phid = $viewer->getPHID();
	+ $is_rsvp_invited = $event->isRSVPInvited($viewer_phid);
	+ $type_user = PhabricatorPeopleUserPHIDType::TYPECONST;
	+
	+ $head = array();
	+ $tail = array();
	foreach ($invitees as $invitee) {
	$item = new PHUIStatusItemView();
	$invitee_phid = $invitee->getInviteePHID();
	$status = $invitee->getStatus();
	$target = $viewer->renderHandle($invitee_phid);
	- $icon = $icon_map[$status];
	- $icon_color = $icon_color_map[$status];
	+ $is_user = (phid_get_type($invitee_phid) == $type_user);
	+
	+ if (!$is_user) {
	+ $icon = 'fa-users';
	+ $icon_color = 'blue';
	+ } else {
	+ $icon = $icon_map[$status];
	+ $icon_color = $icon_color_map[$status];
	+ }
	+
	+ // Highlight invited groups which you're a member of if you have
	+ // not RSVP'd to an event yet.
	+ if ($is_rsvp_invited) {
	+ if ($invitee_phid != $viewer_phid) {
	+ if ($event->hasRSVPAuthority($viewer_phid, $invitee_phid)) {
	+ $item->setHighlighted(true);
	+ }
	+ }
	+ }

	$item->setIcon($icon, $icon_color)
	->setTarget($target);
	+
	+ if ($is_user) {
	+ $tail[] = $item;
	+ } else {
	+ $head[] = $item;
	+ }
	+ }
	+
	+ foreach (array_merge($head, $tail) as $item) {
	$invitee_list->addItem($item);
	}
	} else {
	$invitee_list = phutil_tag(
	'em',
	array(),
	pht('None'));
	}

	if ($event->isImportedEvent()) {
	$properties->addProperty(
	pht('Imported By'),
	pht(
	'%s from %s',
	$viewer->renderHandle($event->getImportAuthorPHID()),
	$viewer->renderHandle($event->getImportSourcePHID())));
	}

	$properties->addProperty(
	pht('Invitees'),
	$invitee_list);

	$properties->invokeWillRenderEvent();

	return $properties;
	}

	private function buildRecurringHeader(PhabricatorCalendarEvent $event) {
	$viewer = $this->getViewer();

	if (!$event->getIsRecurring()) {
	return null;
	}

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Recurring Event'));

	$sequence = $event->getSequenceIndex();
	if ($event->isParentEvent()) {
	$parent = $event;
	} else {
	$parent = $event->getParentEvent();
	}

	if ($parent->isValidSequenceIndex($viewer, $sequence + 1)) {
	$next_uri = $parent->getURI().'/'.($sequence + 1);
	$has_next = true;
	} else {
	$next_uri = null;
	$has_next = false;
	}

	if ($sequence) {
	if ($sequence > 1) {
	$previous_uri = $parent->getURI().'/'.($sequence - 1);
	} else {
	$previous_uri = $parent->getURI();
	}
	$has_previous = true;
	} else {
	$has_previous = false;
	$previous_uri = null;
	}

	$prev_button = id(new PHUIButtonView())
	->setTag('a')
	->setIcon('fa-chevron-left')
	->setHref($previous_uri)
	->setDisabled(!$has_previous)
	->setText(pht('Previous'));

	$next_button = id(new PHUIButtonView())
	->setTag('a')
	->setIcon('fa-chevron-right')
	->setHref($next_uri)
	->setDisabled(!$has_next)
	->setText(pht('Next'));

	$header
	->addActionLink($next_button)
	->addActionLink($prev_button);

	return $header;
	}

	private function buildRecurringSection(PhabricatorCalendarEvent $event) {
	$viewer = $this->getViewer();

	if (!$event->getIsRecurring()) {
	return null;
	}

	$properties = id(new PHUIPropertyListView())
	->setUser($viewer);

	$is_parent = $event->isParentEvent();
	if ($is_parent) {
	$parent_link = null;
	} else {
	$parent = $event->getParentEvent();
	$parent_link = $viewer
	->renderHandle($parent->getPHID())
	->render();
	}

	$rrule = $event->newRecurrenceRule();

	if ($rrule) {
	$frequency = $rrule->getFrequency();
	} else {
	$frequency = null;
	}

	switch ($frequency) {
	case PhutilCalendarRecurrenceRule::FREQUENCY_DAILY:
	if ($is_parent) {
	$message = pht('This event repeats every day.');
	} else {
	$message = pht(
	'This event is an instance of %s, and repeats every day.',
	$parent_link);
	}
	break;
	case PhutilCalendarRecurrenceRule::FREQUENCY_WEEKLY:
	if ($is_parent) {
	$message = pht('This event repeats every week.');
	} else {
	$message = pht(
	'This event is an instance of %s, and repeats every week.',
	$parent_link);
	}
	break;
	case PhutilCalendarRecurrenceRule::FREQUENCY_MONTHLY:
	if ($is_parent) {
	$message = pht('This event repeats every month.');
	} else {
	$message = pht(
	'This event is an instance of %s, and repeats every month.',
	$parent_link);
	}
	break;
	case PhutilCalendarRecurrenceRule::FREQUENCY_YEARLY:
	if ($is_parent) {
	$message = pht('This event repeats every year.');
	} else {
	$message = pht(
	'This event is an instance of %s, and repeats every year.',
	$parent_link);
	}
	break;
	}

	$properties->addProperty(pht('Event Series'), $message);

	return $properties;
	}

	private function buildDescriptionView(
	PhabricatorCalendarEvent $event) {
	$viewer = $this->getViewer();

	$properties = id(new PHUIPropertyListView())
	->setUser($viewer);

	if (strlen($event->getDescription())) {
	$description = new PHUIRemarkupView($viewer, $event->getDescription());
	$properties->addTextContent($description);
	return $properties;
	}

	return null;
	}

	private function loadEvent() {
	$request = $this->getRequest();
	$viewer = $this->getViewer();

	$id = $request->getURIData('id');
	$sequence = $request->getURIData('sequence');

	// We're going to figure out which event you're trying to look at. Most of
	// the time this is simple, but you may be looking at an instance of a
	// recurring event which we haven't generated an object for.

	// If you are, we're going to generate a "stub" event so we have a real
	// ID and PHID to work with, since the rest of the infrastructure relies
	// on these identifiers existing.

	// Load the event identified by ID first.
	$event = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withIDs(array($id))
	+ ->needRSVPs(array($viewer->getPHID()))
	->executeOne();
	if (!$event) {
	return null;
	}

	// If we aren't looking at an instance of this event, this is a completely
	// normal request and we can just return this event.
	if (!$sequence) {
	return $event;
	}

	// When you view "E123/999", E123 is normally the parent event. However,
	// you might visit a different instance first instead and then fiddle
	// with the URI. If the event we're looking at is a child, we are going
	// to act on the parent instead.
	if ($event->isChildEvent()) {
	$event = $event->getParentEvent();
	}

	// Try to load the instance. If it already exists, we're all done and
	// can just return it.
	$instance = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withInstanceSequencePairs(
	array(
	array($event->getPHID(), $sequence),
	))
	->executeOne();
	if ($instance) {
	return $instance;
	}

	if (!$viewer->isLoggedIn()) {
	throw new Exception(
	pht(
	'This event instance has not been created yet. Log in to create '.
	'it.'));
	}

	if (!$event->isValidSequenceIndex($viewer, $sequence)) {
	return null;
	}

	return $event->newStub($viewer, $sequence);
	}

	private function buildSubheaderView(PhabricatorCalendarEvent $event) {
	$viewer = $this->getViewer();

	$host_phid = $event->getHostPHID();

	$handles = $viewer->loadHandles(array($host_phid));
	$handle = $handles[$host_phid];

	$host = $viewer->renderHandle($host_phid);
	$host = phutil_tag('strong', array(), $host);

	$image_uri = $handles[$host_phid]->getImageURI();
	$image_href = $handles[$host_phid]->getURI();

	$date = $event->renderEventDate($viewer, true);

	$content = pht('Hosted by %s on %s.', $host, $date);

	return id(new PHUIHeadThingView())
	->setImage($image_uri)
	->setImageHref($image_href)
	->setContent($content);
	}


	private function buildRSVPActions(PhabricatorCalendarEvent $event) {
	$viewer = $this->getViewer();
	$id = $event->getID();

	- $invite_status = $event->getUserInviteStatus($viewer->getPHID());
	- $status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	- $is_invite_pending = ($invite_status == $status_invited);
	- if (!$is_invite_pending) {
	+ $is_pending = $event->isRSVPInvited($viewer->getPHID());
	+ if (!$is_pending) {
	return array();
	}

	$decline_button = id(new PHUIButtonView())
	->setTag('a')
	->setIcon('fa-times grey')
	->setHref($this->getApplicationURI("/event/decline/{$id}/"))
	->setWorkflow(true)
	->setText(pht('Decline'));

	$accept_button = id(new PHUIButtonView())
	->setTag('a')
	->setIcon('fa-check green')
	->setHref($this->getApplicationURI("/event/accept/{$id}/"))
	->setWorkflow(true)
	->setText(pht('Accept'));

	return array($decline_button, $accept_button);
	}

	}
	diff --git a/src/applications/calendar/policyrule/PhabricatorCalendarEventInviteesPolicyRule.php b/src/applications/calendar/policyrule/PhabricatorCalendarEventInviteesPolicyRule.php
	index 4e7b928901..93c92b828d 100644
	--- a/src/applications/calendar/policyrule/PhabricatorCalendarEventInviteesPolicyRule.php
	+++ b/src/applications/calendar/policyrule/PhabricatorCalendarEventInviteesPolicyRule.php
	@@ -1,104 +1,104 @@
	<?php

	final class PhabricatorCalendarEventInviteesPolicyRule
	extends PhabricatorPolicyRule {

	private $invited = array();
	private $sourcePHIDs = array();

	public function getObjectPolicyKey() {
	return 'calendar.event.invitees';
	}

	public function getObjectPolicyName() {
	return pht('Event Invitees');
	}

	public function getPolicyExplanation() {
	return pht('Users invited to this event can take this action.');
	}

	public function getRuleDescription() {
	return pht('event invitees');
	}

	public function canApplyToObject(PhabricatorPolicyInterface $object) {
	return ($object instanceof PhabricatorCalendarEvent);
	}

	public function willApplyRules(
	PhabricatorUser $viewer,
	array $values,
	array $objects) {

	$viewer_phid = $viewer->getPHID();
	if (!$viewer_phid) {
	return;
	}

	if (empty($this->invited[$viewer_phid])) {
	$this->invited[$viewer_phid] = array();
	}

	if (!isset($this->sourcePHIDs[$viewer_phid])) {
	$source_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$viewer_phid,
	- PhabricatorProjectMemberOfProjectEdgeType::EDGECONST);
	+ PhabricatorProjectMaterializedMemberEdgeType::EDGECONST);
	$source_phids[] = $viewer_phid;
	$this->sourcePHIDs[$viewer_phid] = $source_phids;
	}

	foreach ($objects as $key => $object) {
	$cache = $this->getTransactionHint($object);
	if ($cache === null) {
	// We don't have a hint for this object, so we'll deal with it below.
	continue;
	}

	// We have a hint, so use that as the source of truth.
	unset($objects[$key]);

	foreach ($this->sourcePHIDs[$viewer_phid] as $source_phid) {
	if (isset($cache[$source_phid])) {
	$this->invited[$viewer_phid][$object->getPHID()] = true;
	break;
	}
	}
	}

	$phids = mpull($objects, 'getPHID');
	if (!$phids) {
	return;
	}

	$invited = id(new PhabricatorCalendarEventInvitee())->loadAllWhere(
	'eventPHID IN (%Ls)
	AND inviteePHID IN (%Ls)
	AND status != %s',
	$phids,
	$this->sourcePHIDs[$viewer_phid],
	PhabricatorCalendarEventInvitee::STATUS_UNINVITED);
	$invited = mpull($invited, 'getEventPHID');

	$this->invited[$viewer_phid] += array_fill_keys($invited, true);
	}

	public function applyRule(
	PhabricatorUser $viewer,
	$value,
	PhabricatorPolicyInterface $object) {

	$viewer_phid = $viewer->getPHID();
	if (!$viewer_phid) {
	return false;
	}

	$invited = idx($this->invited, $viewer_phid);
	return isset($invited[$object->getPHID()]);
	}

	public function getValueControlType() {
	return self::CONTROL_TYPE_NONE;
	}

	}
	diff --git a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	index 0c762ffa54..a8d1ccdc1b 100644
	--- a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	+++ b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	@@ -1,684 +1,754 @@
	<?php

	final class PhabricatorCalendarEventQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $rangeBegin;
	private $rangeEnd;
	private $inviteePHIDs;
	private $hostPHIDs;
	private $isCancelled;
	private $eventsWithNoParent;
	private $instanceSequencePairs;
	private $isStub;
	private $parentEventPHIDs;
	private $importSourcePHIDs;
	private $importAuthorPHIDs;
	private $importUIDs;
	private $utcInitialEpochMin;
	private $utcInitialEpochMax;
	private $isImported;
	+ private $needRSVPs;

	private $generateGhosts = false;

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

	public function setGenerateGhosts($generate_ghosts) {
	$this->generateGhosts = $generate_ghosts;
	return $this;
	}

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

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

	public function withDateRange($begin, $end) {
	$this->rangeBegin = $begin;
	$this->rangeEnd = $end;
	return $this;
	}

	public function withUTCInitialEpochBetween($min, $max) {
	$this->utcInitialEpochMin = $min;
	$this->utcInitialEpochMax = $max;
	return $this;
	}

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

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

	public function withIsCancelled($is_cancelled) {
	$this->isCancelled = $is_cancelled;
	return $this;
	}

	public function withIsStub($is_stub) {
	$this->isStub = $is_stub;
	return $this;
	}

	public function withEventsWithNoParent($events_with_no_parent) {
	$this->eventsWithNoParent = $events_with_no_parent;
	return $this;
	}

	public function withInstanceSequencePairs(array $pairs) {
	$this->instanceSequencePairs = $pairs;
	return $this;
	}

	public function withParentEventPHIDs(array $parent_phids) {
	$this->parentEventPHIDs = $parent_phids;
	return $this;
	}

	public function withImportSourcePHIDs(array $import_phids) {
	$this->importSourcePHIDs = $import_phids;
	return $this;
	}

	public function withImportAuthorPHIDs(array $author_phids) {
	$this->importAuthorPHIDs = $author_phids;
	return $this;
	}

	public function withImportUIDs(array $uids) {
	$this->importUIDs = $uids;
	return $this;
	}

	public function withIsImported($is_imported) {
	$this->isImported = $is_imported;
	return $this;
	}

	+ public function needRSVPs(array $phids) {
	+ $this->needRSVPs = $phids;
	+ return $this;
	+ }
	+
	protected function getDefaultOrderVector() {
	return array('start', 'id');
	}

	public function getBuiltinOrders() {
	return array(
	'start' => array(
	'vector' => array('start', 'id'),
	'name' => pht('Event Start'),
	),
	) + parent::getBuiltinOrders();
	}

	public function getOrderableColumns() {
	return array(
	'start' => array(
	'table' => $this->getPrimaryTableAlias(),
	'column' => 'utcInitialEpoch',
	'reverse' => true,
	'type' => 'int',
	'unique' => false,
	),
	) + parent::getOrderableColumns();
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$event = $this->loadCursorObject($cursor);
	return array(
	'start' => $event->getStartDateTimeEpoch(),
	'id' => $event->getID(),
	);
	}

	protected function shouldLimitResults() {
	// When generating ghosts, we can't rely on database ordering because
	// MySQL can't predict the ghost start times. We'll just load all matching
	// events, then generate results from there.
	if ($this->generateGhosts) {
	return false;
	}

	return true;
	}

	protected function loadPage() {
	$events = $this->loadStandardPage($this->newResultObject());

	$viewer = $this->getViewer();
	foreach ($events as $event) {
	$event->applyViewerTimezone($viewer);
	}

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

	$raw_limit = $this->getRawResultLimit();

	if (!$raw_limit && !$this->rangeEnd) {
	throw new Exception(
	pht(
	'Event queries which generate ghost events must include either a '.
	'result limit or an end date, because they may otherwise generate '.
	'an infinite number of results. This query has neither.'));
	}

	foreach ($events as $key => $event) {
	$sequence_start = 0;
	$sequence_end = null;
	$end = null;

	$instance_of = $event->getInstanceOfEventPHID();

	if ($instance_of == null && $this->isCancelled !== null) {
	if ($event->getIsCancelled() != $this->isCancelled) {
	unset($events[$key]);
	continue;
	}
	}
	}

	// Pull out all of the parents first. We may discard them as we begin
	// generating ghost events, but we still want to process all of them.
	$parents = array();
	foreach ($events as $key => $event) {
	if ($event->isParentEvent()) {
	$parents[$key] = $event;
	}
	}

	// Now that we've picked out all the parent events, we can immediately
	// discard anything outside of the time window.
	$events = $this->getEventsInRange($events);

	$generate_from = $this->rangeBegin;
	$generate_until = $this->rangeEnd;
	foreach ($parents as $key => $event) {
	$duration = $event->getDuration();

	$start_date = $this->getRecurrenceWindowStart(
	$event,
	$generate_from - $duration);

	$end_date = $this->getRecurrenceWindowEnd(
	$event,
	$generate_until);

	$limit = $this->getRecurrenceLimit($event, $raw_limit);

	$set = $event->newRecurrenceSet();

	$recurrences = $set->getEventsBetween(
	null,
	$end_date,
	$limit + 1);

	// We're generating events from the beginning and then filtering them
	// here (instead of only generating events starting at the start date)
	// because we need to know the proper sequence indexes to generate ghost
	// events. This may change after RDATE support.
	if ($start_date) {
	$start_epoch = $start_date->getEpoch();
	} else {
	$start_epoch = null;
	}

	foreach ($recurrences as $sequence_index => $sequence_datetime) {
	if (!$sequence_index) {
	// This is the parent event, which we already have.
	continue;
	}

	if ($start_epoch) {
	if ($sequence_datetime->getEpoch() < $start_epoch) {
	continue;
	}
	}

	$events[] = $event->newGhost(
	$viewer,
	$sequence_index,
	$sequence_datetime);
	}

	// NOTE: We're slicing results every time because this makes it cheaper
	// to generate future ghosts. If we already have 100 events that occur
	// before July 1, we know we never need to generate ghosts after that
	// because they couldn't possibly ever appear in the result set.

	if ($raw_limit) {
	if (count($events) > $raw_limit) {
	$events = msort($events, 'getStartDateTimeEpoch');
	$events = array_slice($events, 0, $raw_limit, true);
	$generate_until = last($events)->getEndDateTimeEpoch();
	}
	}
	}

	// Now that we're done generating ghost events, we're going to remove any
	// ghosts that we have concrete events for (or which we can load the
	// concrete events for). These concrete events are generated when users
	// edit a ghost, and replace the ghost events.

	// First, generate a map of all concrete <parentPHID, sequence> events we
	// already loaded. We don't need to load these again.
	$have_pairs = array();
	foreach ($events as $event) {
	if ($event->getIsGhostEvent()) {
	continue;
	}

	$parent_phid = $event->getInstanceOfEventPHID();
	$sequence = $event->getSequenceIndex();

	$have_pairs[$parent_phid][$sequence] = true;
	}

	// Now, generate a map of all <parentPHID, sequence> events we generated
	// ghosts for. We need to try to load these if we don't already have them.
	$map = array();
	$parent_pairs = array();
	foreach ($events as $key => $event) {
	if (!$event->getIsGhostEvent()) {
	continue;
	}

	$parent_phid = $event->getInstanceOfEventPHID();
	$sequence = $event->getSequenceIndex();

	// We already loaded the concrete version of this event, so we can just
	// throw out the ghost and move on.
	if (isset($have_pairs[$parent_phid][$sequence])) {
	unset($events[$key]);
	continue;
	}

	// We didn't load the concrete version of this event, so we need to
	// try to load it if it exists.
	$parent_pairs[] = array($parent_phid, $sequence);
	$map[$parent_phid][$sequence] = $key;
	}

	if ($parent_pairs) {
	$instances = id(new self())
	->setViewer($viewer)
	->setParentQuery($this)
	->withInstanceSequencePairs($parent_pairs)
	->execute();

	foreach ($instances as $instance) {
	$parent_phid = $instance->getInstanceOfEventPHID();
	$sequence = $instance->getSequenceIndex();

	$indexes = idx($map, $parent_phid);
	$key = idx($indexes, $sequence);

	// Replace the ghost with the corresponding concrete event.
	$events[$key] = $instance;
	}
	}

	$events = msort($events, 'getStartDateTimeEpoch');

	return $events;
	}

	protected function buildJoinClauseParts(AphrontDatabaseConnection $conn_r) {
	$parts = parent::buildJoinClauseParts($conn_r);

	if ($this->inviteePHIDs !== null) {
	$parts[] = qsprintf(
	$conn_r,
	'JOIN %T invitee ON invitee.eventPHID = event.phid
	AND invitee.status != %s',
	id(new PhabricatorCalendarEventInvitee())->getTableName(),
	PhabricatorCalendarEventInvitee::STATUS_UNINVITED);
	}

	return $parts;
	}

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

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

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

	// NOTE: The date ranges we query for are larger than the requested ranges
	// because we need to catch all-day events. We'll refine this range later
	// after adjusting the visible range of events we load.

	if ($this->rangeBegin) {
	$where[] = qsprintf(
	$conn,
	'(event.utcUntilEpoch >= %d) OR (event.utcUntilEpoch IS NULL)',
	$this->rangeBegin - phutil_units('16 hours in seconds'));
	}

	if ($this->rangeEnd) {
	$where[] = qsprintf(
	$conn,
	'event.utcInitialEpoch <= %d',
	$this->rangeEnd + phutil_units('16 hours in seconds'));
	}

	if ($this->utcInitialEpochMin !== null) {
	$where[] = qsprintf(
	$conn,
	'event.utcInitialEpoch >= %d',
	$this->utcInitialEpochMin);
	}

	if ($this->utcInitialEpochMax !== null) {
	$where[] = qsprintf(
	$conn,
	'event.utcInitialEpoch <= %d',
	$this->utcInitialEpochMax);
	}

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

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

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

	if ($this->eventsWithNoParent == true) {
	$where[] = qsprintf(
	$conn,
	'event.instanceOfEventPHID IS NULL');
	}

	if ($this->instanceSequencePairs !== null) {
	$sql = array();

	foreach ($this->instanceSequencePairs as $pair) {
	$sql[] = qsprintf(
	$conn,
	'(event.instanceOfEventPHID = %s AND event.sequenceIndex = %d)',
	$pair[0],
	$pair[1]);
	}

	$where[] = qsprintf(
	$conn,
	'%Q',
	implode(' OR ', $sql));
	}

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

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

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

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

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

	if ($this->isImported !== null) {
	if ($this->isImported) {
	$where[] = qsprintf(
	$conn,
	'event.importSourcePHID IS NOT NULL');
	} else {
	$where[] = qsprintf(
	$conn,
	'event.importSourcePHID IS NULL');
	}
	}

	return $where;
	}

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

	protected function shouldGroupQueryResultRows() {
	if ($this->inviteePHIDs !== null) {
	return true;
	}
	return parent::shouldGroupQueryResultRows();
	}

	protected function getApplicationSearchObjectPHIDColumn() {
	return 'event.phid';
	}

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


	protected function willFilterPage(array $events) {
	$instance_of_event_phids = array();
	$recurring_events = array();
	$viewer = $this->getViewer();

	$events = $this->getEventsInRange($events);

	$import_phids = array();
	foreach ($events as $event) {
	$import_phid = $event->getImportSourcePHID();
	if ($import_phid !== null) {
	$import_phids[$import_phid] = $import_phid;
	}
	}

	if ($import_phids) {
	$imports = id(new PhabricatorCalendarImportQuery())
	->setParentQuery($this)
	->setViewer($viewer)
	->withPHIDs($import_phids)
	->execute();
	$imports = mpull($imports, null, 'getPHID');
	} else {
	$imports = array();
	}

	foreach ($events as $key => $event) {
	$import_phid = $event->getImportSourcePHID();
	if ($import_phid === null) {
	$event->attachImportSource(null);
	continue;
	}

	$import = idx($imports, $import_phid);
	if (!$import) {
	unset($events[$key]);
	$this->didRejectResult($event);
	continue;
	}

	$event->attachImportSource($import);
	}

	$phids = array();

	foreach ($events as $event) {
	$phids[] = $event->getPHID();
	$instance_of = $event->getInstanceOfEventPHID();

	if ($instance_of) {
	$instance_of_event_phids[] = $instance_of;
	}
	}

	if (count($instance_of_event_phids) > 0) {
	$recurring_events = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withPHIDs($instance_of_event_phids)
	->withEventsWithNoParent(true)
	->execute();

	$recurring_events = mpull($recurring_events, null, 'getPHID');
	}

	if ($events) {
	$invitees = id(new PhabricatorCalendarEventInviteeQuery())
	->setViewer($viewer)
	->withEventPHIDs($phids)
	->execute();
	$invitees = mgroup($invitees, 'getEventPHID');
	} else {
	$invitees = array();
	}

	foreach ($events as $key => $event) {
	$event_invitees = idx($invitees, $event->getPHID(), array());
	$event->attachInvitees($event_invitees);

	$instance_of = $event->getInstanceOfEventPHID();
	if (!$instance_of) {
	continue;
	}
	$parent = idx($recurring_events, $instance_of);

	// should never get here
	if (!$parent) {
	unset($events[$key]);
	continue;
	}
	$event->attachParentEvent($parent);

	if ($this->isCancelled !== null) {
	if ($event->getIsCancelled() != $this->isCancelled) {
	unset($events[$key]);
	continue;
	}
	}
	}

	$events = msort($events, 'getStartDateTimeEpoch');

	+ if ($this->needRSVPs) {
	+ $rsvp_phids = $this->needRSVPs;
	+ $project_type = PhabricatorProjectProjectPHIDType::TYPECONST;
	+
	+ $project_phids = array();
	+ foreach ($events as $event) {
	+ foreach ($event->getInvitees() as $invitee) {
	+ $invitee_phid = $invitee->getInviteePHID();
	+ if (phid_get_type($invitee_phid) == $project_type) {
	+ $project_phids[] = $invitee_phid;
	+ }
	+ }
	+ }
	+
	+ if ($project_phids) {
	+ $member_type = PhabricatorProjectMaterializedMemberEdgeType::EDGECONST;
	+
	+ $query = id(new PhabricatorEdgeQuery())
	+ ->withSourcePHIDs($project_phids)
	+ ->withEdgeTypes(array($member_type))
	+ ->withDestinationPHIDs($rsvp_phids);
	+
	+ $edges = $query->execute();
	+
	+ $project_map = array();
	+ foreach ($edges as $src => $types) {
	+ foreach ($types as $type => $dsts) {
	+ foreach ($dsts as $dst => $edge) {
	+ $project_map[$dst][] = $src;
	+ }
	+ }
	+ }
	+ } else {
	+ $project_map = array();
	+ }
	+
	+ $membership_map = array();
	+ foreach ($rsvp_phids as $rsvp_phid) {
	+ $membership_map[$rsvp_phid] = array();
	+ $membership_map[$rsvp_phid][] = $rsvp_phid;
	+
	+ $project_phids = idx($project_map, $rsvp_phid);
	+ if ($project_phids) {
	+ foreach ($project_phids as $project_phid) {
	+ $membership_map[$rsvp_phid][] = $project_phid;
	+ }
	+ }
	+ }
	+
	+ foreach ($events as $event) {
	+ $invitees = $event->getInvitees();
	+ $invitees = mpull($invitees, null, 'getInviteePHID');
	+
	+ $rsvp_map = array();
	+ foreach ($rsvp_phids as $rsvp_phid) {
	+ $membership_phids = $membership_map[$rsvp_phid];
	+ $rsvps = array_select_keys($invitees, $membership_phids);
	+ $rsvp_map[$rsvp_phid] = $rsvps;
	+ }
	+
	+ $event->attachRSVPs($rsvp_map);
	+ }
	+ }
	+
	return $events;
	}

	private function getEventsInRange(array $events) {
	$range_start = $this->rangeBegin;
	$range_end = $this->rangeEnd;

	foreach ($events as $key => $event) {
	$event_start = $event->getStartDateTimeEpoch();
	$event_end = $event->getEndDateTimeEpoch();

	if ($range_start && $event_end < $range_start) {
	unset($events[$key]);
	}

	if ($range_end && $event_start > $range_end) {
	unset($events[$key]);
	}
	}

	return $events;
	}

	private function getRecurrenceWindowStart(
	PhabricatorCalendarEvent $event,
	$generate_from) {

	if (!$generate_from) {
	return null;
	}

	return PhutilCalendarAbsoluteDateTime::newFromEpoch($generate_from);
	}

	private function getRecurrenceWindowEnd(
	PhabricatorCalendarEvent $event,
	$generate_until) {

	$end_epochs = array();
	if ($generate_until) {
	$end_epochs[] = $generate_until;
	}

	$until_epoch = $event->getUntilDateTimeEpoch();
	if ($until_epoch) {
	$end_epochs[] = $until_epoch;
	}

	if (!$end_epochs) {
	return null;
	}

	return PhutilCalendarAbsoluteDateTime::newFromEpoch(min($end_epochs));
	}

	private function getRecurrenceLimit(
	PhabricatorCalendarEvent $event,
	$raw_limit) {

	$count = $event->getRecurrenceCount();
	if ($count && ($count <= $raw_limit)) {
	return ($count - 1);
	}

	return $raw_limit;
	}

	}
	diff --git a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	index 94534b54ab..5de1d5c3d2 100644
	--- a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	+++ b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	@@ -1,618 +1,621 @@
	<?php

	final class PhabricatorCalendarEventSearchEngine
	extends PhabricatorApplicationSearchEngine {

	private $calendarYear;
	private $calendarMonth;
	private $calendarDay;

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

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

	public function newQuery() {
	- return new PhabricatorCalendarEventQuery();
	+ $viewer = $this->requireViewer();
	+
	+ return id(new PhabricatorCalendarEventQuery())
	+ ->needRSVPs(array($viewer->getPHID()));
	}

	protected function shouldShowOrderField() {
	return false;
	}

	protected function buildCustomSearchFields() {
	return array(
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Hosts'))
	->setKey('hostPHIDs')
	->setAliases(array('host', 'hostPHID', 'hosts'))
	->setDatasource(new PhabricatorPeopleUserFunctionDatasource()),
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Invited'))
	->setKey('invitedPHIDs')
	->setDatasource(new PhabricatorPeopleUserFunctionDatasource()),
	id(new PhabricatorSearchDateControlField())
	->setLabel(pht('Occurs After'))
	->setKey('rangeStart'),
	id(new PhabricatorSearchDateControlField())
	->setLabel(pht('Occurs Before'))
	->setKey('rangeEnd')
	->setAliases(array('rangeEnd')),
	id(new PhabricatorSearchCheckboxesField())
	->setKey('upcoming')
	->setOptions(array(
	'upcoming' => pht('Show only upcoming events.'),
	)),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Cancelled Events'))
	->setKey('isCancelled')
	->setOptions($this->getCancelledOptions())
	->setDefault('active'),
	id(new PhabricatorPHIDsSearchField())
	->setLabel(pht('Import Sources'))
	->setKey('importSourcePHIDs')
	->setAliases(array('importSourcePHID')),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Display Options'))
	->setKey('display')
	->setOptions($this->getViewOptions())
	->setDefault('month'),
	);
	}

	private function getCancelledOptions() {
	return array(
	'active' => pht('Active Events Only'),
	'cancelled' => pht('Cancelled Events Only'),
	'both' => pht('Both Cancelled and Active Events'),
	);
	}

	private function getViewOptions() {
	return array(
	'month' => pht('Month View'),
	'day' => pht('Day View'),
	'list' => pht('List View'),
	);
	}

	protected function buildQueryFromParameters(array $map) {
	$query = $this->newQuery();
	$viewer = $this->requireViewer();

	if ($map['hostPHIDs']) {
	$query->withHostPHIDs($map['hostPHIDs']);
	}

	if ($map['invitedPHIDs']) {
	$query->withInvitedPHIDs($map['invitedPHIDs']);
	}

	$range_start = $map['rangeStart'];
	$range_end = $map['rangeEnd'];
	$display = $map['display'];

	if ($map['upcoming'] && $map['upcoming'][0] == 'upcoming') {
	$upcoming = true;
	} else {
	$upcoming = false;
	}

	list($range_start, $range_end) = $this->getQueryDateRange(
	$range_start,
	$range_end,
	$display,
	$upcoming);

	$query->withDateRange($range_start, $range_end);

	switch ($map['isCancelled']) {
	case 'active':
	$query->withIsCancelled(false);
	break;
	case 'cancelled':
	$query->withIsCancelled(true);
	break;
	}

	if ($map['importSourcePHIDs']) {
	$query->withImportSourcePHIDs($map['importSourcePHIDs']);
	}

	// Generate ghosts (and ignore stub events) if we aren't querying for
	// specific events or exporting.
	if (!empty($map['export'])) {
	// This is a specific mode enabled by event exports.
	$query
	->withIsStub(false);
	} else if (!$map['ids'] && !$map['phids']) {
	$query
	->withIsStub(false)
	->setGenerateGhosts(true);
	}

	return $query;
	}

	private function getQueryDateRange(
	$start_date_wild,
	$end_date_wild,
	$display,
	$upcoming) {

	$start_date_value = $this->getSafeDate($start_date_wild);
	$end_date_value = $this->getSafeDate($end_date_wild);

	$viewer = $this->requireViewer();
	$timezone = new DateTimeZone($viewer->getTimezoneIdentifier());
	$min_range = null;
	$max_range = null;

	$min_range = $start_date_value->getEpoch();
	$max_range = $end_date_value->getEpoch();

	if ($display == 'month' \|\| $display == 'day') {
	list($start_year, $start_month, $start_day) =
	$this->getDisplayYearAndMonthAndDay($min_range, $max_range, $display);

	$start_day = new DateTime(
	"{$start_year}-{$start_month}-{$start_day}",
	$timezone);
	$next = clone $start_day;

	if ($display == 'month') {
	$next->modify('+1 month');
	} else if ($display == 'day') {
	$next->modify('+7 day');
	}

	$display_start = $start_day->format('U');
	$display_end = $next->format('U');

	$start_of_week = $viewer->getUserSetting(
	PhabricatorWeekStartDaySetting::SETTINGKEY);

	$end_of_week = ($start_of_week + 6) % 7;

	$first_of_month = $start_day->format('w');
	$last_of_month = id(clone $next)->modify('-1 day')->format('w');

	if (!$min_range \|\| ($min_range < $display_start)) {
	$min_range = $display_start;

	if ($display == 'month' &&
	$first_of_month !== $start_of_week) {
	$interim_day_num = ($first_of_month + 7 - $start_of_week) % 7;
	$min_range = id(clone $start_day)
	->modify('-'.$interim_day_num.' days')
	->format('U');
	}
	}
	if (!$max_range \|\| ($max_range > $display_end)) {
	$max_range = $display_end;

	if ($display == 'month' &&
	$last_of_month !== $end_of_week) {
	$interim_day_num = ($end_of_week + 7 - $last_of_month) % 7;
	$max_range = id(clone $next)
	->modify('+'.$interim_day_num.' days')
	->format('U');
	}
	}
	}

	if ($upcoming) {
	$now = PhabricatorTime::getNow();
	if ($min_range) {
	$min_range = max($now, $min_range);
	} else {
	$min_range = $now;
	}
	}

	return array($min_range, $max_range);
	}

	protected function getURI($path) {
	return '/calendar/'.$path;
	}

	protected function getBuiltinQueryNames() {
	$names = array(
	'month' => pht('Month View'),
	'day' => pht('Day View'),
	'upcoming' => pht('Upcoming Events'),
	'all' => pht('All Events'),
	);

	return $names;
	}

	public function setCalendarYearAndMonthAndDay($year, $month, $day = null) {
	$this->calendarYear = $year;
	$this->calendarMonth = $month;
	$this->calendarDay = $day;

	return $this;
	}

	public function buildSavedQueryFromBuiltin($query_key) {
	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	switch ($query_key) {
	case 'month':
	return $query->setParameter('display', 'month');
	case 'day':
	return $query->setParameter('display', 'day');
	case 'upcoming':
	return $query
	->setParameter('display', 'list')
	->setParameter('upcoming', array(
	0 => 'upcoming',
	));
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	protected function renderResultList(
	array $events,
	PhabricatorSavedQuery $query,
	array $handles) {

	if ($this->isMonthView($query)) {
	$result = $this->buildCalendarMonthView($events, $query);
	} else if ($this->isDayView($query)) {
	$result = $this->buildCalendarDayView($events, $query);
	} else {
	$result = $this->buildCalendarListView($events, $query);
	}

	return $result;
	}

	private function buildCalendarListView(
	array $events,
	PhabricatorSavedQuery $query) {

	assert_instances_of($events, 'PhabricatorCalendarEvent');
	$viewer = $this->requireViewer();
	$list = new PHUIObjectItemListView();

	foreach ($events as $event) {
	if ($event->getIsGhostEvent()) {
	$monogram = $event->getParentEvent()->getMonogram();
	$index = $event->getSequenceIndex();
	$monogram = "{$monogram}/{$index}";
	} else {
	$monogram = $event->getMonogram();
	}

	$item = id(new PHUIObjectItemView())
	->setUser($viewer)
	->setObject($event)
	->setObjectName($monogram)
	->setHeader($event->getName())
	->setHref($event->getURI());

	$item->addAttribute($event->renderEventDate($viewer, false));

	if ($event->getIsCancelled()) {
	$item->setDisabled(true);
	}

	$status_icon = $event->getDisplayIcon($viewer);
	$status_color = $event->getDisplayIconColor($viewer);
	$status_label = $event->getDisplayIconLabel($viewer);

	$item->setStatusIcon("{$status_icon} {$status_color}", $status_label);

	$host = pht(
	'Hosted by %s',
	$viewer->renderHandle($event->getHostPHID()));
	$item->addByline($host);

	$list->addItem($item);
	}

	return $this->newResultView()
	->setObjectList($list)
	->setNoDataString(pht('No events found.'));
	}

	private function buildCalendarMonthView(
	array $events,
	PhabricatorSavedQuery $query) {
	assert_instances_of($events, 'PhabricatorCalendarEvent');

	$viewer = $this->requireViewer();
	$now = PhabricatorTime::getNow();

	list($start_year, $start_month) =
	$this->getDisplayYearAndMonthAndDay(
	$this->getQueryDateFrom($query)->getEpoch(),
	$this->getQueryDateTo($query)->getEpoch(),
	$query->getParameter('display'));

	$now_year = phabricator_format_local_time($now, $viewer, 'Y');
	$now_month = phabricator_format_local_time($now, $viewer, 'm');
	$now_day = phabricator_format_local_time($now, $viewer, 'j');

	if ($start_month == $now_month && $start_year == $now_year) {
	$month_view = new PHUICalendarMonthView(
	$this->getQueryDateFrom($query),
	$this->getQueryDateTo($query),
	$start_month,
	$start_year,
	$now_day);
	} else {
	$month_view = new PHUICalendarMonthView(
	$this->getQueryDateFrom($query),
	$this->getQueryDateTo($query),
	$start_month,
	$start_year);
	}

	$month_view->setUser($viewer);

	foreach ($events as $event) {
	$epoch_min = $event->getStartDateTimeEpoch();
	$epoch_max = $event->getEndDateTimeEpoch();

	$event_view = id(new AphrontCalendarEventView())
	->setHostPHID($event->getHostPHID())
	->setEpochRange($epoch_min, $epoch_max)
	->setIsCancelled($event->getIsCancelled())
	->setName($event->getName())
	->setURI($event->getURI())
	->setIsAllDay($event->getIsAllDay())
	->setIcon($event->getDisplayIcon($viewer))
	->setViewerIsInvited($event->getIsUserInvited($viewer->getPHID()))
	->setIconColor($event->getDisplayIconColor($viewer));

	$month_view->addEvent($event_view);
	}

	$month_view->setBrowseURI(
	$this->getURI('query/'.$query->getQueryKey().'/'));

	$from = $this->getQueryDateFrom($query)->getDateTime();

	$crumbs = array();
	$crumbs[] = id(new PHUICrumbView())
	->setName($from->format('F Y'));

	$header = id(new PHUIHeaderView())
	->setProfileHeader(true)
	->setHeader($from->format('F Y'));

	return $this->newResultView($month_view)
	->setCrumbs($crumbs)
	->setHeader($header);
	}

	private function buildCalendarDayView(
	array $events,
	PhabricatorSavedQuery $query) {

	$viewer = $this->requireViewer();

	list($start_year, $start_month, $start_day) =
	$this->getDisplayYearAndMonthAndDay(
	$this->getQueryDateFrom($query)->getEpoch(),
	$this->getQueryDateTo($query)->getEpoch(),
	$query->getParameter('display'));

	$day_view = id(new PHUICalendarDayView(
	$this->getQueryDateFrom($query),
	$this->getQueryDateTo($query),
	$start_year,
	$start_month,
	$start_day))
	->setQuery($query->getQueryKey());

	$day_view->setUser($viewer);

	$phids = mpull($events, 'getHostPHID');

	foreach ($events as $event) {
	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$event,
	PhabricatorPolicyCapability::CAN_EDIT);

	$epoch_min = $event->getStartDateTimeEpoch();
	$epoch_max = $event->getEndDateTimeEpoch();

	$status_icon = $event->getDisplayIcon($viewer);
	$status_color = $event->getDisplayIconColor($viewer);

	$event_view = id(new AphrontCalendarEventView())
	->setCanEdit($can_edit)
	->setEventID($event->getID())
	->setEpochRange($epoch_min, $epoch_max)
	->setIsAllDay($event->getIsAllDay())
	->setIcon($status_icon)
	->setIconColor($status_color)
	->setName($event->getName())
	->setURI($event->getURI())
	->setIsCancelled($event->getIsCancelled());

	$day_view->addEvent($event_view);
	}

	$browse_uri = $this->getURI('query/'.$query->getQueryKey().'/');
	$day_view->setBrowseURI($browse_uri);

	$from = $this->getQueryDateFrom($query)->getDateTime();
	$month_uri = $browse_uri.$from->format('Y/m/');

	$crumbs = array(
	id(new PHUICrumbView())
	->setName($from->format('F Y'))
	->setHref($month_uri),
	id(new PHUICrumbView())
	->setName($from->format('D jS')),
	);

	$header = id(new PHUIHeaderView())
	->setProfileHeader(true)
	->setHeader($from->format('D, F jS'));

	return $this->newResultView($day_view)
	->setCrumbs($crumbs)
	->setHeader($header);
	}

	private function getDisplayYearAndMonthAndDay(
	$range_start,
	$range_end,
	$display) {

	$viewer = $this->requireViewer();
	$epoch = null;

	if ($this->calendarYear && $this->calendarMonth) {
	$start_year = $this->calendarYear;
	$start_month = $this->calendarMonth;
	$start_day = $this->calendarDay ? $this->calendarDay : 1;
	} else {
	if ($range_start) {
	$epoch = $range_start;
	} else if ($range_end) {
	$epoch = $range_end;
	} else {
	$epoch = time();
	}
	if ($display == 'month') {
	$day = 1;
	} else {
	$day = phabricator_format_local_time($epoch, $viewer, 'd');
	}
	$start_year = phabricator_format_local_time($epoch, $viewer, 'Y');
	$start_month = phabricator_format_local_time($epoch, $viewer, 'm');
	$start_day = $day;
	}
	return array($start_year, $start_month, $start_day);
	}

	public function getPageSize(PhabricatorSavedQuery $saved) {
	if ($this->isMonthView($saved) \|\| $this->isDayView($saved)) {
	return $saved->getParameter('limit', 1000);
	} else {
	return $saved->getParameter('limit', 100);
	}
	}

	private function getQueryDateFrom(PhabricatorSavedQuery $saved) {
	if ($this->calendarYear && $this->calendarMonth) {
	$viewer = $this->requireViewer();

	$start_year = $this->calendarYear;
	$start_month = $this->calendarMonth;
	$start_day = $this->calendarDay ? $this->calendarDay : 1;

	return AphrontFormDateControlValue::newFromDictionary(
	$viewer,
	array(
	'd' => "{$start_year}-{$start_month}-{$start_day}",
	));
	}

	return $this->getQueryDate($saved, 'rangeStart');
	}

	private function getQueryDateTo(PhabricatorSavedQuery $saved) {
	return $this->getQueryDate($saved, 'rangeEnd');
	}

	private function getQueryDate(PhabricatorSavedQuery $saved, $key) {
	$viewer = $this->requireViewer();

	$wild = $saved->getParameter($key);
	return $this->getSafeDate($wild);
	}

	private function getSafeDate($value) {
	$viewer = $this->requireViewer();
	if ($value) {
	// ideally this would be consistent and always pass in the same type
	if ($value instanceof AphrontFormDateControlValue) {
	return $value;
	} else {
	$value = AphrontFormDateControlValue::newFromWild($viewer, $value);
	}
	} else {
	$value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	PhabricatorTime::getTodayMidnightDateTime($viewer)->format('U'));
	$value->setEnabled(false);
	}

	$value->setOptional(true);

	return $value;
	}

	private function isMonthView(PhabricatorSavedQuery $query) {
	if ($this->isDayView($query)) {
	return false;
	}
	if ($query->getParameter('display') == 'month') {
	return true;
	}
	}

	private function isDayView(PhabricatorSavedQuery $query) {
	if ($query->getParameter('display') == 'day') {
	return true;
	}
	if ($this->calendarDay) {
	return true;
	}

	return false;
	}

	public function newUseResultsActions(PhabricatorSavedQuery $saved) {
	$viewer = $this->requireViewer();
	$can_export = $viewer->isLoggedIn();

	return array(
	id(new PhabricatorActionView())
	->setIcon('fa-download')
	->setName(pht('Export Query as .ics'))
	->setDisabled(!$can_export)
	->setHref('/calendar/export/edit/?queryKey='.$saved->getQueryKey()),
	);
	}


	private function newResultView($content = null) {
	// If we aren't rendering a dashboard panel, activate global drag-and-drop
	// so you can import ".ics" files by dropping them directly onto the
	// calendar.
	if (!$this->isPanelContext()) {
	$drop_upload = id(new PhabricatorGlobalUploadTargetView())
	->setViewer($this->requireViewer())
	->setHintText("\xE2\x87\xAA ".pht('Drop .ics Files to Import'))
	->setSubmitURI('/calendar/import/drop/')
	->setViewPolicy(PhabricatorPolicies::POLICY_NOONE);

	$content = array(
	$drop_upload,
	$content,
	);
	}

	return id(new PhabricatorApplicationSearchResultView())
	->setContent($content);
	}

	}
	diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	index 6acd90b3f2..ca41fc8cf1 100644
	--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	@@ -1,1380 +1,1437 @@
	<?php

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

	protected $name;
	protected $hostPHID;
	protected $description;
	protected $isCancelled;
	protected $isAllDay;
	protected $icon;
	protected $mailKey;
	protected $isStub;

	protected $isRecurring = 0;

	protected $seriesParentPHID;
	protected $instanceOfEventPHID;
	protected $sequenceIndex;

	protected $viewPolicy;
	protected $editPolicy;

	protected $spacePHID;

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

	protected $importAuthorPHID;
	protected $importSourcePHID;
	protected $importUIDIndex;
	protected $importUID;

	private $parentEvent = self::ATTACHABLE;
	private $invitees = self::ATTACHABLE;
	private $importSource = self::ATTACHABLE;
	+ private $rsvps = self::ATTACHABLE;

	private $viewerTimezone;

	private $isGhostEvent = false;
	private $stubInvitees;

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

	$default_icon = 'fa-calendar';

	$datetime_defaults = self::newDefaultEventDateTimes(
	$actor,
	$now);
	list($datetime_start, $datetime_end) = $datetime_defaults;

	// When importing events from a context like "bin/calendar reload", we may
	// be acting as the omnipotent user.
	$host_phid = $actor->getPHID();
	if (!$host_phid) {
	$host_phid = $app->getPHID();
	}

	return id(new PhabricatorCalendarEvent())
	->setDescription('')
	->setHostPHID($host_phid)
	->setIsCancelled(0)
	->setIsAllDay(0)
	->setIsStub(0)
	->setIsRecurring(0)
	->setIcon($default_icon)
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setSpacePHID($actor->getDefaultSpacePHID())
	->attachInvitees(array())
	->setStartDateTime($datetime_start)
	->setEndDateTime($datetime_end)
	->attachImportSource(null)
	->applyViewerTimezone($actor);
	}

	public static function newDefaultEventDateTimes(
	PhabricatorUser $viewer,
	$now) {

	$datetime_start = PhutilCalendarAbsoluteDateTime::newFromEpoch(
	$now,
	$viewer->getTimezoneIdentifier());

	// Advance the time by an hour, then round downwards to the nearest hour.
	// For example, if it is currently 3:25 PM, we suggest a default start time
	// of 4 PM.
	$datetime_start = $datetime_start
	->newRelativeDateTime('PT1H')
	->newAbsoluteDateTime();
	$datetime_start->setMinute(0);
	$datetime_start->setSecond(0);

	// Default the end time to an hour after the start time.
	$datetime_end = $datetime_start
	->newRelativeDateTime('PT1H')
	->newAbsoluteDateTime();

	return array($datetime_start, $datetime_end);
	}

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

	$series_phid = $this->getSeriesParentPHID();
	if (!$series_phid) {
	$series_phid = $this->getPHID();
	}

	$child = id(new self())
	->setIsCancelled(0)
	->setIsStub(0)
	->setInstanceOfEventPHID($this->getPHID())
	->setSeriesParentPHID($series_phid)
	->setSequenceIndex($sequence)
	->setIsRecurring(true)
	->attachParentEvent($this)
	->attachImportSource(null);

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

	protected function readField($field) {
	static $inherit = array(
	'hostPHID' => true,
	'isAllDay' => true,
	'icon' => true,
	'spacePHID' => true,
	'viewPolicy' => true,
	'editPolicy' => true,
	'name' => true,
	'description' => true,
	'isCancelled' => 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,
	PhutilCalendarDateTime $start = null) {

	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())
	->setIsCancelled($parent->getIsCancelled());

	if ($start) {
	$start_datetime = $start;
	} else {
	$sequence = $this->getSequenceIndex();
	$start_datetime = $parent->newSequenceIndexDateTime($sequence);

	if (!$start_datetime) {
	throw new Exception(
	pht(
	'Sequence "%s" is not valid for event!',
	$sequence));
	}
	}

	$duration = $parent->newDuration();
	$end_datetime = $start_datetime->newRelativeDateTime($duration);

	$this
	->setStartDateTime($start_datetime)
	->setEndDateTime($end_datetime);

	if ($parent->isImportedEvent()) {
	$full_uid = $parent->getImportUID().'/'.$start_datetime->getEpoch();

	// NOTE: We don't attach the import source because this gets called
	// from CalendarEventQuery while building ghosts, before we've loaded
	// and attached sources. Possibly this sequence should be flipped.

	$this
	->setImportAuthorPHID($parent->getImportAuthorPHID())
	->setImportSourcePHID($parent->getImportSourcePHID())
	->setImportUID($full_uid);
	}

	return $this;
	}

	public function isValidSequenceIndex(PhabricatorUser $viewer, $sequence) {
	return (bool)$this->newSequenceIndexDateTime($sequence);
	}

	public function newSequenceIndexDateTime($sequence) {
	$set = $this->newRecurrenceSet();
	if (!$set) {
	return null;
	}

	$limit = $sequence + 1;
	$count = $this->getRecurrenceCount();
	if ($count && ($count < $limit)) {
	return null;
	}

	$instances = $set->getEventsBetween(
	null,
	$this->newUntilDateTime(),
	$limit);

	return idx($instances, $sequence, null);
	}

	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,
	PhutilCalendarDateTime $start = null) {

	$ghost = $this->newChild($actor, $sequence, $start);

	$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->getEndDateTimeEpoch() - $this->getStartDateTimeEpoch());
	}

	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();
	if ($until_date) {
	$until_date->setViewerTimezone('UTC');
	$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);
	}

	$import_uid = $this->getImportUID();
	if ($import_uid !== null) {
	$index = PhabricatorHash::digestForIndex($import_uid);
	} else {
	$index = null;
	}
	$this->setImportUIDIndex($index);

	$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 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',
	'description' => 'text',
	'isCancelled' => 'bool',
	'isAllDay' => 'bool',
	'icon' => 'text32',
	'mailKey' => 'bytes20',
	'isRecurring' => 'bool',
	'seriesParentPHID' => 'phid?',
	'instanceOfEventPHID' => 'phid?',
	'sequenceIndex' => 'uint32?',
	'isStub' => 'bool',
	'utcInitialEpoch' => 'epoch',
	'utcUntilEpoch' => 'epoch?',
	'utcInstanceEpoch' => 'epoch?',

	'importAuthorPHID' => 'phid?',
	'importSourcePHID' => 'phid?',
	'importUIDIndex' => 'bytes12?',
	'importUID' => 'text?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'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,
	),
	'key_series' => array(
	'columns' => array('seriesParentPHID', 'utcInitialEpoch'),
	),
	),
	self::CONFIG_SERIALIZATION => array(
	'parameters' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

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

	public function getInvitees() {
	if ($this->getIsGhostEvent() \|\| $this->getIsStub()) {
	if ($this->stubInvitees === null) {
	$this->stubInvitees = $this->newStubInvitees();
	}
	return $this->stubInvitees;
	}

	return $this->assertAttached($this->invitees);
	}

	public function getInviteeForPHID($phid) {
	$invitees = $this->getInvitees();
	$invitees = mpull($invitees, null, 'getInviteePHID');
	return idx($invitees, $phid);
	}

	public static function getFrequencyMap() {
	return array(
	PhutilCalendarRecurrenceRule::FREQUENCY_DAILY => array(
	'label' => pht('Daily'),
	),
	PhutilCalendarRecurrenceRule::FREQUENCY_WEEKLY => array(
	'label' => pht('Weekly'),
	),
	PhutilCalendarRecurrenceRule::FREQUENCY_MONTHLY => array(
	'label' => pht('Monthly'),
	),
	PhutilCalendarRecurrenceRule::FREQUENCY_YEARLY => array(
	'label' => pht('Yearly'),
	),
	);
	}

	private function newStubInvitees() {
	$parent = $this->getParentEvent();

	$parent_invitees = $parent->getInvitees();
	$stub_invitees = array();

	foreach ($parent_invitees as $invitee) {
	$stub_invitee = id(new PhabricatorCalendarEventInvitee())
	->setInviteePHID($invitee->getInviteePHID())
	->setInviterPHID($invitee->getInviterPHID())
	->setStatus(PhabricatorCalendarEventInvitee::STATUS_INVITED);

	$stub_invitees[] = $stub_invitee;
	}

	return $stub_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 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(PhabricatorCalendarEvent $event = null) {
	$this->parentEvent = $event;
	return $this;
	}

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

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

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

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

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

	if ($show_end) {
	// Subtract one second since the stored date is exclusive.
	$max_date = $max_date->modify('-1 second');

	$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 = $min_date->format('U');
	$max_epoch = $max_date->format('U');

	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->getIsCancelled()) {
	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';
	+ $viewer_phid = $viewer->getPHID();
	+ if ($this->isRSVPInvited($viewer_phid)) {
	+ return 'fa-users';
	+ } else {
	+ $status = $this->getUserInviteStatus($viewer_phid);
	+ 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';
	+ }
	}
	}

	if ($this->isImportedEvent()) {
	return 'fa-download';
	}

	return $this->getIcon();
	}

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

	if ($this->isImportedEvent()) {
	return 'orange';
	}

	if ($viewer->isLoggedIn()) {
	- $status = $this->getUserInviteStatus($viewer->getPHID());
	+ $viewer_phid = $viewer->getPHID();
	+ if ($this->isRSVPInvited($viewer_phid)) {
	+ return 'green';
	+ }
	+
	+ $status = $this->getUserInviteStatus($viewer_phid);
	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->getIsCancelled()) {
	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,
	array $children) {

	$base_uri = new PhutilURI(PhabricatorEnv::getProductionURI('/'));
	$domain = $base_uri->getDomain();

	// NOTE: For recurring events, all of the events in the series have the
	// same UID (the UID of the parent). The child event instances are
	// differentiated by the "RECURRENCE-ID" field.
	if ($this->isChildEvent()) {
	$parent = $this->getParentEvent();
	$instance_datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch(
	$this->getUTCInstanceEpoch());
	$recurrence_id = $instance_datetime->getISO8601();
	$rrule = null;
	} else {
	$parent = $this;
	$recurrence_id = null;
	$rrule = $this->newRecurrenceRule();
	}
	$uid = $parent->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();

	// NOTE: Gmail shows "Who: Unknown Organizer*" if the organizer URI does
	// not look like an email address. Use a synthetic address so it shows
	// the host name instead.
	$install_uri = PhabricatorEnv::getProductionURI('/');
	$install_uri = new PhutilURI($install_uri);

	// This should possibly use "metamta.reply-handler-domain" instead, but
	// we do not currently accept mail for users anyway, and that option may
	// not be configured.
	$mail_domain = $install_uri->getDomain();
	$host_uri = "mailto:{$host_phid}@{$mail_domain}";

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

	// TODO: Use $children to generate EXDATE/RDATE information.

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

	if ($rrule) {
	$node->setRecurrenceRule($rrule);
	}

	if ($recurrence_id) {
	$node->setRecurrenceID($recurrence_id);
	}

	return $node;
	}

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

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

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

	public function newEndDateTime() {
	$datetime = $this->newEndDateTimeForEdit();

	// If this is an all day event, we move the end date time forward to the
	// first second of the following day. This is consistent with what users
	// expect: an all day event from "Nov 1" to "Nov 1" lasts the entire day.

	// For imported events, the end date is already stored with this
	// adjustment.

	if ($this->getIsAllDay() && !$this->isImportedEvent()) {
	$datetime = $datetime
	->newAbsoluteDateTime()
	->setHour(0)
	->setMinute(0)
	->setSecond(0)
	->newRelativeDateTime('P1D')
	->newAbsoluteDateTime();
	}

	return $datetime;
	}

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

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

	return null;
	}

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

	$index = $this->getSequenceIndex();
	if (!$index) {
	return null;
	}

	return $this->newSequenceIndexDateTime($index);
	}

	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 = null) {
	if ($datetime) {
	$value = $datetime->newAbsoluteDateTime()->toDictionary();
	} else {
	$value = null;
	}

	return $this->setParameter('untilDateTime', $value);
	}

	public function setRecurrenceRule(PhutilCalendarRecurrenceRule $rrule) {
	return $this->setParameter(
	'recurrenceRule',
	$rrule->toDictionary());
	}

	public function newRecurrenceRule() {
	if ($this->isChildEvent()) {
	return $this->getParentEvent()->newRecurrenceRule();
	}

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

	$dict = $this->getParameter('recurrenceRule');
	if (!$dict) {
	return null;
	}

	$rrule = PhutilCalendarRecurrenceRule::newFromDictionary($dict);

	$start = $this->newStartDateTime();
	$rrule->setStartDateTime($start);

	$until = $this->newUntilDateTime();
	if ($until) {
	$rrule->setUntil($until);
	}

	$count = $this->getRecurrenceCount();
	if ($count) {
	$rrule->setCount($count);
	}

	return $rrule;
	}

	public function getRecurrenceCount() {
	$count = (int)$this->getParameter('recurrenceCount');

	if (!$count) {
	return null;
	}

	return $count;
	}

	public function newRecurrenceSet() {
	if ($this->isChildEvent()) {
	return $this->getParentEvent()->newRecurrenceSet();
	}

	$set = new PhutilCalendarRecurrenceSet();

	$rrule = $this->newRecurrenceRule();
	if (!$rrule) {
	return null;
	}

	$set->addSource($rrule);

	return $set;
	}

	public function isImportedEvent() {
	return (bool)$this->getImportSourcePHID();
	}

	public function getImportSource() {
	return $this->assertAttached($this->importSource);
	}

	public function attachImportSource(
	PhabricatorCalendarImport $import = null) {
	$this->importSource = $import;
	return $this;
	}

	public function loadForkTarget(PhabricatorUser $viewer) {
	if (!$this->getIsRecurring()) {
	// Can't fork an event which isn't recurring.
	return null;
	}

	if ($this->isChildEvent()) {
	// If this is a child event, this is the fork target.
	return $this;
	}

	if (!$this->isValidSequenceIndex($viewer, 1)) {
	// This appears to be a "recurring" event with no valid instances: for
	// example, its "until" date is before the second instance would occur.
	// This can happen if we already forked the event or if users entered
	// silly stuff. Just edit the event directly without forking anything.
	return null;
	}


	$next_event = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withInstanceSequencePairs(
	array(
	array($this->getPHID(), 1),
	))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();

	if (!$next_event) {
	$next_event = $this->newStub($viewer, 1);
	}

	return $next_event;
	}

	public function loadFutureEvents(PhabricatorUser $viewer) {
	// NOTE: If you can't edit some of the future events, we just
	// don't try to update them. This seems like it's probably what
	// users are likely to expect.

	// NOTE: This only affects events that are currently in the same
	// series, not all events that were ever in the original series.
	// We could use series PHIDs instead of parent PHIDs to affect more
	// events if this turns out to be counterintuitive. Other
	// applications differ in their behavior.

	return id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withParentEventPHIDs(array($this->getPHID()))
	->withUTCInitialEpochBetween($this->getUTCInitialEpoch(), null)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->execute();
	}

	public function getNotificationPHIDs() {
	$phids = array();
	if ($this->getPHID()) {
	$phids[] = $this->getPHID();
	}

	if ($this->getSeriesParentPHID()) {
	$phids[] = $this->getSeriesParentPHID();
	}

	return $phids;
	}

	+ public function getRSVPs($phid) {
	+ return $this->assertAttachedKey($this->rsvps, $phid);
	+ }
	+
	+ public function attachRSVPs(array $rsvps) {
	+ $this->rsvps = $rsvps;
	+ return $this;
	+ }
	+
	+ public function isRSVPInvited($phid) {
	+ $status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	+ return ($this->getRSVPStatus($phid) == $status_invited);
	+ }
	+
	+ public function hasRSVPAuthority($phid, $other_phid) {
	+ foreach ($this->getRSVPs($phid) as $rsvp) {
	+ if ($rsvp->getInviteePHID() == $other_phid) {
	+ return true;
	+ }
	+ }
	+
	+ return false;
	+ }
	+
	+ public function getRSVPStatus($phid) {
	+ // Check for an individual invitee record first.
	+ $invitees = $this->invitees;
	+ $invitees = mpull($invitees, null, 'getInviteePHID');
	+ $invitee = idx($invitees, $phid);
	+ if ($invitee) {
	+ return $invitee->getStatus();
	+ }
	+
	+ // If we don't have one, try to find an invited status for the user's
	+ // projects.
	+ $status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	+ foreach ($this->getRSVPs($phid) as $rsvp) {
	+ if ($rsvp->getStatus() == $status_invited) {
	+ return $status_invited;
	+ }
	+ }
	+
	+ return PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	+ }
	+
	+

	/* -( 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:
	if ($this->isImportedEvent()) {
	return PhabricatorPolicies::POLICY_NOONE;
	} else {
	return $this->getEditPolicy();
	}
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	if ($this->isImportedEvent()) {
	return false;
	}

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


	/* -( PhabricatorExtendedPolicyInterface )--------------------------------- */


	public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
	$extended = array();

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$import_source = $this->getImportSource();
	if ($import_source) {
	$extended[] = array(
	$import_source,
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}
	break;
	}

	return $extended;
	}

	/* -( PhabricatorPolicyCodexInterface )------------------------------------ */

	public function newPolicyCodex() {
	return new PhabricatorCalendarEventPolicyCodex();
	}


	/* -( 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.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('isAllDay')
	->setType('bool')
	->setDescription(pht('True if the event is an all day event.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('startDateTime')
	->setType('datetime')
	->setDescription(pht('Start date and time of the event.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('endDateTime')
	->setType('datetime')
	->setDescription(pht('End date and time of the event.')),
	);
	}

	public function getFieldValuesForConduit() {
	$start_datetime = $this->newStartDateTime();
	$end_datetime = $this->newEndDateTime();

	return array(
	'name' => $this->getName(),
	'description' => $this->getDescription(),
	'isAllDay' => (bool)$this->getIsAllDay(),
	'startDateTime' => $this->getConduitDateTime($start_datetime),
	'endDateTime' => $this->getConduitDateTime($end_datetime),
	);
	}

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

	private function getConduitDateTime($datetime) {
	if (!$datetime) {
	return null;
	}

	$epoch = $datetime->getEpoch();

	// TODO: Possibly pass the actual viewer in from the Conduit stuff, or
	// retain it when setting the viewer timezone?
	$viewer = id(new PhabricatorUser())
	->overrideTimezoneIdentifier($this->viewerTimezone);

	return array(
	'epoch' => (int)$epoch,
	'display' => array(
	'default' => phabricator_datetime($epoch, $viewer),
	),
	'iso8601' => $datetime->getISO8601(),
	'timezone' => $this->viewerTimezone,
	);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 6, 9:21 AM (9 h, 50 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 321786
Default Alt Text: (103 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions