No OneTemporary
Actions

Size

69 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	index c8bc9b5593..a67bc8b741 100644
	--- a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	+++ b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	@@ -1,573 +1,592 @@
	<?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->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());

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

	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);
	+
	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))
	+ ->setHref($edit_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));
	}

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

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

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

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

	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))
	->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/PhabricatorCalendarEventEditEngine.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	index fef14c13e1..318db2e2d2 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
	@@ -1,270 +1,276 @@
	<?php

	final class PhabricatorCalendarEventEditEngine
	extends PhabricatorEditEngine {

	const ENGINECONST = 'calendar.event';

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	- $frequency_options = array(
	- PhutilCalendarRecurrenceRule::FREQUENCY_DAILY => pht('Daily'),
	- PhutilCalendarRecurrenceRule::FREQUENCY_WEEKLY => pht('Weekly'),
	- PhutilCalendarRecurrenceRule::FREQUENCY_MONTHLY => pht('Monthly'),
	- PhutilCalendarRecurrenceRule::FREQUENCY_YEARLY => pht('Yearly'),
	- );
	+ $frequency_map = PhabricatorCalendarEvent::getFrequencyMap();
	+ $frequency_options = ipull($frequency_map, 'label');
	+
	+ $rrule = $object->newRecurrenceRule();
	+ if ($rrule) {
	+ $frequency = $rrule->getFrequency();
	+ } else {
	+ $frequency = null;
	+ }

	$fields = array(
	id(new PhabricatorTextEditField())
	->setKey('name')
	->setLabel(pht('Name'))
	->setDescription(pht('Name of the event.'))
	->setIsRequired(true)
	->setTransactionType(
	PhabricatorCalendarEventNameTransaction::TRANSACTIONTYPE)
	->setConduitDescription(pht('Rename the event.'))
	->setConduitTypeDescription(pht('New event name.'))
	->setValue($object->getName()),
	- id(new PhabricatorRemarkupEditField())
	- ->setKey('description')
	- ->setLabel(pht('Description'))
	- ->setDescription(pht('Description of the event.'))
	+ id(new PhabricatorBoolEditField())
	+ ->setKey('isAllDay')
	+ ->setLabel(pht('All Day'))
	+ ->setOptions(pht('Normal Event'), pht('All Day Event'))
	->setTransactionType(
	- PhabricatorCalendarEventDescriptionTransaction::TRANSACTIONTYPE)
	- ->setConduitDescription(pht('Update the event description.'))
	- ->setConduitTypeDescription(pht('New event description.'))
	- ->setValue($object->getDescription()),
	+ PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE)
	+ ->setDescription(pht('Marks this as an all day event.'))
	+ ->setConduitDescription(pht('Make the event an all day event.'))
	+ ->setConduitTypeDescription(pht('Mark the event as an all day event.'))
	+ ->setValue($object->getIsAllDay()),
	+ id(new PhabricatorEpochEditField())
	+ ->setKey('start')
	+ ->setLabel(pht('Start'))
	+ ->setIsLockable(false)
	+ ->setIsDefaultable(false)
	+ ->setTransactionType(
	+ PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE)
	+ ->setDescription(pht('Start time of the event.'))
	+ ->setConduitDescription(pht('Change the start time of the event.'))
	+ ->setConduitTypeDescription(pht('New event start time.'))
	+ ->setValue($object->getStartDateTimeEpoch()),
	+ id(new PhabricatorEpochEditField())
	+ ->setKey('end')
	+ ->setLabel(pht('End'))
	+ ->setIsLockable(false)
	+ ->setIsDefaultable(false)
	+ ->setTransactionType(
	+ PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE)
	+ ->setDescription(pht('End time of the event.'))
	+ ->setConduitDescription(pht('Change the end time of the event.'))
	+ ->setConduitTypeDescription(pht('New event end time.'))
	+ ->setValue($object->getEndDateTimeEpoch()),
	id(new PhabricatorBoolEditField())
	->setKey('cancelled')
	->setOptions(pht('Active'), pht('Cancelled'))
	->setLabel(pht('Cancelled'))
	->setDescription(pht('Cancel the event.'))
	->setTransactionType(
	PhabricatorCalendarEventCancelTransaction::TRANSACTIONTYPE)
	->setIsConduitOnly(true)
	->setConduitDescription(pht('Cancel or restore the event.'))
	->setConduitTypeDescription(pht('True to cancel the event.'))
	->setValue($object->getIsCancelled()),
	id(new PhabricatorUsersEditField())
	->setKey('hostPHID')
	->setAliases(array('host'))
	->setLabel(pht('Host'))
	->setDescription(pht('Host of the event.'))
	->setTransactionType(
	PhabricatorCalendarEventHostTransaction::TRANSACTIONTYPE)
	->setIsConduitOnly($this->getIsCreate())
	->setConduitDescription(pht('Change the host of the event.'))
	->setConduitTypeDescription(pht('New event host.'))
	->setSingleValue($object->getHostPHID()),
	id(new PhabricatorDatasourceEditField())
	->setKey('inviteePHIDs')
	->setAliases(array('invite', 'invitee', 'invitees', 'inviteePHID'))
	->setLabel(pht('Invitees'))
	->setDatasource(new PhabricatorMetaMTAMailableDatasource())
	->setTransactionType(
	PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Users invited to the event.'))
	->setConduitDescription(pht('Change invited users.'))
	->setConduitTypeDescription(pht('New event invitees.'))
	->setValue($invitee_phids)
	->setCommentActionLabel(pht('Change Invitees')),
	- );
	-
	- if ($this->getIsCreate()) {
	- $fields[] = id(new PhabricatorBoolEditField())
	+ id(new PhabricatorRemarkupEditField())
	+ ->setKey('description')
	+ ->setLabel(pht('Description'))
	+ ->setDescription(pht('Description of the event.'))
	+ ->setTransactionType(
	+ PhabricatorCalendarEventDescriptionTransaction::TRANSACTIONTYPE)
	+ ->setConduitDescription(pht('Update the event description.'))
	+ ->setConduitTypeDescription(pht('New event description.'))
	+ ->setValue($object->getDescription()),
	+ id(new PhabricatorIconSetEditField())
	+ ->setKey('icon')
	+ ->setLabel(pht('Icon'))
	+ ->setIconSet(new PhabricatorCalendarIconSet())
	+ ->setTransactionType(
	+ PhabricatorCalendarEventIconTransaction::TRANSACTIONTYPE)
	+ ->setDescription(pht('Event icon.'))
	+ ->setConduitDescription(pht('Change the event icon.'))
	+ ->setConduitTypeDescription(pht('New event icon.'))
	+ ->setValue($object->getIcon()),
	+ id(new PhabricatorBoolEditField())
	+ ->setIsHidden($object->getIsRecurring())
	->setKey('isRecurring')
	->setLabel(pht('Recurring'))
	->setOptions(pht('One-Time Event'), pht('Recurring Event'))
	->setTransactionType(
	PhabricatorCalendarEventRecurringTransaction::TRANSACTIONTYPE)
	->setDescription(pht('One time or recurring event.'))
	->setConduitDescription(pht('Make the event recurring.'))
	->setConduitTypeDescription(pht('Mark the event as a recurring event.'))
	- ->setValue($object->getIsRecurring());
	-
	-
	- $rrule = $object->newRecurrenceRule();
	- if ($rrule) {
	- $frequency = $rrule->getFrequency();
	- } else {
	- $frequency = null;
	- }
	-
	- $fields[] = id(new PhabricatorSelectEditField())
	+ ->setValue($object->getIsRecurring()),
	+ id(new PhabricatorSelectEditField())
	->setKey('frequency')
	->setLabel(pht('Frequency'))
	->setOptions($frequency_options)
	->setTransactionType(
	PhabricatorCalendarEventFrequencyTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Recurring event frequency.'))
	->setConduitDescription(pht('Change the event frequency.'))
	->setConduitTypeDescription(pht('New event frequency.'))
	- ->setValue($frequency);
	- }
	-
	- if ($this->getIsCreate() \|\| $object->getIsRecurring()) {
	- $fields[] = id(new PhabricatorEpochEditField())
	+ ->setValue($frequency),
	+ id(new PhabricatorEpochEditField())
	->setIsLockable(false)
	->setIsDefaultable(false)
	->setAllowNull(true)
	+ ->setHideTime($object->getIsAllDay())
	->setKey('until')
	->setLabel(pht('Repeat Until'))
	->setTransactionType(
	PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE)
	->setDescription(pht('Last instance of the event.'))
	->setConduitDescription(pht('Change when the event repeats until.'))
	->setConduitTypeDescription(pht('New final event time.'))
	- ->setValue($object->getUntilDateTimeEpoch());
	- }
	-
	- $fields[] = id(new PhabricatorBoolEditField())
	- ->setKey('isAllDay')
	- ->setLabel(pht('All Day'))
	- ->setOptions(pht('Normal Event'), pht('All Day Event'))
	- ->setTransactionType(
	- PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE)
	- ->setDescription(pht('Marks this as an all day event.'))
	- ->setConduitDescription(pht('Make the event an all day event.'))
	- ->setConduitTypeDescription(pht('Mark the event as an all day event.'))
	- ->setValue($object->getIsAllDay());
	-
	- $fields[] = id(new PhabricatorEpochEditField())
	- ->setKey('start')
	- ->setLabel(pht('Start'))
	- ->setIsLockable(false)
	- ->setIsDefaultable(false)
	- ->setTransactionType(
	- PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE)
	- ->setDescription(pht('Start time of the event.'))
	- ->setConduitDescription(pht('Change the start time of the event.'))
	- ->setConduitTypeDescription(pht('New event start time.'))
	- ->setValue($object->getStartDateTimeEpoch());
	-
	- $fields[] = id(new PhabricatorEpochEditField())
	- ->setKey('end')
	- ->setLabel(pht('End'))
	- ->setIsLockable(false)
	- ->setIsDefaultable(false)
	- ->setTransactionType(
	- PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE)
	- ->setDescription(pht('End time of the event.'))
	- ->setConduitDescription(pht('Change the end time of the event.'))
	- ->setConduitTypeDescription(pht('New event end time.'))
	- ->setValue($object->getEndDateTimeEpoch());
	-
	- $fields[] = id(new PhabricatorIconSetEditField())
	- ->setKey('icon')
	- ->setLabel(pht('Icon'))
	- ->setIconSet(new PhabricatorCalendarIconSet())
	- ->setTransactionType(
	- PhabricatorCalendarEventIconTransaction::TRANSACTIONTYPE)
	- ->setDescription(pht('Event icon.'))
	- ->setConduitDescription(pht('Change the event icon.'))
	- ->setConduitTypeDescription(pht('New event icon.'))
	- ->setValue($object->getIcon());
	+ ->setValue($object->getUntilDateTimeEpoch()),
	+ );

	return $fields;
	}

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

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

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

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

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

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

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

	-
	-
	return $fields;
	}
	+
	+ protected function newPages($object) {
	+ // Controls for event recurrence behavior go on a separate page which we
	+ // put in a dialog. This simplifies event creation in the common case.
	+
	+ return array(
	+ id(new PhabricatorEditPage())
	+ ->setKey('core')
	+ ->setLabel(pht('Core'))
	+ ->setIsDefault(true),
	+ id(new PhabricatorEditPage())
	+ ->setKey('recurring')
	+ ->setLabel(pht('Recurrence'))
	+ ->setFieldKeys(
	+ array(
	+ 'isRecurring',
	+ 'frequency',
	+ 'until',
	+ )),
	+ );
	+ }
	+
	}
	diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	index cb93e54554..1410c0e106 100644
	--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	@@ -1,1290 +1,1307 @@
	<?php

	final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
	implements
	PhabricatorPolicyInterface,
	PhabricatorExtendedPolicyInterface,
	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 $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 $viewerTimezone;

	// TODO: DEPRECATED. Remove once we're sure the migrations worked.
	protected $allDayDateFrom;
	protected $allDayDateTo;
	protected $dateFrom;
	protected $dateTo;
	protected $recurrenceEndDate;
	protected $recurrenceFrequency = array();

	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;

	return id(new PhabricatorCalendarEvent())
	->setDescription('')
	->setHostPHID($actor->getPHID())
	->setIsCancelled(0)
	->setIsAllDay(0)
	->setIsStub(0)
	->setIsRecurring(0)
	->setIcon($default_icon)
	->setViewPolicy($view_policy)
	->setEditPolicy($edit_policy)
	->setSpacePHID($actor->getDefaultSpacePHID())
	->attachInvitees(array())
	->setDateFrom(0)
	->setDateTo(0)
	->setAllDayDateFrom(0)
	->setAllDayDateTo(0)
	->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!'));
	}

	$child = id(new self())
	->setIsCancelled(0)
	->setIsStub(0)
	->setInstanceOfEventPHID($this->getPHID())
	->setSequenceIndex($sequence)
	->setIsRecurring(true)
	->attachParentEvent($this)
	->setAllDayDateFrom(0)
	->setAllDayDateTo(0)
	->setDateFrom(0)
	->setDateTo(0);

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

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

	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',
	'instanceOfEventPHID' => 'phid?',
	'sequenceIndex' => 'uint32?',
	'isStub' => 'bool',
	'utcInitialEpoch' => 'epoch',
	'utcUntilEpoch' => 'epoch?',
	'utcInstanceEpoch' => 'epoch?',

	'importAuthorPHID' => 'phid?',
	'importSourcePHID' => 'phid?',
	'importUIDIndex' => 'bytes12?',
	'importUID' => 'text?',

	// TODO: DEPRECATED.
	'allDayDateFrom' => 'epoch',
	'allDayDateTo' => 'epoch',
	'dateFrom' => 'epoch',
	'dateTo' => 'epoch',
	'recurrenceEndDate' => 'epoch?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_date' => array(
	'columns' => array('dateFrom', 'dateTo'),
	),
	'key_instance' => array(
	'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
	'unique' => true,
	),
	'key_epoch' => array(
	'columns' => array('utcInitialEpoch', 'utcUntilEpoch'),
	),
	'key_rdate' => array(
	'columns' => array('instanceOfEventPHID', 'utcInstanceEpoch'),
	'unique' => true,
	),
	),
	self::CONFIG_SERIALIZATION => array(
	'recurrenceFrequency' => self::SERIALIZATION_JSON,
	'parameters' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

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

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

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

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

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

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

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

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

	return false;
	}

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

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

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

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

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

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

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


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

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

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

	return $this->getIcon();
	}

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

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

	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,
	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');
	if ($datetime) {
	return $this->newDateTimeFromDictionary($datetime);
	}

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

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

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

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

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

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

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

	public function getUntilDateTimeEpoch() {
	$datetime = $this->newUntilDateTime();

	if (!$datetime) {
	return null;
	}

	return $datetime->getEpoch();
	}

	public function newDuration() {
	return id(new PhutilCalendarDuration())
	->setSeconds($this->getDuration());
	}

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

	$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) {
	return $this->setParameter(
	'untilDateTime',
	$datetime->newAbsoluteDateTime()->toDictionary());
	}

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


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

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	if ($this->getImportSource()) {
	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;
	}

	public function describeAutomaticCapability($capability) {
	if ($this->getImportSource()) {
	return pht(
	'Events imported from external sources can not be edited in '.
	'Phabricator.');
	}

	return pht(
	'The host of an event can always view and edit it. Users who are '.
	'invited to an event can always view it.');
	}


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


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

	}
	diff --git a/src/applications/calendar/xaction/PhabricatorCalendarEventRecurringTransaction.php b/src/applications/calendar/xaction/PhabricatorCalendarEventRecurringTransaction.php
	index 07aa26fa94..05f312ddc4 100644
	--- a/src/applications/calendar/xaction/PhabricatorCalendarEventRecurringTransaction.php
	+++ b/src/applications/calendar/xaction/PhabricatorCalendarEventRecurringTransaction.php
	@@ -1,44 +1,47 @@
	<?php

	final class PhabricatorCalendarEventRecurringTransaction
	extends PhabricatorCalendarEventTransactionType {

	const TRANSACTIONTYPE = 'calendar.recurring';

	public function generateOldValue($object) {
	return (int)$object->getIsRecurring();
	}

	public function generateNewValue($object, $value) {
	return (int)$value;
	}

	public function applyInternalEffects($object, $value) {
	$object->setIsRecurring($value);
	}

	public function validateTransactions($object, array $xactions) {
	$errors = array();

	$old = $object->getIsRecurring();
	foreach ($xactions as $xaction) {
	if ($this->isNewObject()) {
	continue;
	}

	if ($xaction->getNewValue() == $old) {
	continue;
	}

	+ if ($xaction->getNewValue()) {
	+ continue;
	+ }
	+
	$errors[] = $this->newInvalidError(
	pht(
	- 'An event can only be made recurring when it is created. '.
	- 'You can not convert an existing event into a recurring '.
	- 'event or vice versa.'),
	+ 'An event can not be stopped from recurring once it has been '.
	+ 'made recurring. You can cancel the event.'),
	$xaction);
	}

	return $errors;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 6, 9:25 AM (6 h, 36 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 321812
Default Alt Text: (69 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions