No OneTemporary
Actions

Size

80 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php b/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
	index 69492a416a..5929ca9428 100644
	--- a/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
	+++ b/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
	@@ -1,527 +1,560 @@
	<?php

	final class PhabricatorCalendarEventEditController
	extends PhabricatorCalendarController {

	private $id;

	public function willProcessRequest(array $data) {
	$this->id = idx($data, 'id');
	}

	public function isCreate() {
	return !$this->id;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getViewer();
	$user_phid = $viewer->getPHID();
	$error_name = true;
	+ $error_recurrence_end_date = true;
	$error_start_date = true;
	$error_end_date = true;
	$validation_exception = null;

	$is_recurring_id = celerity_generate_unique_node_id();
	+ $recurrence_end_date_id = celerity_generate_unique_node_id();
	$frequency_id = celerity_generate_unique_node_id();
	$all_day_id = celerity_generate_unique_node_id();
	$start_date_id = celerity_generate_unique_node_id();
	$end_date_id = celerity_generate_unique_node_id();

	$next_workflow = $request->getStr('next');
	$uri_query = $request->getStr('query');

	if ($this->isCreate()) {
	$mode = $request->getStr('mode');
	$event = PhabricatorCalendarEvent::initializeNewCalendarEvent(
	$viewer,
	$mode);

	$create_start_year = $request->getInt('year');
	$create_start_month = $request->getInt('month');
	$create_start_day = $request->getInt('day');
	$create_start_time = $request->getStr('time');

	if ($create_start_year) {
	$start = AphrontFormDateControlValue::newFromParts(
	$viewer,
	$create_start_year,
	$create_start_month,
	$create_start_day,
	$create_start_time);
	if (!$start->isValid()) {
	return new Aphront400Response();
	}
	$start_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$start->getEpoch());

	$end = clone $start_value->getDateTime();
	$end->modify('+1 hour');
	$end_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$end->format('U'));

	} else {
	list($start_value, $end_value) = $this->getDefaultTimeValues($viewer);
	}

	+ $recurrence_end_date_value = clone $end_value;
	+ $recurrence_end_date_value->setOptional(true);

	$submit_label = pht('Create');
	$page_title = pht('Create Event');
	$redirect = 'created';
	$subscribers = array();
	$invitees = array($user_phid);
	$cancel_uri = $this->getApplicationURI();
	} else {
	$event = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withIDs(array($this->id))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$event) {
	return new Aphront404Response();
	}

	if ($request->getURIData('sequence')) {
	$index = $request->getURIData('sequence');

	$result = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withInstanceSequencePairs(
	array(
	array(
	$event->getPHID(),
	$index,
	),
	))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();

	if ($result) {
	return id(new AphrontRedirectResponse())
	->setURI('/calendar/event/edit/'.$result->getID().'/');
	}

	$invitees = $event->getInvitees();

	$new_ghost = $event->generateNthGhost($index, $viewer);
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$new_ghost
	->setID(null)
	->setPHID(null)
	->removeViewerTimezone($viewer)
	->save();
	$ghost_invitees = array();
	foreach ($invitees as $invitee) {
	$ghost_invitee = clone $invitee;
	$ghost_invitee
	->setID(null)
	->setEventPHID($new_ghost->getPHID())
	->save();
	}
	unset($unguarded);
	return id(new AphrontRedirectResponse())
	->setURI('/calendar/event/edit/'.$new_ghost->getID().'/');
	}

	$end_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$event->getDateTo());
	$start_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$event->getDateFrom());
	+ $recurrence_end_date_value = id(clone $end_value)
	+ ->setOptional(true);

	$submit_label = pht('Update');
	$page_title = pht('Update Event');

	$subscribers = PhabricatorSubscribersQuery::loadSubscribersForPHID(
	$event->getPHID());

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

	$cancel_uri = '/'.$event->getMonogram();
	}

	$name = $event->getName();
	$description = $event->getDescription();
	$is_all_day = $event->getIsAllDay();
	$is_recurring = $event->getIsRecurring();
	$frequency = idx($event->getRecurrenceFrequency(), 'rule');
	$icon = $event->getIcon();

	$current_policies = id(new PhabricatorPolicyQuery())
	->setViewer($viewer)
	->setObject($event)
	->execute();

	if ($request->isFormPost()) {
	$xactions = array();
	$name = $request->getStr('name');

	$start_value = AphrontFormDateControlValue::newFromRequest(
	$request,
	'start');
	$end_value = AphrontFormDateControlValue::newFromRequest(
	$request,
	'end');
	+ $recurrence_end_date_value = AphrontFormDateControlValue::newFromRequest(
	+ $request,
	+ 'recurrenceEndDate');
	+ $recurrence_end_date_value->setOptional(true);
	$description = $request->getStr('description');
	$subscribers = $request->getArr('subscribers');
	$edit_policy = $request->getStr('editPolicy');
	$view_policy = $request->getStr('viewPolicy');
	$is_recurring = $request->getStr('isRecurring') ? 1 : 0;
	$frequency = $request->getStr('frequency');
	$is_all_day = $request->getStr('isAllDay');
	$icon = $request->getStr('icon');

	$invitees = $request->getArr('invitees');
	$new_invitees = $this->getNewInviteeList($invitees, $event);
	$status_attending = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
	if ($this->isCreate()) {
	$status = idx($new_invitees, $viewer->getPHID());
	if ($status) {
	$new_invitees[$viewer->getPHID()] = $status_attending;
	}
	}

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_NAME)
	->setNewValue($name);

	if ($this->isCreate()) {
	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_RECURRING)
	->setNewValue($is_recurring);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_FREQUENCY)
	->setNewValue(array('rule' => $frequency));
	+
	+ $xactions[] = id(new PhabricatorCalendarEventTransaction())
	+ ->setTransactionType(
	+ PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE)
	+ ->setNewValue($recurrence_end_date_value);
	}

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_ALL_DAY)
	->setNewValue($is_all_day);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_ICON)
	->setNewValue($icon);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_START_DATE)
	->setNewValue($start_value);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_END_DATE)
	->setNewValue($end_value);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(array('=' => array_fuse($subscribers)));

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_INVITE)
	->setNewValue($new_invitees);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(
	PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION)
	->setNewValue($description);

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
	->setNewValue($request->getStr('viewPolicy'));

	$xactions[] = id(new PhabricatorCalendarEventTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDIT_POLICY)
	->setNewValue($request->getStr('editPolicy'));

	$editor = id(new PhabricatorCalendarEventEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true);

	try {
	$xactions = $editor->applyTransactions($event, $xactions);
	$response = id(new AphrontRedirectResponse());
	switch ($next_workflow) {
	case 'day':
	if (!$uri_query) {
	$uri_query = 'month';
	}
	$year = $start_value->getDateTime()->format('Y');
	$month = $start_value->getDateTime()->format('m');
	$day = $start_value->getDateTime()->format('d');
	$response->setURI(
	'/calendar/query/'.$uri_query.'/'.$year.'/'.$month.'/'.$day.'/');
	break;
	default:
	$response->setURI('/E'.$event->getID());
	break;
	}
	return $response;
	} catch (PhabricatorApplicationTransactionValidationException $ex) {
	$validation_exception = $ex;
	$error_name = $ex->getShortMessage(
	PhabricatorCalendarEventTransaction::TYPE_NAME);
	$error_start_date = $ex->getShortMessage(
	PhabricatorCalendarEventTransaction::TYPE_START_DATE);
	$error_end_date = $ex->getShortMessage(
	PhabricatorCalendarEventTransaction::TYPE_END_DATE);
	+ $error_recurrence_end_date = $ex->getShortMessage(
	+ PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE);

	$event->setViewPolicy($view_policy);
	$event->setEditPolicy($edit_policy);
	}
	}

	$is_recurring_checkbox = null;
	+ $recurrence_end_date_control = null;
	$recurrence_frequency_select = null;

	$name = id(new AphrontFormTextControl())
	->setLabel(pht('Name'))
	->setName('name')
	->setValue($name)
	->setError($error_name);

	if ($this->isCreate()) {
	Javelin::initBehavior('recurring-edit', array(
	'isRecurring' => $is_recurring_id,
	'frequency' => $frequency_id,
	+ 'recurrenceEndDate' => $recurrence_end_date_id,
	));

	$is_recurring_checkbox = id(new AphrontFormCheckboxControl())
	->addCheckbox(
	'isRecurring',
	1,
	pht('Recurring Event'),
	$is_recurring,
	$is_recurring_id);

	+ $recurrence_end_date_control = id(new AphrontFormDateControl())
	+ ->setUser($viewer)
	+ ->setName('recurrenceEndDate')
	+ ->setLabel(pht('Recurrence End Date'))
	+ ->setError($error_recurrence_end_date)
	+ ->setValue($recurrence_end_date_value)
	+ ->setID($recurrence_end_date_id)
	+ ->setIsTimeDisabled(true)
	+ ->setAllowNull(true)
	+ ->setIsDisabled(!$is_recurring);
	+
	$recurrence_frequency_select = id(new AphrontFormSelectControl())
	->setName('frequency')
	->setOptions(array(
	'daily' => pht('Daily'),
	'weekly' => pht('Weekly'),
	'monthly' => pht('Monthly'),
	'yearly' => pht('Yearly'),
	))
	->setValue($frequency)
	->setLabel(pht('Recurring Event Frequency'))
	->setID($frequency_id)
	->setDisabled(!$is_recurring);
	}

	Javelin::initBehavior('event-all-day', array(
	'allDayID' => $all_day_id,
	'startDateID' => $start_date_id,
	'endDateID' => $end_date_id,
	));

	$all_day_checkbox = id(new AphrontFormCheckboxControl())
	->addCheckbox(
	'isAllDay',
	1,
	pht('All Day Event'),
	$is_all_day,
	$all_day_id);

	$start_control = id(new AphrontFormDateControl())
	->setUser($viewer)
	->setName('start')
	->setLabel(pht('Start'))
	->setError($error_start_date)
	->setValue($start_value)
	->setID($start_date_id)
	->setIsTimeDisabled($is_all_day)
	->setEndDateID($end_date_id);

	$end_control = id(new AphrontFormDateControl())
	->setUser($viewer)
	->setName('end')
	->setLabel(pht('End'))
	->setError($error_end_date)
	->setValue($end_value)
	->setID($end_date_id)
	->setIsTimeDisabled($is_all_day);

	$description = id(new AphrontFormTextAreaControl())
	->setLabel(pht('Description'))
	->setName('description')
	->setValue($description);

	$view_policies = id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
	->setPolicyObject($event)
	->setPolicies($current_policies)
	->setName('viewPolicy');
	$edit_policies = id(new AphrontFormPolicyControl())
	->setUser($viewer)
	->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
	->setPolicyObject($event)
	->setPolicies($current_policies)
	->setName('editPolicy');

	$subscribers = id(new AphrontFormTokenizerControl())
	->setLabel(pht('Subscribers'))
	->setName('subscribers')
	->setValue($subscribers)
	->setUser($viewer)
	->setDatasource(new PhabricatorMetaMTAMailableDatasource());

	$invitees = id(new AphrontFormTokenizerControl())
	->setLabel(pht('Invitees'))
	->setName('invitees')
	->setValue($invitees)
	->setUser($viewer)
	->setDatasource(new PhabricatorMetaMTAMailableDatasource());

	if ($this->isCreate()) {
	$icon_uri = $this->getApplicationURI('icon/');
	} else {
	$icon_uri = $this->getApplicationURI('icon/'.$event->getID().'/');
	}
	$icon_display = PhabricatorCalendarIcon::renderIconForChooser($icon);
	$icon = id(new AphrontFormChooseButtonControl())
	->setLabel(pht('Icon'))
	->setName('icon')
	->setDisplayValue($icon_display)
	->setButtonText(pht('Choose Icon...'))
	->setChooseURI($icon_uri)
	->setValue($icon);

	$form = id(new AphrontFormView())
	->addHiddenInput('next', $next_workflow)
	->addHiddenInput('query', $uri_query)
	->setUser($viewer)
	->appendChild($name);

	if ($is_recurring_checkbox) {
	$form->appendChild($is_recurring_checkbox);
	}
	+ if ($recurrence_end_date_control) {
	+ $form->appendChild($recurrence_end_date_control);
	+ }
	if ($recurrence_frequency_select) {
	$form->appendControl($recurrence_frequency_select);
	}

	$form
	->appendChild($all_day_checkbox)
	->appendChild($start_control)
	->appendChild($end_control)
	->appendControl($view_policies)
	->appendControl($edit_policies)
	->appendControl($subscribers)
	->appendControl($invitees)
	->appendChild($description)
	->appendChild($icon);


	if ($request->isAjax()) {
	return $this->newDialog()
	->setTitle($page_title)
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->appendForm($form)
	->addCancelButton($cancel_uri)
	->addSubmitButton($submit_label);
	}

	$submit = id(new AphrontFormSubmitControl())
	->addCancelButton($cancel_uri)
	->setValue($submit_label);

	$form->appendChild($submit);

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText($page_title)
	->setForm($form);

	$crumbs = $this->buildApplicationCrumbs();

	if (!$this->isCreate()) {
	$crumbs->addTextCrumb('E'.$event->getId(), '/E'.$event->getId());
	}

	$crumbs->addTextCrumb($page_title);

	$object_box = id(new PHUIObjectBoxView())
	->setHeaderText($page_title)
	->setValidationException($validation_exception)
	->appendChild($form);

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$object_box,
	),
	array(
	'title' => $page_title,
	));
	}


	public function getNewInviteeList(array $phids, $event) {
	$invitees = $event->getInvitees();
	$invitees = mpull($invitees, null, 'getInviteePHID');
	$invited_status = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	$uninvited_status = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	$phids = array_fuse($phids);

	$new = array();
	foreach ($phids as $phid) {
	$old_status = $event->getUserInviteStatus($phid);
	if ($old_status != $uninvited_status) {
	continue;
	}
	$new[$phid] = $invited_status;
	}

	foreach ($invitees as $invitee) {
	$deleted_invitee = !idx($phids, $invitee->getInviteePHID());
	if ($deleted_invitee) {
	$new[$invitee->getInviteePHID()] = $uninvited_status;
	}
	}

	return $new;
	}

	private function getDefaultTimeValues($viewer) {
	$start = new DateTime('@'.time());
	$start->setTimeZone($viewer->getTimeZone());

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

	$start_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$start->format('U'));
	$end_value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	$end->format('U'));

	return array($start_value, $end_value);
	}

	}
	diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	index 37411c9786..777a81cff3 100644
	--- a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	+++ b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	@@ -1,314 +1,321 @@
	<?php

	final class PhabricatorCalendarEventViewController
	extends PhabricatorCalendarController {

	private $id;

	public function shouldAllowPublic() {
	return true;
	}

	public function willProcessRequest(array $data) {
	$this->id = $data['id'];
	}

	public function processRequest() {
	$request = $this->getRequest();
	$viewer = $request->getUser();

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

	$event = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->withIDs(array($this->id))
	->executeOne();
	if (!$event) {
	return new Aphront404Response();
	}

	if ($sequence && $event->getIsRecurring()) {
	$event = $event->generateNthGhost($sequence, $viewer);
	} else if ($sequence) {
	return new Aphront404Response();
	}

	$title = 'E'.$event->getID();
	$page_title = $title.' '.$event->getName();
	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($title, '/E'.$event->getID());

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

	$header = $this->buildHeaderView($event);
	$actions = $this->buildActionView($event);
	$properties = $this->buildPropertyView($event);

	$properties->setActionList($actions);
	$box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->addPropertyList($properties);

	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
	$add_comment_header = $is_serious
	? pht('Add Comment')
	: pht('Add To Plate');
	$draft = PhabricatorDraft::newFromUserAndKey($viewer, $event->getPHID());
	$add_comment_form = id(new PhabricatorApplicationTransactionCommentView())
	->setUser($viewer)
	->setObjectPHID($event->getPHID())
	->setDraft($draft)
	->setHeaderText($add_comment_header)
	->setAction(
	$this->getApplicationURI('/event/comment/'.$event->getID().'/'))
	->setSubmitButtonName(pht('Add Comment'));

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$box,
	$timeline,
	$add_comment_form,
	),
	array(
	'title' => $page_title,
	));
	}

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

	$is_cancelled = $event->getIsCancelled();
	$icon = $is_cancelled ? ('fa-times') : ('fa-calendar');
	$color = $is_cancelled ? ('grey') : ('green');
	$status = $is_cancelled ? pht('Cancelled') : pht('Active');

	$invite_status = $event->getUserInviteStatus($viewer->getPHID());
	$status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
	$is_invite_pending = ($invite_status == $status_invited);

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

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

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

	$header->addActionLink($decline_button)
	->addActionLink($accept_button);
	}
	return $header;
	}

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

	$actions = id(new PhabricatorActionListView())
	->setObjectURI($this->getApplicationURI('event/'.$id.'/'))
	->setUser($viewer)
	->setObject($event);

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

	- if ($event->getIsRecurring() && $event->getIsGhostEvent()) {
	+ if ($event->getIsRecurring() && $event->getInstanceOfEventPHID()) {
	$index = $event->getSequenceIndex();

	$actions->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit This Instance'))
	->setIcon('fa-pencil')
	->setHref($this->getApplicationURI("event/edit/{$id}/{$index}/"))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));
	}

	if (!$event->getIsRecurring() && !$event->getIsGhostEvent()) {
	$actions->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Event'))
	->setIcon('fa-pencil')
	->setHref($this->getApplicationURI("event/edit/{$id}/"))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit));
	}

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

	if ($is_cancelled) {
	$actions->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Reinstate Event'))
	->setIcon('fa-plus')
	->setHref($this->getApplicationURI("event/cancel/{$id}/"))
	->setDisabled(!$can_edit)
	->setWorkflow(true));
	} else {
	$actions->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Cancel Event'))
	->setIcon('fa-times')
	->setHref($this->getApplicationURI("event/cancel/{$id}/"))
	->setDisabled(!$can_edit)
	->setWorkflow(true));
	}

	return $actions;
	}

	private function buildPropertyView(PhabricatorCalendarEvent $event) {
	$viewer = $this->getRequest()->getUser();

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

	if ($event->getIsAllDay()) {
	$date_start = phabricator_date($event->getDateFrom(), $viewer);
	$date_end = phabricator_date($event->getDateTo(), $viewer);

	if ($date_start == $date_end) {
	$properties->addProperty(
	pht('Time'),
	phabricator_date($event->getDateFrom(), $viewer));
	} else {
	$properties->addProperty(
	pht('Starts'),
	phabricator_date($event->getDateFrom(), $viewer));
	$properties->addProperty(
	pht('Ends'),
	phabricator_date($event->getDateTo(), $viewer));
	}
	} else {
	$properties->addProperty(
	pht('Starts'),
	phabricator_datetime($event->getDateFrom(), $viewer));

	$properties->addProperty(
	pht('Ends'),
	phabricator_datetime($event->getDateTo(), $viewer));
	}

	if ($event->getIsRecurring()) {
	$properties->addProperty(
	pht('Recurs'),
	ucwords(idx($event->getRecurrenceFrequency(), 'rule')));
	+
	+ if ($event->getRecurrenceEndDate()) {
	+ $properties->addProperty(
	+ pht('Recurrence Ends'),
	+ phabricator_datetime($event->getRecurrenceEndDate(), $viewer));
	+ }
	+
	if ($event->getInstanceOfEventPHID()) {
	$properties->addProperty(
	pht('Recurrence of Event'),
	$viewer->renderHandle($event->getInstanceOfEventPHID()));
	}
	}

	$properties->addProperty(
	pht('Host'),
	$viewer->renderHandle($event->getUserPHID()));

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

	$icon_display = PhabricatorCalendarIcon::renderIconForChooser(
	$event->getIcon());
	$properties->addProperty(
	pht('Icon'),
	$icon_display);

	$properties->addSectionHeader(
	pht('Description'),
	PHUIPropertyListView::ICON_SUMMARY);
	$properties->addTextContent($event->getDescription());

	return $properties;
	}

	}
	diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	index ea0b886b35..712dd8945d 100644
	--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
	@@ -1,429 +1,431 @@
	<?php

	final class PhabricatorCalendarEventEditor
	extends PhabricatorApplicationTransactionEditor {

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

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

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

	$types[] = PhabricatorCalendarEventTransaction::TYPE_NAME;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_START_DATE;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_CANCEL;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_INVITE;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_ALL_DAY;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_ICON;

	$types[] = PhabricatorCalendarEventTransaction::TYPE_RECURRING;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_FREQUENCY;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT;
	$types[] = PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX;

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

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
	return $object->getIsRecurring();
	case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
	return $object->getRecurrenceFrequency();
	case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
	return $object->getRecurrenceEndDate();
	case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
	return $object->getInstanceOfEventPHID();
	case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
	return $object->getSequenceIndex();
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	return $object->getName();
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	return $object->getDateFrom();
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	return $object->getDateTo();
	case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
	return $object->getDescription();
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	return $object->getIsCancelled();
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	return (int)$object->getIsAllDay();
	case PhabricatorCalendarEventTransaction::TYPE_ICON:
	return $object->getIcon();
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	$map = $xaction->getNewValue();
	$phids = array_keys($map);
	$invitees = mpull($object->getInvitees(), null, 'getInviteePHID');

	$old = array();
	foreach ($phids as $phid) {
	$invitee = idx($invitees, $phid);
	if ($invitee) {
	$old[$phid] = $invitee->getStatus();
	} else {
	$old[$phid] = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
	}
	}
	return $old;
	}

	return parent::getCustomTransactionOldValue($object, $xaction);
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
	case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
	- case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
	case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	case PhabricatorCalendarEventTransaction::TYPE_ICON:
	return $xaction->getNewValue();
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	return (int)$xaction->getNewValue();
	+ case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	return $xaction->getNewValue()->getEpoch();
	}

	return parent::getCustomTransactionNewValue($object, $xaction);
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
	return $object->setIsRecurring($xaction->getNewValue());
	case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
	return $object->setRecurrenceFrequency($xaction->getNewValue());
	- case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
	- return $object->setRecurrenceEndDate($xaction->getNewValue());
	case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
	return $object->setInstanceOfEventPHID($xaction->getNewValue());
	case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
	return $object->setSequenceIndex($xaction->getNewValue());
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	$object->setName($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	$object->setDateFrom($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	$object->setDateTo($xaction->getNewValue());
	return;
	+ case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
	+ $object->setRecurrenceEndDate($xaction->getNewValue());
	+ return;
	case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
	$object->setDescription($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	$object->setIsCancelled((int)$xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	$object->setIsAllDay((int)$xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_ICON:
	$object->setIcon($xaction->getNewValue());
	return;
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	return;
	}

	return parent::applyCustomInternalTransaction($object, $xaction);
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
	case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
	case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
	case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	case PhabricatorCalendarEventTransaction::TYPE_ICON:
	return;
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	$map = $xaction->getNewValue();
	$phids = array_keys($map);
	$invitees = $object->getInvitees();
	$invitees = mpull($invitees, null, 'getInviteePHID');

	foreach ($phids as $phid) {
	$invitee = idx($invitees, $phid);
	if (!$invitee) {
	$invitee = id(new PhabricatorCalendarEventInvitee())
	->setEventPHID($object->getPHID())
	->setInviteePHID($phid)
	->setInviterPHID($this->getActingAsPHID());
	$invitees[] = $invitee;
	}
	$invitee->setStatus($map[$phid])
	->save();
	}
	$object->attachInvitees($invitees);
	return;
	}

	return parent::applyCustomExternalTransaction($object, $xaction);
	}

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

	$object->removeViewerTimezone($this->requireActor());

	return $xactions;
	}

	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 PhabricatorCalendarEventTransaction::TYPE_ICON:
	break;
	case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
	case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
	case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
	case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
	case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
	// For these kinds of changes, we need to invalidate the availabilty
	// caches for all attendees.
	$invalidate_all = true;
	break;
	case PhabricatorCalendarEventTransaction::TYPE_INVITE:
	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) {
	$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 = PhabricatorCalendarEventTransaction::TYPE_START_DATE;
	$end_date_xaction = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
	$start_date = $object->getDateFrom();
	$end_date = $object->getDateTo();
	$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();
	}
	}
	if ($start_date > $end_date) {
	$type = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('End date must be after start date.'),
	null);
	}

	return $errors;
	}

	protected function validateTransaction(
	PhabricatorLiskDAO $object,
	$type,
	array $xactions) {

	$errors = parent::validateTransaction($object, $type, $xactions);

	switch ($type) {
	case PhabricatorCalendarEventTransaction::TYPE_NAME:
	$missing = $this->validateIsEmptyTextField(
	$object->getName(),
	$xactions);

	if ($missing) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Required'),
	pht('Event name is required.'),
	nonempty(last($xactions), null));

	$error->setIsMissingFieldError(true);
	$errors[] = $error;
	}
	break;
	+ case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
	case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
	foreach ($xactions as $xaction) {
	$date_value = $xaction->getNewValue();
	if (!$date_value->isValid()) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('Invalid date.'),
	$xaction);
	}
	}
	break;
	}

	return $errors;
	}

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

	protected function supportsSearch() {
	return true;
	}

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

	$xactions = mfilter($xactions, 'shouldHide', true);
	return $xactions;
	}

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

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

	if ($object->getUserPHID()) {
	$phids[] = $object->getUserPHID();
	}
	$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->addTextSection(
	pht('EVENT DESCRIPTION'),
	$object->getDescription());
	}

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


	return $body;
	}


	}
	diff --git a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	index 23dd2a2cf9..d8374e4726 100644
	--- a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	+++ b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	@@ -1,346 +1,350 @@
	<?php

	final class PhabricatorCalendarEventQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $rangeBegin;
	private $rangeEnd;
	private $inviteePHIDs;
	private $creatorPHIDs;
	private $isCancelled;
	private $instanceSequencePairs;


	private $generateGhosts = false;

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

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

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

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

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

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

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

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

	protected function getDefaultOrderVector() {
	return array('start', 'id');
	}

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

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

	protected function loadPage() {
	$table = new PhabricatorCalendarEvent();
	$conn_r = $table->establishConnection('r');
	$viewer = $this->getViewer();

	$data = queryfx_all(
	$conn_r,
	'SELECT event.* FROM %T event %Q %Q %Q %Q %Q',
	$table->getTableName(),
	$this->buildJoinClause($conn_r),
	$this->buildWhereClause($conn_r),
	$this->buildGroupClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	$events = $table->loadAllFromArray($data);

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

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

	$map = array();
	$instance_sequence_pairs = array();

	foreach ($events as $event) {
	$sequence_start = 0;
	- $instance_count = null;
	+ $sequence_end = null;
	$duration = $event->getDateTo() - $event->getDateFrom();
	+ $end = null;

	if ($event->getIsRecurring() && !$event->getInstanceOfEventPHID()) {
	$frequency = $event->getFrequencyUnit();
	$modify_key = '+1 '.$frequency;

	if ($this->rangeBegin && $this->rangeBegin > $event->getDateFrom()) {
	$max_date = $this->rangeBegin - $duration;
	$date = $event->getDateFrom();
	$datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);

	while ($date < $max_date) {
	// TODO: optimize this to not loop through all off-screen events
	$sequence_start++;
	$datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
	$date = $datetime->modify($modify_key)->format('U');
	}

	$start = $this->rangeBegin;
	} else {
	$start = $event->getDateFrom() - $duration;
	}

	$date = $start;
	- $start_datetime = PhabricatorTime::getDateTimeFromEpoch(
	- $start,
	- $viewer);
	+ $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);

	- if ($this->rangeEnd) {
	+ if (($this->rangeEnd && $event->getRecurrenceEndDate()) &&
	+ $this->rangeEnd < $event->getRecurrenceEndDate()) {
	$end = $this->rangeEnd;
	- $instance_count = $sequence_start;
	+ } else if ($event->getRecurrenceEndDate()) {
	+ $end = $event->getRecurrenceEndDate();
	+ } else if ($this->rangeEnd) {
	+ $end = $this->rangeEnd;
	+ }

	+ if ($end) {
	+ $sequence_end = $sequence_start;
	while ($date < $end) {
	- $instance_count++;
	- $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
	+ $sequence_end++;
	$datetime->modify($modify_key);
	$date = $datetime->format('U');
	}
	} else {
	- $instance_count = $this->getRawResultLimit();
	+ $sequence_end = $this->getRawResultLimit() + $sequence_start;
	}

	$sequence_start = max(1, $sequence_start);

	- $max_sequence = $sequence_start + $instance_count;
	- for ($index = $sequence_start; $index < $max_sequence; $index++) {
	+ for ($index = $sequence_start; $index < $sequence_end; $index++) {
	$instance_sequence_pairs[] = array($event->getPHID(), $index);
	$events[] = $event->generateNthGhost($index, $viewer);

	$key = last_key($events);
	$map[$event->getPHID()][$index] = $key;
	}
	}
	}

	if (count($instance_sequence_pairs) > 0) {
	$sub_query = id(new PhabricatorCalendarEventQuery())
	->setViewer($viewer)
	->setParentQuery($this)
	->withInstanceSequencePairs($instance_sequence_pairs)
	->execute();

	foreach ($sub_query as $edited_ghost) {
	$indexes = idx($map, $edited_ghost->getInstanceOfEventPHID());
	$key = idx($indexes, $edited_ghost->getSequenceIndex());
	$events[$key] = $edited_ghost;
	}

	$id_map = array();
	foreach ($events as $key => $event) {
	if ($event->getIsGhostEvent()) {
	continue;
	}
	if (isset($id_map[$event->getID()])) {
	unset($events[$key]);
	} else {
	$id_map[$event->getID()] = true;
	}
	}
	}

	return $events;
	}

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

	protected function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

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

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

	if ($this->rangeBegin) {
	$where[] = qsprintf(
	$conn_r,
	'event.dateTo >= %d OR event.isRecurring = 1',
	$this->rangeBegin);
	}

	if ($this->rangeEnd) {
	$where[] = qsprintf(
	$conn_r,
	'event.dateFrom <= %d',
	$this->rangeEnd);
	}

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

	if ($this->creatorPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'event.userPHID IN (%Ls)',
	$this->creatorPHIDs);
	}

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

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

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

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

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

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

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

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


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

	foreach ($events as $key => $event) {
	$event_start = $event->getDateFrom();
	$event_end = $event->getDateTo();

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

	$phids = array();

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

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

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

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

	return $events;
	}

	}
	diff --git a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	index 24c77b096e..321e0e1439 100644
	--- a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	+++ b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	@@ -1,514 +1,513 @@
	<?php

	final class PhabricatorCalendarEventSearchEngine
	extends PhabricatorApplicationSearchEngine {

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

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

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

	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$saved = new PhabricatorSavedQuery();

	$saved->setParameter(
	'rangeStart',
	$this->readDateFromRequest($request, 'rangeStart'));

	$saved->setParameter(
	'rangeEnd',
	$this->readDateFromRequest($request, 'rangeEnd'));

	$saved->setParameter(
	'upcoming',
	$this->readBoolFromRequest($request, 'upcoming'));

	$saved->setParameter(
	'invitedPHIDs',
	$this->readUsersFromRequest($request, 'invited'));

	$saved->setParameter(
	'creatorPHIDs',
	$this->readUsersFromRequest($request, 'creators'));

	$saved->setParameter(
	'isCancelled',
	$request->getStr('isCancelled'));

	$saved->setParameter(
	'display',
	$request->getStr('display'));

	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new PhabricatorCalendarEventQuery())
	->setGenerateGhosts(true);
	$viewer = $this->requireViewer();
	$timezone = new DateTimeZone($viewer->getTimezoneIdentifier());

	$min_range = $this->getDateFrom($saved)->getEpoch();
	$max_range = $this->getDateTo($saved)->getEpoch();

	if ($this->isMonthView($saved) \|\|
	$this->isDayView($saved)) {
	list($start_year, $start_month, $start_day) =
	$this->getDisplayYearAndMonthAndDay($saved);

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

	if ($this->isMonthView($saved)) {
	$next->modify('+1 month');
	} else if ($this->isDayView($saved)) {
	$next->modify('+6 day');
	}

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

	$preferences = $viewer->loadPreferences();
	$pref_week_day = PhabricatorUserPreferences::PREFERENCE_WEEK_START_DAY;

	$start_of_week = $preferences->getPreference($pref_week_day, 0);
	$end_of_week = ($start_of_week + 6) % 7;

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

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

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

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

	}
	}

	if ($saved->getParameter('upcoming')) {
	if ($min_range) {
	$min_range = max(time(), $min_range);
	} else {
	$min_range = time();
	}
	}

	if ($min_range \|\| $max_range) {
	$query->withDateRange($min_range, $max_range);
	}

	$invited_phids = $saved->getParameter('invitedPHIDs');
	if ($invited_phids) {
	$query->withInvitedPHIDs($invited_phids);
	}

	$creator_phids = $saved->getParameter('creatorPHIDs');
	if ($creator_phids) {
	$query->withCreatorPHIDs($creator_phids);
	}

	$is_cancelled = $saved->getParameter('isCancelled', 'active');

	switch ($is_cancelled) {
	case 'active':
	$query->withIsCancelled(false);
	break;
	case 'cancelled':
	$query->withIsCancelled(true);
	break;
	}

	return $query;
	}

	public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved) {

	$range_start = $this->getDateFrom($saved);
	$e_start = null;

	$range_end = $this->getDateTo($saved);
	$e_end = null;

	if (!$range_start->isValid()) {
	$this->addError(pht('Start date is not valid.'));
	$e_start = pht('Invalid');
	}

	if (!$range_end->isValid()) {
	$this->addError(pht('End date is not valid.'));
	$e_end = pht('Invalid');
	}

	$start_epoch = $range_start->getEpoch();
	$end_epoch = $range_end->getEpoch();

	if ($start_epoch && $end_epoch && ($start_epoch > $end_epoch)) {
	$this->addError(pht('End date must be after start date.'));
	$e_start = pht('Invalid');
	$e_end = pht('Invalid');
	}

	$upcoming = $saved->getParameter('upcoming');
	$is_cancelled = $saved->getParameter('isCancelled', 'active');
	$display = $saved->getParameter('display', 'month');

	$invited_phids = $saved->getParameter('invitedPHIDs', array());
	$creator_phids = $saved->getParameter('creatorPHIDs', array());
	$resolution_types = array(
	'active' => pht('Active Events Only'),
	'cancelled' => pht('Cancelled Events Only'),
	'both' => pht('Both Cancelled and Active Events'),
	);
	$display_options = array(
	'month' => pht('Month View'),
	'day' => pht('Day View (beta)'),
	'list' => pht('List View'),
	);

	$form
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorPeopleDatasource())
	->setName('creators')
	->setLabel(pht('Created By'))
	->setValue($creator_phids))
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorPeopleDatasource())
	->setName('invited')
	->setLabel(pht('Invited'))
	->setValue($invited_phids))
	->appendChild(
	id(new AphrontFormDateControl())
	->setLabel(pht('Occurs After'))
	->setUser($this->requireViewer())
	->setName('rangeStart')
	->setError($e_start)
	->setValue($range_start))
	->appendChild(
	id(new AphrontFormDateControl())
	->setLabel(pht('Occurs Before'))
	->setUser($this->requireViewer())
	->setName('rangeEnd')
	->setError($e_end)
	->setValue($range_end))
	->appendChild(
	id(new AphrontFormCheckboxControl())
	->addCheckbox(
	'upcoming',
	1,
	pht('Show only upcoming events.'),
	$upcoming))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Cancelled Events'))
	->setName('isCancelled')
	->setValue($is_cancelled)
	->setOptions($resolution_types))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Display Options'))
	->setName('display')
	->setValue($display)
	->setOptions($display_options));
	}

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

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

	return $names;
	}

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

	return $this;
	}

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

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

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $objects,
	PhabricatorSavedQuery $query) {
	$phids = array();
	foreach ($objects as $event) {
	$phids[$event->getUserPHID()] = 1;
	}
	return array_keys($phids);
	}

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

	if ($this->isMonthView($query)) {
	return $this->buildCalendarView($events, $query, $handles);
	} else if ($this->isDayView($query)) {
	return $this->buildCalendarDayView($events, $query, $handles);
	}

	assert_instances_of($events, 'PhabricatorCalendarEvent');
	$viewer = $this->requireViewer();
	$list = new PHUIObjectItemListView();
	foreach ($events as $event) {
	$from = phabricator_datetime($event->getDateFrom(), $viewer);
	$to = phabricator_datetime($event->getDateTo(), $viewer);
	$creator_handle = $handles[$event->getUserPHID()];

	$item = id(new PHUIObjectItemView())
	->setHeader($event->getName())
	->setHref($event->getURI())
	->addByline(pht('Creator: %s', $creator_handle->renderLink()))
	->addAttribute(pht('From %s to %s', $from, $to))
	->addAttribute(id(new PhutilUTF8StringTruncator())
	->setMaximumGlyphs(64)
	->truncateString($event->getDescription()));

	$list->addItem($item);
	}

	return $list;
	}

	private function buildCalendarView(
	array $statuses,
	PhabricatorSavedQuery $query,
	array $handles) {
	$viewer = $this->requireViewer();
	$now = time();

	list($start_year, $start_month) =
	$this->getDisplayYearAndMonthAndDay($query);

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

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

	$month_view->setUser($viewer);

	$phids = mpull($statuses, 'getUserPHID');

	foreach ($statuses as $status) {
	$viewer_is_invited = $status->getIsUserInvited($viewer->getPHID());

	$event = new AphrontCalendarEventView();
	$event->setEpochRange($status->getDateFrom(), $status->getDateTo());
	$event->setIsAllDay($status->getIsAllDay());
	$event->setIcon($status->getIcon());

	$name_text = $handles[$status->getUserPHID()]->getName();
	$status_text = $status->getName();
	$event->setUserPHID($status->getUserPHID());
	$event->setDescription(pht('%s (%s)', $name_text, $status_text));
	$event->setName($status_text);
	$event->setURI($status->getURI());
	- // $event->setEventID($status->getID());
	$event->setViewerIsInvited($viewer_is_invited);
	$month_view->addEvent($event);
	}

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

	return $month_view;
	}

	private function buildCalendarDayView(
	array $statuses,
	PhabricatorSavedQuery $query,
	array $handles) {
	$viewer = $this->requireViewer();
	list($start_year, $start_month, $start_day) =
	$this->getDisplayYearAndMonthAndDay($query);

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

	$day_view->setUser($viewer);

	$phids = mpull($statuses, 'getUserPHID');

	foreach ($statuses as $status) {
	if ($status->getIsCancelled()) {
	continue;
	}

	$viewer_is_invited = $status->getIsUserInvited($viewer->getPHID());

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

	$event = new AphrontCalendarEventView();
	$event->setCanEdit($can_edit);
	$event->setEventID($status->getID());
	$event->setEpochRange($status->getDateFrom(), $status->getDateTo());
	$event->setIsAllDay($status->getIsAllDay());
	$event->setIcon($status->getIcon());
	$event->setViewerIsInvited($viewer_is_invited);

	$event->setName($status->getName());
	$event->setURI($status->getURI());
	$day_view->addEvent($event);
	}

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

	return $day_view;
	}

	private function getDisplayYearAndMonthAndDay(
	PhabricatorSavedQuery $query) {
	$viewer = $this->requireViewer();
	if ($this->calendarYear && $this->calendarMonth) {
	$start_year = $this->calendarYear;
	$start_month = $this->calendarMonth;
	$start_day = $this->calendarDay ? $this->calendarDay : 1;
	} else {
	$epoch = $this->getDateFrom($query)->getEpoch();
	if (!$epoch) {
	$epoch = $this->getDateTo($query)->getEpoch();
	if (!$epoch) {
	$epoch = time();
	}
	}
	if ($this->isMonthView($query)) {
	$day = 1;
	} else {
	$day = phabricator_format_local_time($epoch, $viewer, 'd');
	}
	$start_year = phabricator_format_local_time($epoch, $viewer, 'Y');
	$start_month = phabricator_format_local_time($epoch, $viewer, 'm');
	$start_day = $day;
	}
	return array($start_year, $start_month, $start_day);
	}

	public function getPageSize(PhabricatorSavedQuery $saved) {
	return $saved->getParameter('limit', 1000);
	}

	private function getDateFrom(PhabricatorSavedQuery $saved) {
	return $this->getDate($saved, 'rangeStart');
	}

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

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

	$wild = $saved->getParameter($key);
	if ($wild) {
	$value = AphrontFormDateControlValue::newFromWild($viewer, $wild);
	} else {
	$value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	PhabricatorTime::getTodayMidnightDateTime($viewer)->format('U'));
	$value->setEnabled(false);
	}

	$value->setOptional(true);

	return $value;
	}

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

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

	return false;
	}
	}
	diff --git a/src/view/form/control/AphrontFormDateControl.php b/src/view/form/control/AphrontFormDateControl.php
	index ac026d410b..7a742efaf1 100644
	--- a/src/view/form/control/AphrontFormDateControl.php
	+++ b/src/view/form/control/AphrontFormDateControl.php
	@@ -1,334 +1,339 @@
	<?php

	final class AphrontFormDateControl extends AphrontFormControl {

	private $initialTime;
	private $zone;

	private $valueDate;
	private $valueTime;
	private $allowNull;
	private $continueOnInvalidDate = false;
	private $isTimeDisabled;
	private $isDisabled;
	private $endDateID;

	public function setAllowNull($allow_null) {
	$this->allowNull = $allow_null;
	return $this;
	}

	public function setIsTimeDisabled($is_disabled) {
	$this->isTimeDisabled = $is_disabled;
	return $this;
	}

	+ public function setIsDisabled($is_datepicker_disabled) {
	+ $this->isDisabled = $is_datepicker_disabled;
	+ return $this;
	+ }
	+
	public function setEndDateID($value) {
	$this->endDateID = $value;
	return $this;
	}

	const TIME_START_OF_DAY = 'start-of-day';
	const TIME_END_OF_DAY = 'end-of-day';
	const TIME_START_OF_BUSINESS = 'start-of-business';
	const TIME_END_OF_BUSINESS = 'end-of-business';

	public function setInitialTime($time) {
	$this->initialTime = $time;
	return $this;
	}

	public function readValueFromRequest(AphrontRequest $request) {
	$date = $request->getStr($this->getDateInputName());
	$time = $request->getStr($this->getTimeInputName());
	$enabled = $request->getBool($this->getCheckboxInputName());

	if ($this->allowNull && !$enabled) {
	$this->setError(null);
	$this->setValue(null);
	return;
	}

	$err = $this->getError();

	if ($date \|\| $time) {
	$this->valueDate = $date;
	$this->valueTime = $time;

	// Assume invalid.
	$err = 'Invalid';

	$zone = $this->getTimezone();

	try {
	$datetime = new DateTime("{$date} {$time}", $zone);
	$value = $datetime->format('U');
	} catch (Exception $ex) {
	$value = null;
	}

	if ($value) {
	$this->setValue($value);
	$err = null;
	} else {
	$this->setValue(null);
	}
	} else {
	$value = $this->getInitialValue();
	if ($value) {
	$this->setValue($value);
	} else {
	$this->setValue(null);
	}
	}

	$this->setError($err);

	return $this->getValue();
	}

	protected function getCustomControlClass() {
	return 'aphront-form-control-date';
	}

	public function setValue($epoch) {
	if ($epoch instanceof AphrontFormDateControlValue) {
	$this->continueOnInvalidDate = true;
	$this->valueDate = $epoch->getValueDate();
	$this->valueTime = $epoch->getValueTime();
	$this->allowNull = $epoch->getOptional();
	$this->isDisabled = $epoch->isDisabled();

	return parent::setValue($epoch->getEpoch());
	}

	$result = parent::setValue($epoch);

	if ($epoch === null) {
	return $result;
	}

	$readable = $this->formatTime($epoch, 'Y!m!d!g:i A');
	$readable = explode('!', $readable, 4);

	$year = $readable[0];
	$month = $readable[1];
	$day = $readable[2];

	$this->valueDate = $month.'/'.$day.'/'.$year;
	$this->valueTime = $readable[3];

	return $result;
	}

	private function getDateInputValue() {
	return $this->valueDate;
	}

	private function getTimeInputValue() {
	return $this->valueTime;
	}

	private function formatTime($epoch, $fmt) {
	return phabricator_format_local_time(
	$epoch,
	$this->user,
	$fmt);
	}

	private function getDateInputName() {
	return $this->getName().'_d';
	}

	private function getTimeInputName() {
	return $this->getName().'_t';
	}

	private function getCheckboxInputName() {
	return $this->getName().'_e';
	}

	protected function renderInput() {

	$disabled = null;
	if ($this->getValue() === null && !$this->continueOnInvalidDate) {
	$this->setValue($this->getInitialValue());
	if ($this->allowNull) {
	$disabled = 'disabled';
	}
	}

	if ($this->isDisabled) {
	$disabled = 'disabled';
	}

	$checkbox = null;
	if ($this->allowNull) {
	$checkbox = javelin_tag(
	'input',
	array(
	'type' => 'checkbox',
	'name' => $this->getCheckboxInputName(),
	'sigil' => 'calendar-enable',
	'class' => 'aphront-form-date-enabled-input',
	'value' => 1,
	'checked' => ($disabled === null ? 'checked' : null),
	));
	}

	$date_sel = javelin_tag(
	'input',
	array(
	'autocomplete' => 'off',
	'name' => $this->getDateInputName(),
	'sigil' => 'date-input',
	'value' => $this->getDateInputValue(),
	'type' => 'text',
	'class' => 'aphront-form-date-input',
	),
	'');

	$date_div = javelin_tag(
	'div',
	array(
	'class' => 'aphront-form-date-input-container',
	),
	$date_sel);

	$cicon = id(new PHUIIconView())
	->setIconFont('fa-calendar');

	$cal_icon = javelin_tag(
	'a',
	array(
	'href' => '#',
	'class' => 'calendar-button',
	'sigil' => 'calendar-button',
	),
	$cicon);

	$values = $this->getTimeTypeaheadValues();

	$time_id = celerity_generate_unique_node_id();
	Javelin::initBehavior('time-typeahead', array(
	'startTimeID' => $time_id,
	'endTimeID' => $this->endDateID,
	'timeValues' => $values,
	));


	$time_sel = javelin_tag(
	'input',
	array(
	'autocomplete' => 'off',
	'name' => $this->getTimeInputName(),
	'sigil' => 'time-input',
	'value' => $this->getTimeInputValue(),
	'type' => 'text',
	'class' => 'aphront-form-time-input',
	),
	'');

	$time_div = javelin_tag(
	'div',
	array(
	'id' => $time_id,
	'class' => 'aphront-form-time-input-container',
	),
	$time_sel);

	Javelin::initBehavior('fancy-datepicker', array());

	$classes = array();
	$classes[] = 'aphront-form-date-container';
	if ($disabled) {
	$classes[] = 'datepicker-disabled';
	}
	if ($this->isTimeDisabled) {
	$classes[] = 'no-time';
	}

	return javelin_tag(
	'div',
	array(
	'class' => implode(' ', $classes),
	'sigil' => 'phabricator-date-control',
	'meta' => array(
	'disabled' => (bool)$disabled,
	),
	'id' => $this->getID(),
	),
	array(
	$checkbox,
	$date_div,
	$cal_icon,
	$time_div,
	));
	}

	private function getTimezone() {
	if ($this->zone) {
	return $this->zone;
	}

	$user = $this->getUser();
	if (!$this->getUser()) {
	throw new PhutilInvalidStateException('setUser');
	}

	$user_zone = $user->getTimezoneIdentifier();
	$this->zone = new DateTimeZone($user_zone);
	return $this->zone;
	}

	private function getInitialValue() {
	$zone = $this->getTimezone();

	// TODO: We could eventually allow these to be customized per install or
	// per user or both, but let's wait and see.
	switch ($this->initialTime) {
	case self::TIME_START_OF_DAY:
	default:
	$time = '12:00 AM';
	break;
	case self::TIME_START_OF_BUSINESS:
	$time = '9:00 AM';
	break;
	case self::TIME_END_OF_BUSINESS:
	$time = '5:00 PM';
	break;
	case self::TIME_END_OF_DAY:
	$time = '11:59 PM';
	break;
	}

	$today = $this->formatTime(time(), 'Y-m-d');
	try {
	$date = new DateTime("{$today} {$time}", $zone);
	$value = $date->format('U');
	} catch (Exception $ex) {
	$value = null;
	}

	return $value;
	}

	private function getTimeTypeaheadValues() {
	$times = array();
	$am_pm_list = array('AM', 'PM');

	foreach ($am_pm_list as $am_pm) {
	for ($hour = 0; $hour < 12; $hour++) {
	$actual_hour = ($hour == 0) ? 12 : $hour;
	$times[] = $actual_hour.':00 '.$am_pm;
	$times[] = $actual_hour.':30 '.$am_pm;
	}
	}

	foreach ($times as $key => $time) {
	$times[$key] = array($key, $time);
	}
	return $times;
	}

	}
	diff --git a/webroot/rsrc/js/application/calendar/behavior-recurring-edit.js b/webroot/rsrc/js/application/calendar/behavior-recurring-edit.js
	index ee5c916d2c..6ce29bdf6b 100644
	--- a/webroot/rsrc/js/application/calendar/behavior-recurring-edit.js
	+++ b/webroot/rsrc/js/application/calendar/behavior-recurring-edit.js
	@@ -1,14 +1,21 @@
	/**
	* @provides javelin-behavior-recurring-edit
	*/


	JX.behavior('recurring-edit', function(config) {
	var checkbox = JX.$(config.isRecurring);
	+
	JX.DOM.listen(checkbox, 'change', null, function() {
	var frequency = JX.$(config.frequency);
	+ var end_date = JX.$(config.recurrenceEndDate);

	frequency.disabled = checkbox.checked ? false : true;
	+ end_date.disabled = checkbox.checked ? false : true;
	+
	+ if (end_date.disabled) {
	+ JX.DOM.alterClass(end_date, 'datepicker-disabled', !checkbox.checked);
	+ }
	});

	});

File Metadata

Mime Type: text/x-diff
Expires: Tue, Dec 2, 4:21 PM (14 h, 1 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 432222
Default Alt Text: (80 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions