No OneTemporary
Actions

Size

34 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 33603cde1d..c397340395 100644
	--- a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	+++ b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
	@@ -1,324 +1,326 @@
	<?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()) {
	+ $parent_event = $event;
	$event = $event->generateNthGhost($sequence, $viewer);
	+ $event->attachParentEvent($parent_event);
	} 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);

	$edit_label = false;
	$edit_uri = false;

	if ($event->getIsGhostEvent()) {
	$index = $event->getSequenceIndex();
	$edit_label = pht('Edit This Instance');
	$edit_uri = "event/edit/{$id}/{$index}/";
	} else if ($event->getInstanceOfEventPHID() && !$event->getIsGhostEvent()) {
	$edit_label = pht('Edit This Instance');
	$edit_uri = "event/edit/{$id}/";
	} else if (!$event->getIsRecurring()) {
	$edit_label = pht('Edit');
	$edit_uri = "event/edit/{$id}/";
	}

	if ($edit_label && $edit_uri) {
	$actions->addAction(
	id(new PhabricatorActionView())
	->setName($edit_label)
	->setIcon('fa-pencil')
	->setHref($this->getApplicationURI($edit_uri))
	->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/query/PhabricatorCalendarEventQuery.php b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	index d8374e4726..850af1ce3f 100644
	--- a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	+++ b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
	@@ -1,350 +1,397 @@
	<?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) {
	+ foreach ($events as $key => $event) {
	$sequence_start = 0;
	$sequence_end = null;
	$duration = $event->getDateTo() - $event->getDateFrom();
	$end = null;

	- if ($event->getIsRecurring() && !$event->getInstanceOfEventPHID()) {
	+ $instance_of = $event->getInstanceOfEventPHID();
	+
	+ if ($instance_of == null && $this->isCancelled !== null) {
	+ if ($event->getIsCancelled() != $this->isCancelled) {
	+ unset($events[$key]);
	+ continue;
	+ }
	+ }
	+
	+ if ($event->getIsRecurring() && $instance_of == null) {
	$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;
	$datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);

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

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

	$sequence_start = max(1, $sequence_start);

	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;
	+ $last_key = last_key($events);
	+ $map[$event->getPHID()][$index] = $last_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;
	+ $instance_of_event_phids = array();
	+ $recurring_events = array();
	+ $viewer = $this->getViewer();

	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();
	+ $instance_of = $event->getInstanceOfEventPHID();
	+
	+ if ($instance_of) {
	+ if ($instance_of != $event->getPHID() \|\| $event->getIsGhostEvent()) {
	+ $instance_of_event_phids[] = $event->getInstanceOfEventPHID();
	+ }
	+ }
	+ }
	+
	+ if (count($instance_of_event_phids) > 0) {
	+ $recurring_events = id(new PhabricatorCalendarEventQuery())
	+ ->setViewer($viewer)
	+ ->withPHIDs($instance_of_event_phids)
	+ ->execute();
	+
	+ $recurring_events = mpull($recurring_events, null, 'getPHID');
	}

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

	- foreach ($events as $event) {
	+ foreach ($events as $key => $event) {
	$event_invitees = idx($invitees, $event->getPHID(), array());
	$event->attachInvitees($event_invitees);
	+
	+ $instance_of = $event->getInstanceOfEventPHID();
	+ if (!$instance_of) {
	+ continue;
	+ }
	+ $parent = idx($recurring_events, $instance_of);
	+
	+ // should never get here
	+ if (!$parent) {
	+ unset($events[$key]);
	+ continue;
	+ }
	+ $event->attachParentEvent($parent);
	+
	+ if ($this->isCancelled !== null) {
	+ if ($event->getIsCancelled() != $this->isCancelled) {
	+ unset($events[$key]);
	+ continue;
	+ }
	+ }
	}

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

	return $events;
	}

	}
	diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	index c3d8e36534..1beff60851 100644
	--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
	@@ -1,480 +1,506 @@
	<?php

	final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
	implements PhabricatorPolicyInterface,
	PhabricatorMarkupInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorSubscribableInterface,
	PhabricatorTokenReceiverInterface,
	PhabricatorDestructibleInterface,
	PhabricatorMentionableInterface,
	PhabricatorFlaggableInterface {

	protected $name;
	protected $userPHID;
	protected $dateFrom;
	protected $dateTo;
	protected $description;
	protected $isCancelled;
	protected $isAllDay;
	protected $icon;
	protected $mailKey;

	protected $isRecurring = 0;
	protected $recurrenceFrequency = array();
	protected $recurrenceEndDate;

	private $isGhostEvent = false;
	protected $instanceOfEventPHID;
	protected $sequenceIndex;

	protected $viewPolicy;
	protected $editPolicy;

	const DEFAULT_ICON = 'fa-calendar';

	+ private $parentEvent = self::ATTACHABLE;
	private $invitees = self::ATTACHABLE;
	private $appliedViewer;

	public static function initializeNewCalendarEvent(
	PhabricatorUser $actor,
	$mode) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorCalendarApplication'))
	->executeOne();

	$view_policy = null;
	$is_recurring = 0;

	if ($mode == 'public') {
	$view_policy = PhabricatorPolicies::getMostOpenPolicy();
	} else if ($mode == 'recurring') {
	$is_recurring = true;
	} else {
	$view_policy = $actor->getPHID();
	}

	return id(new PhabricatorCalendarEvent())
	->setUserPHID($actor->getPHID())
	->setIsCancelled(0)
	->setIsAllDay(0)
	->setIsRecurring($is_recurring)
	->setIcon(self::DEFAULT_ICON)
	->setViewPolicy($view_policy)
	->setEditPolicy($actor->getPHID())
	->attachInvitees(array())
	->applyViewerTimezone($actor);
	}

	public function applyViewerTimezone(PhabricatorUser $viewer) {
	if ($this->appliedViewer) {
	throw new Exception(pht('Viewer timezone is already applied!'));
	}

	$this->appliedViewer = $viewer;

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

	$zone = $viewer->getTimeZone();


	$this->setDateFrom(
	$this->getDateEpochForTimeZone(
	$this->getDateFrom(),
	new DateTimeZone('Pacific/Kiritimati'),
	'Y-m-d',
	null,
	$zone));

	$this->setDateTo(
	$this->getDateEpochForTimeZone(
	$this->getDateTo(),
	new DateTimeZone('Pacific/Midway'),
	'Y-m-d 23:59:00',
	'-1 day',
	$zone));

	return $this;
	}


	public function removeViewerTimezone(PhabricatorUser $viewer) {
	if (!$this->appliedViewer) {
	throw new Exception(pht('Viewer timezone is not applied!'));
	}

	if ($viewer->getPHID() != $this->appliedViewer->getPHID()) {
	throw new Exception(pht('Removed viewer must match applied viewer!'));
	}

	$this->appliedViewer = null;

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

	$zone = $viewer->getTimeZone();

	$this->setDateFrom(
	$this->getDateEpochForTimeZone(
	$this->getDateFrom(),
	$zone,
	'Y-m-d',
	null,
	new DateTimeZone('Pacific/Kiritimati')));

	$this->setDateTo(
	$this->getDateEpochForTimeZone(
	$this->getDateTo(),
	$zone,
	'Y-m-d',
	'+1 day',
	new DateTimeZone('Pacific/Midway')));

	return $this;
	}

	private function getDateEpochForTimeZone(
	$epoch,
	$src_zone,
	$format,
	$adjust,
	$dst_zone) {

	$src = new DateTime('@'.$epoch);
	$src->setTimeZone($src_zone);

	if (strlen($adjust)) {
	$adjust = ' '.$adjust;
	}

	$dst = new DateTime($src->format($format).$adjust, $dst_zone);
	return $dst->format('U');
	}

	public function save() {
	if ($this->appliedViewer) {
	throw new Exception(
	pht(
	'Can not save event with viewer timezone still applied!'));
	}

	if (!$this->mailKey) {
	$this->mailKey = Filesystem::readRandomCharacters(20);
	}

	return parent::save();
	}

	/**
	* Get the event start epoch for evaluating invitee availability.
	*
	* When assessing availability, we pretend events start earlier than they
	* really. This allows us to mark users away for the entire duration of a
	* series of back-to-back meetings, even if they don't strictly overlap.
	*
	* @return int Event start date for availability caches.
	*/
	public function getDateFromForCache() {
	return ($this->getDateFrom() - phutil_units('15 minutes in seconds'));
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'name' => 'text',
	'dateFrom' => 'epoch',
	'dateTo' => 'epoch',
	'description' => 'text',
	'isCancelled' => 'bool',
	'isAllDay' => 'bool',
	'icon' => 'text32',
	'mailKey' => 'bytes20',
	'isRecurring' => 'bool',
	'recurrenceEndDate' => 'epoch?',
	'instanceOfEventPHID' => 'phid?',
	'sequenceIndex' => 'uint32?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'userPHID_dateFrom' => array(
	'columns' => array('userPHID', 'dateTo'),
	),
	'key_instance' => array(
	'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
	'unique' => true,
	),
	),
	self::CONFIG_SERIALIZATION => array(
	'recurrenceFrequency' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

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

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

	public function getInvitees() {
	return $this->assertAttached($this->invitees);
	}

	public function attachInvitees(array $invitees) {
	$this->invitees = $invitees;
	return $this;
	}

	public function 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 generateNthGhost(
	$sequence_index,
	PhabricatorUser $actor) {

	$frequency = $this->getFrequencyUnit();
	$modify_key = '+'.$sequence_index.' '.$frequency;

	$instance_of = ($this->getPHID()) ?
	$this->getPHID() : $this->instanceOfEventPHID;

	$date = $this->dateFrom;
	$date_time = PhabricatorTime::getDateTimeFromEpoch($date, $actor);
	$date_time->modify($modify_key);
	$date = $date_time->format('U');

	$duration = $this->dateTo - $this->dateFrom;

	$edit_policy = PhabricatorPolicies::POLICY_NOONE;

	$ghost_event = id(clone $this)
	->setIsGhostEvent(true)
	->setDateFrom($date)
	->setDateTo($date + $duration)
	->setIsRecurring(true)
	->setRecurrenceFrequency($this->recurrenceFrequency)
	->setInstanceOfEventPHID($instance_of)
	->setSequenceIndex($sequence_index)
	->setEditPolicy($edit_policy);

	return $ghost_event;
	}

	public function getFrequencyUnit() {
	$frequency = idx($this->recurrenceFrequency, 'rule');

	switch ($frequency) {
	case 'daily':
	return 'day';
	case 'weekly':
	return 'week';
	case 'monthly':
	return 'month';
	case 'yearly':
	return 'yearly';
	default:
	return 'day';
	}
	}

	public function getURI() {
	$uri = '/'.$this->getMonogram();
	if ($this->isGhostEvent) {
	$uri = $uri.'/'.$this->sequenceIndex;
	}
	return $uri;
	}

	+ public function getParentEvent() {
	+ return $this->assertAttached($this->parentEvent);
	+ }
	+
	+ public function attachParentEvent($event) {
	+ $this->parentEvent = $event;
	+ return $this;
	+ }
	+
	+ public function getIsCancelled() {
	+ $instance_of = $this->instanceOfEventPHID;
	+ if ($instance_of != null && $this->getIsParentCancelled()) {
	+ return true;
	+ }
	+ return $this->isCancelled;
	+ }
	+
	+ public function getIsParentCancelled() {
	+ $recurring_event = $this->getParentEvent();
	+ if ($recurring_event->getIsCancelled()) {
	+ return true;
	+ }
	+ return false;
	+ }
	+
	/* -( Markup Interface )--------------------------------------------------- */


	/**
	* @task markup
	*/
	public function getMarkupFieldKey($field) {
	$hash = PhabricatorHash::digest($this->getMarkupText($field));
	$id = $this->getID();
	return "calendar:T{$id}:{$field}:{$hash}";
	}


	/**
	* @task markup
	*/
	public function getMarkupText($field) {
	return $this->getDescription();
	}


	/**
	* @task markup
	*/
	public function newMarkupEngine($field) {
	return PhabricatorMarkupEngine::newCalendarMarkupEngine();
	}


	/**
	* @task markup
	*/
	public function didMarkupText(
	$field,
	$output,
	PhutilMarkupEngine $engine) {
	return $output;
	}


	/**
	* @task markup
	*/
	public function shouldUseMarkupCache($field) {
	return (bool)$this->getID();
	}

	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	// The owner of a task can always view and edit it.
	$user_phid = $this->getUserPHID();
	if ($user_phid) {
	$viewer_phid = $viewer->getPHID();
	if ($viewer_phid == $user_phid) {
	return true;
	}
	}

	if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
	$status = $this->getUserInviteStatus($viewer->getPHID());
	if ($status == PhabricatorCalendarEventInvitee::STATUS_INVITED \|\|
	$status == PhabricatorCalendarEventInvitee::STATUS_ATTENDING \|\|
	$status == PhabricatorCalendarEventInvitee::STATUS_DECLINED) {
	return true;
	}
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	return pht('The owner of an event can always view and edit it,
	and invitees can always view it, except if the event is an
	instance of a recurring event.');
	}

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

	public function shouldShowSubscribersProperty() {
	return true;
	}

	public function shouldAllowSubscription($phid) {
	return true;
	}

	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	return array($this->getUserPHID());
	}

	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();
	$this->saveTransaction();
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Dec 2, 8:47 AM (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 431763
Default Alt Text: (34 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions