diff --git a/src/applications/calendar/application/PhabricatorCalendarApplication.php b/src/applications/calendar/application/PhabricatorCalendarApplication.php
index ec3d256ece..e948d70198 100644
--- a/src/applications/calendar/application/PhabricatorCalendarApplication.php
+++ b/src/applications/calendar/application/PhabricatorCalendarApplication.php
@@ -1,107 +1,107 @@
 <?php
 
 final class PhabricatorCalendarApplication extends PhabricatorApplication {
 
   public function getName() {
     return pht('Calendar');
   }
 
   public function getShortDescription() {
     return pht('Upcoming Events');
   }
 
   public function getFlavorText() {
     return pht('Never miss an episode ever again.');
   }
 
   public function getBaseURI() {
     return '/calendar/';
   }
 
   public function getIcon() {
     return 'fa-calendar';
   }
 
   public function getTitleGlyph() {
     // Unicode has a calendar character but it's in some distant code plane,
     // use "keyboard" since it looks vaguely similar.
     return "\xE2\x8C\xA8";
   }
 
   public function getApplicationGroup() {
     return self::GROUP_UTILITIES;
   }
 
   public function isPrototype() {
     return true;
   }
 
   public function getRemarkupRules() {
     return array(
       new PhabricatorCalendarRemarkupRule(),
     );
   }
 
   public function getRoutes() {
     return array(
       '/E(?P<id>[1-9]\d*)(?:/(?P<sequence>\d+)/)?'
         => 'PhabricatorCalendarEventViewController',
       '/calendar/' => array(
         '(?:query/(?P<queryKey>[^/]+)/(?:(?P<year>\d+)/'.
           '(?P<month>\d+)/)?(?:(?P<day>\d+)/)?)?'
           => 'PhabricatorCalendarEventListController',
         'event/' => array(
           $this->getEditRoutePattern('edit/')
             => 'PhabricatorCalendarEventEditController',
           'drag/(?P<id>[1-9]\d*)/'
             => 'PhabricatorCalendarEventDragController',
           'cancel/(?P<id>[1-9]\d*)/'
             => 'PhabricatorCalendarEventCancelController',
           '(?P<action>join|decline|accept)/(?P<id>[1-9]\d*)/'
             => 'PhabricatorCalendarEventJoinController',
-          'export/(?P<id>[1-9]\d*)/'
+          'export/(?P<id>[1-9]\d*)/(?P<filename>[^/]*)'
             => 'PhabricatorCalendarEventExportController',
         ),
       ),
     );
   }
 
   public function getHelpDocumentationArticles(PhabricatorUser $viewer) {
     return array(
       array(
         'name' => pht('Calendar User Guide'),
         'href' => PhabricatorEnv::getDoclink('Calendar User Guide'),
       ),
     );
   }
 
   public function getMailCommandObjects() {
     return array(
       'event' => array(
         'name' => pht('Email Commands: Events'),
         'header' => pht('Interacting with Calendar Events'),
         'object' => new PhabricatorCalendarEvent(),
         'summary' => pht(
           'This page documents the commands you can use to interact with '.
           'events in Calendar. These commands work when creating new tasks '.
           'via email and when replying to existing tasks.'),
       ),
     );
   }
 
   protected function getCustomCapabilities() {
     return array(
       PhabricatorCalendarEventDefaultViewCapability::CAPABILITY => array(
         'caption' => pht('Default view policy for newly created events.'),
         'template' => PhabricatorCalendarEventPHIDType::TYPECONST,
         'capability' => PhabricatorPolicyCapability::CAN_VIEW,
       ),
       PhabricatorCalendarEventDefaultEditCapability::CAPABILITY => array(
         'caption' => pht('Default edit policy for newly created events.'),
         'template' => PhabricatorCalendarEventPHIDType::TYPECONST,
         'capability' => PhabricatorPolicyCapability::CAN_EDIT,
       ),
     );
   }
 
 }
diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventExportController.php b/src/applications/calendar/controller/PhabricatorCalendarEventExportController.php
index e96744e46a..8163e4abeb 100644
--- a/src/applications/calendar/controller/PhabricatorCalendarEventExportController.php
+++ b/src/applications/calendar/controller/PhabricatorCalendarEventExportController.php
@@ -1,54 +1,40 @@
 <?php
 
 final class PhabricatorCalendarEventExportController
   extends PhabricatorCalendarController {
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $this->getViewer();
     $id = $request->getURIData('id');
 
     $event = id(new PhabricatorCalendarEventQuery())
       ->setViewer($viewer)
       ->withIDs(array($id))
       ->executeOne();
     if (!$event) {
       return new Aphront404Response();
     }
 
-    if ($request->isFormPost()) {
-      $file_name = $event->getMonogram().'.ics';
+    $file_name = $event->getICSFilename();
+    $event_node = $event->newIntermediateEventNode($viewer);
 
-      $event_node = $event->newIntermediateEventNode($viewer);
+    $document_node = id(new PhutilCalendarDocumentNode())
+      ->appendChild($event_node);
 
-      $document_node = id(new PhutilCalendarDocumentNode())
-        ->appendChild($event_node);
+    $root_node = id(new PhutilCalendarRootNode())
+      ->appendChild($document_node);
 
-      $root_node = id(new PhutilCalendarRootNode())
-        ->appendChild($document_node);
-
-      $ics_data = id(new PhutilICSWriter())
-        ->writeICSDocument($root_node);
-
-      return id(new AphrontFileResponse())
-        ->setDownload($file_name)
-        ->setMimeType('text/calendar')
-        ->setContent($ics_data);
-    }
-
-    return $this->newDialog()
-      ->setDisableWorkflowOnSubmit(true)
-      ->setTitle(pht('Export as .ics'))
-      ->appendParagraph(
-        pht(
-          'WARNING: This feature is a prototype and only supports a limited '.
-          'set of features. Keep your expectations low!'))
-      ->addSubmitButton(pht('Download .ics'))
-      ->addCancelButton($event->getURI(), pht('Close'));
+    $ics_data = id(new PhutilICSWriter())
+      ->writeICSDocument($root_node);
 
+    return id(new AphrontFileResponse())
+      ->setDownload($file_name)
+      ->setMimeType('text/calendar')
+      ->setContent($ics_data);
   }
 
 }
diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
index 4a0e6e7650..57792e6717 100644
--- a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
+++ b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
@@ -1,530 +1,530 @@
 <?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 = new DateTime('@'.$event->getViewerDateFrom());
     $start->setTimeZone($viewer->getTimeZone());
 
     $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);
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setSubheader($subheader)
       ->setMainColumn(
         array(
           $timeline,
           $comment_view,
         ))
       ->setCurtain($curtain)
       ->addPropertySection($details_header, $details)
       ->addPropertySection($recurring_header, $recurring)
       ->addPropertySection(pht('Description'), $description);
 
     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->isCancelledEvent()) {
       $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());
 
     foreach ($this->buildRSVPActions($event) as $action) {
       $header->addActionLink($action);
     }
 
     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}/";
     if ($event->isChildEvent()) {
       $edit_label = pht('Edit This Instance');
     } else {
       $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($this->getApplicationURI($edit_uri))
           ->setDisabled(!$can_edit)
           ->setWorkflow(!$can_edit));
     }
 
     if ($is_attending) {
       $curtain->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Decline Event'))
           ->setIcon('fa-user-times')
           ->setHref($this->getApplicationURI("event/join/{$id}/"))
           ->setWorkflow(true));
     } else {
       $curtain->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Join Event'))
           ->setIcon('fa-user-plus')
           ->setHref($this->getApplicationURI("event/join/{$id}/"))
           ->setWorkflow(true));
     }
 
     $cancel_uri = $this->getApplicationURI("event/cancel/{$id}/");
     $cancel_disabled = !$can_edit;
 
     if ($event->isChildEvent()) {
       $cancel_label = pht('Cancel This Instance');
       $reinstate_label = pht('Reinstate This Instance');
 
       if ($event->getParentEvent()->getIsCancelled()) {
         $cancel_disabled = true;
       }
     } else if ($event->isParentEvent()) {
       $cancel_label = pht('Cancel All');
       $reinstate_label = pht('Reinstate All');
     } else {
       $cancel_label = pht('Cancel Event');
       $reinstate_label = pht('Reinstate Event');
     }
 
     if ($event->isCancelledEvent()) {
       $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));
     }
 
-    $export_uri = $this->getApplicationURI("event/export/{$id}/");
+    $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)
-        ->setWorkflow(true));
+        ->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',
       );
 
       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];
 
         $item->setIcon($icon, $icon_color)
           ->setTarget($target);
         $invitee_list->addItem($item);
       }
     } else {
       $invitee_list = phutil_tag(
         'em',
         array(),
         pht('None'));
     }
 
     $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();
     }
 
     $rule = $event->getFrequencyRule();
     switch ($rule) {
       case PhabricatorCalendarEvent::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 PhabricatorCalendarEvent::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 PhabricatorCalendarEvent::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 PhabricatorCalendarEvent::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))
       ->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) {
       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/editor/PhabricatorCalendarEventEditor.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
index 5498efadd3..d87746f347 100644
--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
@@ -1,307 +1,331 @@
 <?php
 
 final class PhabricatorCalendarEventEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorCalendarApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Calendar');
   }
 
   protected function shouldApplyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function applyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $actor = $this->requireActor();
     if ($object->getIsStub()) {
       $this->materializeStub($object);
     }
   }
 
   private function materializeStub(PhabricatorCalendarEvent $event) {
     if (!$event->getIsStub()) {
       throw new Exception(
         pht('Can not materialize an event stub: this event is not a stub.'));
     }
 
     $actor = $this->getActor();
     $event->copyFromParent($actor);
     $event->setIsStub(0);
 
     $invitees = $event->getParentEvent()->getInvitees();
 
     $new_invitees = array();
     foreach ($invitees as $invitee) {
       $invitee = id(new PhabricatorCalendarEventInvitee())
         ->setEventPHID($event->getPHID())
         ->setInviteePHID($invitee->getInviteePHID())
         ->setInviterPHID($invitee->getInviterPHID())
         ->setStatus($invitee->getStatus())
         ->save();
 
       $new_invitees[] = $invitee;
     }
 
     $event->save();
     $event->attachInvitees($new_invitees);
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     return $types;
   }
 
   protected function adjustObjectForPolicyChecks(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $copy = parent::adjustObjectForPolicyChecks($object, $xactions);
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorCalendarEventHostTransaction::TRANSACTIONTYPE:
           $copy->setHostPHID($xaction->getNewValue());
           break;
         case PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE:
           PhabricatorPolicyRule::passTransactionHintToRule(
             $copy,
             new PhabricatorCalendarEventInviteesPolicyRule(),
             array_fuse($xaction->getNewValue()));
           break;
       }
     }
 
     return $copy;
   }
 
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // Clear the availability caches for users whose availability is affected
     // by this edit.
 
     $invalidate_all = false;
     $invalidate_phids = array();
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE:
         case PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE:
         case PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE:
         case PhabricatorCalendarEventCancelTransaction::TRANSACTIONTYPE:
         case PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE:
           // For these kinds of changes, we need to invalidate the availabilty
           // caches for all attendees.
           $invalidate_all = true;
           break;
         case PhabricatorCalendarEventAcceptTransaction::TRANSACTIONTYPE:
         case PhabricatorCalendarEventDeclineTransaction::TRANSACTIONTYPE:
           $acting_phid = $this->getActingAsPHID();
           $invalidate_phids[$acting_phid] = $acting_phid;
           break;
         case PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE:
           foreach ($xaction->getNewValue() as $phid => $ignored) {
             $invalidate_phids[$phid] = $phid;
           }
           break;
       }
     }
 
     $phids = mpull($object->getInvitees(), 'getInviteePHID');
     $phids = array_fuse($phids);
 
     if (!$invalidate_all) {
       $phids = array_select_keys($phids, $invalidate_phids);
     }
 
     if ($phids) {
       $object->applyViewerTimezone($this->getActor());
 
       $user = new PhabricatorUser();
       $conn_w = $user->establishConnection('w');
       queryfx(
         $conn_w,
         'UPDATE %T SET availabilityCacheTTL = NULL
           WHERE phid IN (%Ls) AND availabilityCacheTTL >= %d',
         $user->getTableName(),
         $phids,
         $object->getDateFromForCache());
     }
 
     return $xactions;
   }
 
 
   protected function validateAllTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $start_date_xaction =
       PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE;
     $end_date_xaction =
       PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE;
     $is_recurrence_xaction =
       PhabricatorCalendarEventRecurringTransaction::TRANSACTIONTYPE;
     $recurrence_end_xaction =
       PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE;
 
     $start_date = $object->getDateFrom();
     $end_date = $object->getDateTo();
     $recurrence_end = $object->getRecurrenceEndDate();
     $is_recurring = $object->getIsRecurring();
 
     $errors = array();
 
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == $start_date_xaction) {
         $start_date = $xaction->getNewValue()->getEpoch();
       } else if ($xaction->getTransactionType() == $end_date_xaction) {
         $end_date = $xaction->getNewValue()->getEpoch();
       } else if ($xaction->getTransactionType() == $recurrence_end_xaction) {
         $recurrence_end = $xaction->getNewValue()->getEpoch();
       } else if ($xaction->getTransactionType() == $is_recurrence_xaction) {
         $is_recurring = $xaction->getNewValue();
       }
     }
 
     if ($start_date > $end_date) {
       $errors[] = new PhabricatorApplicationTransactionValidationError(
         $end_date_xaction,
         pht('Invalid'),
         pht('End date must be after start date.'),
         null);
     }
 
     if ($recurrence_end && !$is_recurring) {
       $errors[] = new PhabricatorApplicationTransactionValidationError(
         $recurrence_end_xaction,
         pht('Invalid'),
         pht('Event must be recurring to have a recurrence end date.').
         null);
     }
 
     return $errors;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function getMailSubjectPrefix() {
     return pht('[Calendar]');
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     $phids = array();
 
     if ($object->getHostPHID()) {
       $phids[] = $object->getHostPHID();
     }
     $phids[] = $this->getActingAsPHID();
 
     $invitees = $object->getInvitees();
     foreach ($invitees as $invitee) {
       $status = $invitee->getStatus();
       if ($status === PhabricatorCalendarEventInvitee::STATUS_ATTENDING
         || $status === PhabricatorCalendarEventInvitee::STATUS_INVITED) {
         $phids[] = $invitee->getInviteePHID();
       }
     }
 
     $phids = array_unique($phids);
 
     return $phids;
   }
 
   public function getMailTagsMap() {
     return array(
       PhabricatorCalendarEventTransaction::MAILTAG_CONTENT =>
         pht(
           "An event's name, status, invite list, ".
           "icon, and description changes."),
       PhabricatorCalendarEventTransaction::MAILTAG_RESCHEDULE =>
         pht(
           "An event's start and end date ".
           "and cancellation status changes."),
       PhabricatorCalendarEventTransaction::MAILTAG_OTHER =>
         pht('Other event activity not listed above occurs.'),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PhabricatorCalendarReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $name = $object->getName();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("E{$id}: {$name}")
       ->addHeader('Thread-Topic', "E{$id}: ".$object->getName());
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $description = $object->getDescription();
     $body = parent::buildMailBody($object, $xactions);
 
     if (strlen($description)) {
       $body->addRemarkupSection(
         pht('EVENT DESCRIPTION'),
         $description);
     }
 
     $body->addLinkSection(
       pht('EVENT DETAIL'),
       PhabricatorEnv::getProductionURI('/E'.$object->getID()));
 
+    $ics_attachment = $this->newICSAttachment($object);
+    $body->addAttachment($ics_attachment);
 
     return $body;
   }
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return id(new PhabricatorCalendarEventHeraldAdapter())
       ->setObject($object);
   }
 
+  private function newICSAttachment(
+    PhabricatorCalendarEvent $event) {
+    $actor = $this->getActor();
+
+    $event_node = $event->newIntermediateEventNode($actor);
+
+    $document_node = id(new PhutilCalendarDocumentNode())
+      ->appendChild($event_node);
+
+    $root_node = id(new PhutilCalendarRootNode())
+      ->appendChild($document_node);
+
+    $ics_data = id(new PhutilICSWriter())
+      ->writeICSDocument($root_node);
+
+    $ics_attachment = new PhabricatorMetaMTAAttachment(
+      $ics_data,
+      $event->getICSFilename(),
+      'text/calendar');
+
+    return $ics_attachment;
+  }
 
 }
diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
index f3865583e2..63e5f2082a 100644
--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
@@ -1,906 +1,909 @@
 <?php
 
 final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorProjectInterface,
     PhabricatorMarkupInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorSubscribableInterface,
     PhabricatorTokenReceiverInterface,
     PhabricatorDestructibleInterface,
     PhabricatorMentionableInterface,
     PhabricatorFlaggableInterface,
     PhabricatorSpacesInterface,
     PhabricatorFulltextInterface,
     PhabricatorConduitResultInterface {
 
   protected $name;
   protected $hostPHID;
   protected $dateFrom;
   protected $dateTo;
   protected $allDayDateFrom;
   protected $allDayDateTo;
   protected $description;
   protected $isCancelled;
   protected $isAllDay;
   protected $icon;
   protected $mailKey;
   protected $isStub;
 
   protected $isRecurring = 0;
   protected $recurrenceFrequency = array();
   protected $recurrenceEndDate;
 
   private $isGhostEvent = false;
   protected $instanceOfEventPHID;
   protected $sequenceIndex;
 
   protected $viewPolicy;
   protected $editPolicy;
 
   protected $spacePHID;
 
   private $parentEvent = self::ATTACHABLE;
   private $invitees = self::ATTACHABLE;
 
   private $viewerDateFrom;
   private $viewerDateTo;
 
   // Frequency Constants
   const FREQUENCY_DAILY = 'daily';
   const FREQUENCY_WEEKLY = 'weekly';
   const FREQUENCY_MONTHLY = 'monthly';
   const FREQUENCY_YEARLY = 'yearly';
 
   public static function initializeNewCalendarEvent(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorCalendarApplication'))
       ->executeOne();
 
     $view_default = PhabricatorCalendarEventDefaultViewCapability::CAPABILITY;
     $edit_default = PhabricatorCalendarEventDefaultEditCapability::CAPABILITY;
     $view_policy = $app->getPolicy($view_default);
     $edit_policy = $app->getPolicy($edit_default);
 
     $now = PhabricatorTime::getNow();
 
     $start = new DateTime('@'.$now);
     $start->setTimeZone($actor->getTimeZone());
 
     $start->setTime($start->format('H'), 0, 0);
     $start->modify('+1 hour');
     $end = id(clone $start)->modify('+1 hour');
 
     $epoch_min = $start->format('U');
     $epoch_max = $end->format('U');
 
     $now_date = new DateTime('@'.$now);
     $now_min = id(clone $now_date)->setTime(0, 0)->format('U');
     $now_max = id(clone $now_date)->setTime(23, 59)->format('U');
 
     $default_icon = 'fa-calendar';
 
     return id(new PhabricatorCalendarEvent())
       ->setHostPHID($actor->getPHID())
       ->setIsCancelled(0)
       ->setIsAllDay(0)
       ->setIsStub(0)
       ->setIsRecurring(0)
       ->setRecurrenceFrequency(
         array(
           'rule' => self::FREQUENCY_WEEKLY,
         ))
       ->setIcon($default_icon)
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setSpacePHID($actor->getDefaultSpacePHID())
       ->attachInvitees(array())
       ->setDateFrom($epoch_min)
       ->setDateTo($epoch_max)
       ->setAllDayDateFrom($now_min)
       ->setAllDayDateTo($now_max)
       ->applyViewerTimezone($actor);
   }
 
   private function newChild(PhabricatorUser $actor, $sequence) {
     if (!$this->isParentEvent()) {
       throw new Exception(
         pht(
           'Unable to generate a new child event for an event which is not '.
           'a recurring parent event!'));
     }
 
     $child = id(new self())
       ->setIsCancelled(0)
       ->setIsStub(0)
       ->setInstanceOfEventPHID($this->getPHID())
       ->setSequenceIndex($sequence)
       ->setIsRecurring(true)
       ->setRecurrenceFrequency($this->getRecurrenceFrequency())
       ->attachParentEvent($this);
 
     return $child->copyFromParent($actor);
   }
 
   protected function readField($field) {
     static $inherit = array(
       'hostPHID' => true,
       'isAllDay' => true,
       'icon' => true,
       'spacePHID' => true,
       'viewPolicy' => true,
       'editPolicy' => true,
       'name' => true,
       'description' => true,
     );
 
     // Read these fields from the parent event instead of this event. For
     // example, we want any changes to the parent event's name to apply to
     // the child.
     if (isset($inherit[$field])) {
       if ($this->getIsStub()) {
         // TODO: This should be unconditional, but the execution order of
         // CalendarEventQuery and applyViewerTimezone() are currently odd.
         if ($this->parentEvent !== self::ATTACHABLE) {
           return $this->getParentEvent()->readField($field);
         }
       }
     }
 
     return parent::readField($field);
   }
 
 
   public function copyFromParent(PhabricatorUser $actor) {
     if (!$this->isChildEvent()) {
       throw new Exception(
         pht(
           'Unable to copy from parent event: this is not a child event.'));
     }
 
     $parent = $this->getParentEvent();
 
     $this
       ->setHostPHID($parent->getHostPHID())
       ->setIsAllDay($parent->getIsAllDay())
       ->setIcon($parent->getIcon())
       ->setSpacePHID($parent->getSpacePHID())
       ->setViewPolicy($parent->getViewPolicy())
       ->setEditPolicy($parent->getEditPolicy())
       ->setName($parent->getName())
       ->setDescription($parent->getDescription());
 
     $sequence = $this->getSequenceIndex();
     $duration = $this->getDuration();
     $epochs = $parent->getSequenceIndexEpochs($actor, $sequence, $duration);
 
     $this
       ->setDateFrom($epochs['dateFrom'])
       ->setDateTo($epochs['dateTo'])
       ->setAllDayDateFrom($epochs['allDayDateFrom'])
       ->setAllDayDateTo($epochs['allDayDateTo']);
 
     return $this;
   }
 
   public function isValidSequenceIndex(PhabricatorUser $viewer, $sequence) {
     try {
       $this->getSequenceIndexEpochs($viewer, $sequence, $this->getDuration());
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   private function getSequenceIndexEpochs(
     PhabricatorUser $viewer,
     $sequence,
     $duration) {
 
     $frequency = $this->getFrequencyUnit();
     $modify_key = '+'.$sequence.' '.$frequency;
 
     $date = $this->getDateFrom();
     $date_time = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
     $date_time->modify($modify_key);
     $date = $date_time->format('U');
 
     $end_date = $this->getRecurrenceEndDate();
     if ($end_date && $date > $end_date) {
       throw new Exception(
         pht(
           'Sequence "%s" is invalid for this event: it would occur after '.
           'the event stops repeating.',
           $sequence));
     }
 
     $utc = new DateTimeZone('UTC');
 
     $allday_from = $this->getAllDayDateFrom();
     $allday_date = new DateTime('@'.$allday_from, $utc);
     $allday_date->setTimeZone($utc);
     $allday_date->modify($modify_key);
 
     $allday_min = $allday_date->format('U');
     $allday_duration = ($this->getAllDayDateTo() - $allday_from);
 
     return array(
       'dateFrom' => $date,
       'dateTo' => $date + $duration,
       'allDayDateFrom' => $allday_min,
       'allDayDateTo' => $allday_min + $allday_duration,
     );
   }
 
   public function newStub(PhabricatorUser $actor, $sequence) {
     $stub = $this->newChild($actor, $sequence);
 
     $stub->setIsStub(1);
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
       $stub->save();
     unset($unguarded);
 
     $stub->applyViewerTimezone($actor);
 
     return $stub;
   }
 
   public function newGhost(PhabricatorUser $actor, $sequence) {
     $ghost = $this->newChild($actor, $sequence);
 
     $ghost
       ->setIsGhostEvent(true)
       ->makeEphemeral();
 
     $ghost->applyViewerTimezone($actor);
 
     return $ghost;
   }
 
   public function getViewerDateFrom() {
     if ($this->viewerDateFrom === null) {
       throw new PhutilInvalidStateException('applyViewerTimezone');
     }
 
     return $this->viewerDateFrom;
   }
 
   public function getViewerDateTo() {
     if ($this->viewerDateTo === null) {
       throw new PhutilInvalidStateException('applyViewerTimezone');
     }
 
     return $this->viewerDateTo;
   }
 
   public function applyViewerTimezone(PhabricatorUser $viewer) {
     if (!$this->getIsAllDay()) {
       $this->viewerDateFrom = $this->getDateFrom();
       $this->viewerDateTo = $this->getDateTo();
     } else {
       $zone = $viewer->getTimeZone();
 
       $this->viewerDateFrom = $this->getDateEpochForTimezone(
         $this->getAllDayDateFrom(),
         new DateTimeZone('UTC'),
         'Y-m-d',
         null,
         $zone);
 
       $this->viewerDateTo = $this->getDateEpochForTimezone(
         $this->getAllDayDateTo(),
         new DateTimeZone('UTC'),
         'Y-m-d 23:59:00',
         null,
         $zone);
     }
 
     return $this;
   }
 
   public function getDuration() {
     return $this->getDateTo() - $this->getDateFrom();
   }
 
   public function getDateEpochForTimezone(
     $epoch,
     $src_zone,
     $format,
     $adjust,
     $dst_zone) {
 
     $src = new DateTime('@'.$epoch);
     $src->setTimeZone($src_zone);
 
     if (strlen($adjust)) {
       $adjust = ' '.$adjust;
     }
 
     $dst = new DateTime($src->format($format).$adjust, $dst_zone);
     return $dst->format('U');
   }
 
   public function save() {
     if (!$this->mailKey) {
       $this->mailKey = Filesystem::readRandomCharacters(20);
     }
 
     return parent::save();
   }
 
   /**
    * Get the event start epoch for evaluating invitee availability.
    *
    * When assessing availability, we pretend events start earlier than they
    * really do. This allows us to mark users away for the entire duration of a
    * series of back-to-back meetings, even if they don't strictly overlap.
    *
    * @return int Event start date for availability caches.
    */
   public function getDateFromForCache() {
     return ($this->getViewerDateFrom() - phutil_units('15 minutes in seconds'));
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'text',
         'dateFrom' => 'epoch',
         'dateTo' => 'epoch',
         'allDayDateFrom' => 'epoch',
         'allDayDateTo' => 'epoch',
         'description' => 'text',
         'isCancelled' => 'bool',
         'isAllDay' => 'bool',
         'icon' => 'text32',
         'mailKey' => 'bytes20',
         'isRecurring' => 'bool',
         'recurrenceEndDate' => 'epoch?',
         'instanceOfEventPHID' => 'phid?',
         'sequenceIndex' => 'uint32?',
         'isStub' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_date' => array(
           'columns' => array('dateFrom', 'dateTo'),
         ),
         'key_instance' => array(
           'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
           'unique' => true,
         ),
       ),
       self::CONFIG_SERIALIZATION => array(
         'recurrenceFrequency' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorCalendarEventPHIDType::TYPECONST);
   }
 
   public function getMonogram() {
     return 'E'.$this->getID();
   }
 
   public function getInvitees() {
     return $this->assertAttached($this->invitees);
   }
 
   public function attachInvitees(array $invitees) {
     $this->invitees = $invitees;
     return $this;
   }
 
   public function getInviteePHIDsForEdit() {
     $invitees = array();
 
     foreach ($this->getInvitees() as $invitee) {
       if ($invitee->isUninvited()) {
         continue;
       }
       $invitees[] = $invitee->getInviteePHID();
     }
 
     return $invitees;
   }
 
   public function getUserInviteStatus($phid) {
     $invitees = $this->getInvitees();
     $invitees = mpull($invitees, null, 'getInviteePHID');
 
     $invited = idx($invitees, $phid);
     if (!$invited) {
       return PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
     }
     $invited = $invited->getStatus();
     return $invited;
   }
 
   public function getIsUserAttending($phid) {
     $attending_status = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
 
     $old_status = $this->getUserInviteStatus($phid);
     $is_attending = ($old_status == $attending_status);
 
     return $is_attending;
   }
 
   public function getIsUserInvited($phid) {
     $uninvited_status = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
     $declined_status = PhabricatorCalendarEventInvitee::STATUS_DECLINED;
     $status = $this->getUserInviteStatus($phid);
     if ($status == $uninvited_status || $status == $declined_status) {
       return false;
     }
     return true;
   }
 
   public function getIsGhostEvent() {
     return $this->isGhostEvent;
   }
 
   public function setIsGhostEvent($is_ghost_event) {
     $this->isGhostEvent = $is_ghost_event;
     return $this;
   }
 
   public function getFrequencyRule() {
     return idx($this->recurrenceFrequency, 'rule');
   }
 
   public function getFrequencyUnit() {
     $frequency = $this->getFrequencyRule();
 
     switch ($frequency) {
       case 'daily':
         return 'day';
       case 'weekly':
         return 'week';
       case 'monthly':
         return 'month';
       case 'yearly':
         return 'year';
       default:
         return 'day';
     }
   }
 
   public function getURI() {
     if ($this->getIsGhostEvent()) {
       $base = $this->getParentEvent()->getURI();
       $sequence = $this->getSequenceIndex();
       return "{$base}/{$sequence}/";
     }
 
     return '/'.$this->getMonogram();
   }
 
   public function getParentEvent() {
     return $this->assertAttached($this->parentEvent);
   }
 
   public function attachParentEvent($event) {
     $this->parentEvent = $event;
     return $this;
   }
 
   public function isParentEvent() {
     return ($this->getIsRecurring() && !$this->getInstanceOfEventPHID());
   }
 
   public function isChildEvent() {
     return ($this->instanceOfEventPHID !== null);
   }
 
   public function isCancelledEvent() {
     if ($this->getIsCancelled()) {
       return true;
     }
 
     if ($this->isChildEvent()) {
       if ($this->getParentEvent()->getIsCancelled()) {
         return true;
       }
     }
 
     return false;
   }
 
   public function renderEventDate(
     PhabricatorUser $viewer,
     $show_end) {
 
     if ($show_end) {
       $min_date = PhabricatorTime::getDateTimeFromEpoch(
         $this->getViewerDateFrom(),
         $viewer);
 
       $max_date = PhabricatorTime::getDateTimeFromEpoch(
         $this->getViewerDateTo(),
         $viewer);
 
       $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 = $this->getViewerDateFrom();
     $max_epoch = $this->getViewerDateTo();
 
     if ($this->getIsAllDay()) {
       if ($show_end_date) {
         return pht(
           '%s - %s, All Day',
           phabricator_date($min_epoch, $viewer),
           phabricator_date($max_epoch, $viewer));
       } else {
         return pht(
           '%s, All Day',
           phabricator_date($min_epoch, $viewer));
       }
     } else if ($show_end_date) {
       return pht(
         '%s - %s',
         phabricator_datetime($min_epoch, $viewer),
         phabricator_datetime($max_epoch, $viewer));
     } else if ($show_end) {
       return pht(
         '%s - %s',
         phabricator_datetime($min_epoch, $viewer),
         phabricator_time($max_epoch, $viewer));
     } else {
       return pht(
         '%s',
         phabricator_datetime($min_epoch, $viewer));
     }
   }
 
 
   public function getDisplayIcon(PhabricatorUser $viewer) {
     if ($this->isCancelledEvent()) {
       return 'fa-times';
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return 'fa-check-circle';
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return 'fa-user-plus';
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return 'fa-times';
       }
     }
 
     return $this->getIcon();
   }
 
   public function getDisplayIconColor(PhabricatorUser $viewer) {
     if ($this->isCancelledEvent()) {
       return 'red';
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return 'green';
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return 'green';
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return 'grey';
       }
     }
 
     return 'bluegrey';
   }
 
   public function getDisplayIconLabel(PhabricatorUser $viewer) {
     if ($this->isCancelledEvent()) {
       return pht('Cancelled');
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return pht('Attending');
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return pht('Invited');
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return pht('Declined');
       }
     }
 
     return null;
   }
 
+  public function getICSFilename() {
+    return $this->getMonogram().'.ics';
+  }
 
   public function newIntermediateEventNode(PhabricatorUser $viewer) {
     $base_uri = new PhutilURI(PhabricatorEnv::getProductionURI('/'));
     $domain = $base_uri->getDomain();
 
     $uid = $this->getPHID().'@'.$domain;
 
     $created = $this->getDateCreated();
     $created = PhutilCalendarAbsoluteDateTime::newFromEpoch($created);
 
     $modified = $this->getDateModified();
     $modified = PhutilCalendarAbsoluteDateTime::newFromEpoch($modified);
 
     $date_start = $this->getDateFrom();
     $date_start = PhutilCalendarAbsoluteDateTime::newFromEpoch($date_start);
 
     $date_end = $this->getDateTo();
     $date_end = PhutilCalendarAbsoluteDateTime::newFromEpoch($date_end);
 
     if ($this->getIsAllDay()) {
       $date_start->setIsAllDay(true);
       $date_end->setIsAllDay(true);
     }
 
     $host_phid = $this->getHostPHID();
 
     $invitees = $this->getInvitees();
     foreach ($invitees as $key => $invitee) {
       if ($invitee->isUninvited()) {
         unset($invitees[$key]);
       }
     }
 
     $phids = array();
     $phids[] = $host_phid;
     foreach ($invitees as $invitee) {
       $phids[] = $invitee->getInviteePHID();
     }
 
     $handles = $viewer->loadHandles($phids);
 
     $host_handle = $handles[$host_phid];
     $host_name = $host_handle->getFullName();
     $host_uri = $host_handle->getURI();
     $host_uri = PhabricatorEnv::getURI($host_uri);
 
     $organizer = id(new PhutilCalendarUserNode())
       ->setName($host_name)
       ->setURI($host_uri);
 
     $attendees = array();
     foreach ($invitees as $invitee) {
       $invitee_phid = $invitee->getInviteePHID();
       $invitee_handle = $handles[$invitee_phid];
       $invitee_name = $invitee_handle->getFullName();
       $invitee_uri = $invitee_handle->getURI();
       $invitee_uri = PhabricatorEnv::getURI($invitee_uri);
 
       switch ($invitee->getStatus()) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           $status = PhutilCalendarUserNode::STATUS_ACCEPTED;
           break;
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           $status = PhutilCalendarUserNode::STATUS_DECLINED;
           break;
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
         default:
           $status = PhutilCalendarUserNode::STATUS_INVITED;
           break;
       }
 
       $attendees[] = id(new PhutilCalendarUserNode())
         ->setName($invitee_name)
         ->setURI($invitee_uri)
         ->setStatus($status);
     }
 
     $node = id(new PhutilCalendarEventNode())
       ->setUID($uid)
       ->setName($this->getName())
       ->setDescription($this->getDescription())
       ->setCreatedDateTime($created)
       ->setModifiedDateTime($modified)
       ->setStartDateTime($date_start)
       ->setEndDateTime($date_end)
       ->setOrganizer($organizer)
       ->setAttendees($attendees);
 
     return $node;
   }
 
 
 
 /* -(  Markup Interface  )--------------------------------------------------- */
 
 
   /**
    * @task markup
    */
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digest($this->getMarkupText($field));
     $id = $this->getID();
     return "calendar:T{$id}:{$field}:{$hash}";
   }
 
 
   /**
    * @task markup
    */
   public function getMarkupText($field) {
     return $this->getDescription();
   }
 
 
   /**
    * @task markup
    */
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newCalendarMarkupEngine();
   }
 
 
   /**
    * @task markup
    */
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
 
   /**
    * @task markup
    */
   public function shouldUseMarkupCache($field) {
     return (bool)$this->getID();
   }
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     // The host of an event can always view and edit it.
     $user_phid = $this->getHostPHID();
     if ($user_phid) {
       $viewer_phid = $viewer->getPHID();
       if ($viewer_phid == $user_phid) {
         return true;
       }
     }
 
     if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       if ($status == PhabricatorCalendarEventInvitee::STATUS_INVITED ||
         $status == PhabricatorCalendarEventInvitee::STATUS_ATTENDING ||
         $status == PhabricatorCalendarEventInvitee::STATUS_DECLINED) {
         return true;
       }
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'The host of an event can always view and edit it. Users who are '.
       'invited to an event can always view it.');
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorCalendarEventEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorCalendarEventTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
 
     return $timeline;
   }
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return ($phid == $this->getHostPHID());
   }
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
 
   public function getUsersToNotifyOfTokenGiven() {
     return array($this->getHostPHID());
   }
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 
 /* -(  PhabricatorSpacesInterface  )----------------------------------------- */
 
 
   public function getSpacePHID() {
     return $this->spacePHID;
   }
 
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new PhabricatorCalendarEventFulltextEngine();
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('name')
         ->setType('string')
         ->setDescription(pht('The name of the event.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('description')
         ->setType('string')
         ->setDescription(pht('The event description.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     return array(
       'name' => $this->getName(),
       'description' => $this->getDescription(),
     );
   }
 
   public function getConduitSearchAttachments() {
     return array();
   }
 
 }