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