No OneTemporary
Actions

Size

23 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/calendar/controller/PhabricatorCalendarImportViewController.php b/src/applications/calendar/controller/PhabricatorCalendarImportViewController.php
	index 12744cf61e..92da19d61b 100644
	--- a/src/applications/calendar/controller/PhabricatorCalendarImportViewController.php
	+++ b/src/applications/calendar/controller/PhabricatorCalendarImportViewController.php
	@@ -1,133 +1,178 @@
	<?php

	final class PhabricatorCalendarImportViewController
	extends PhabricatorCalendarController {

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getViewer();

	$import = id(new PhabricatorCalendarImportQuery())
	->setViewer($viewer)
	->withIDs(array($request->getURIData('id')))
	->executeOne();
	if (!$import) {
	return new Aphront404Response();
	}

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(
	pht('Imports'),
	'/calendar/import/');
	$crumbs->addTextCrumb(pht('Import %d', $import->getID()));
	$crumbs->setBorder(true);

	$timeline = $this->buildTransactionTimeline(
	$import,
	new PhabricatorCalendarImportTransactionQuery());
	$timeline->setShouldTerminate(true);

	$header = $this->buildHeaderView($import);
	$curtain = $this->buildCurtain($import);
	$details = $this->buildPropertySection($import);

	+ $imported_events = $this->buildImportedEvents($import);
	+
	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setMainColumn(
	array(
	+ $imported_events,
	$timeline,
	))
	->setCurtain($curtain)
	->addPropertySection(pht('Details'), $details);

	$page_title = pht(
	'Import %d %s',
	$import->getID(),
	$import->getDisplayName());

	return $this->newPage()
	->setTitle($page_title)
	->setCrumbs($crumbs)
	->setPageObjectPHIDs(array($import->getPHID()))
	->appendChild($view);
	}

	private function buildHeaderView(
	PhabricatorCalendarImport $import) {
	$viewer = $this->getViewer();
	$id = $import->getID();

	if ($import->getIsDisabled()) {
	$icon = 'fa-ban';
	$color = 'red';
	$status = pht('Disabled');
	} else {
	$icon = 'fa-check';
	$color = 'bluegrey';
	$status = pht('Active');
	}

	$header = id(new PHUIHeaderView())
	->setViewer($viewer)
	->setHeader($import->getDisplayName())
	->setStatus($icon, $color, $status)
	->setPolicyObject($import);

	return $header;
	}

	private function buildCurtain(PhabricatorCalendarImport $import) {
	$viewer = $this->getViewer();
	$id = $import->getID();

	$curtain = $this->newCurtainView($import);
	$engine = $import->getEngine();

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

	$edit_uri = "import/edit/{$id}/";
	$edit_uri = $this->getApplicationURI($edit_uri);

	$can_disable = ($can_edit && $engine->canDisable($viewer, $import));

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Import'))
	->setIcon('fa-pencil')
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit)
	->setHref($edit_uri));

	$disable_uri = "import/disable/{$id}/";
	$disable_uri = $this->getApplicationURI($disable_uri);
	if ($import->getIsDisabled()) {
	$disable_name = pht('Enable Import');
	$disable_icon = 'fa-check';
	} else {
	$disable_name = pht('Disable Import');
	$disable_icon = 'fa-ban';
	}

	$curtain->addAction(
	id(new PhabricatorActionView())
	->setName($disable_name)
	->setIcon($disable_icon)
	->setDisabled(!$can_disable)
	->setWorkflow(true)
	->setHref($disable_uri));

	return $curtain;
	}

	private function buildPropertySection(
	PhabricatorCalendarImport $import) {
	$viewer = $this->getViewer();

	$properties = id(new PHUIPropertyListView())
	->setViewer($viewer);

	return $properties;
	}
	+
	+ private function buildImportedEvents(
	+ PhabricatorCalendarImport $import) {
	+ $viewer = $this->getViewer();
	+
	+ $engine = id(new PhabricatorCalendarEventSearchEngine())
	+ ->setViewer($viewer);
	+
	+ $saved = $engine->newSavedQuery()
	+ ->setParameter('importSourcePHIDs', array($import->getPHID()));
	+
	+ $pager = $engine->newPagerForSavedQuery($saved);
	+ $pager->setPageSize(25);
	+
	+ $query = $engine->buildQueryFromSavedQuery($saved);
	+
	+ $results = $engine->executeQuery($query, $pager);
	+ $view = $engine->renderResults($results, $saved);
	+ $list = $view->getObjectList();
	+ $list->setNoDataString(pht('No imported events.'));
	+
	+ $all_uri = $this->getApplicationURI();
	+ $all_uri = (string)id(new PhutilURI($all_uri))
	+ ->setQueryParam('importSourcePHID', $import->getPHID())
	+ ->setQueryParam('display', 'list');
	+
	+ $all_button = id(new PHUIButtonView())
	+ ->setTag('a')
	+ ->setText(pht('View All'))
	+ ->setIcon('fa-search')
	+ ->setHref($all_uri);
	+
	+ $header = id(new PHUIHeaderView())
	+ ->setHeader(pht('Imported Events'))
	+ ->addActionLink($all_button);
	+
	+ return id(new PHUIObjectBoxView())
	+ ->setHeader($header)
	+ ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	+ ->setObjectList($list);
	+ }
	+
	}
	diff --git a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	index a29b7ea37a..8d55da994a 100644
	--- a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	+++ b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
	@@ -1,591 +1,599 @@
	<?php

	final class PhabricatorCalendarEventSearchEngine
	extends PhabricatorApplicationSearchEngine {

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

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

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

	public function newQuery() {
	return new PhabricatorCalendarEventQuery();
	}

	protected function shouldShowOrderField() {
	return false;
	}

	protected function buildCustomSearchFields() {
	return array(
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Hosts'))
	->setKey('hostPHIDs')
	->setAliases(array('host', 'hostPHID', 'hosts'))
	->setDatasource(new PhabricatorPeopleUserFunctionDatasource()),
	id(new PhabricatorSearchDatasourceField())
	->setLabel(pht('Invited'))
	->setKey('invitedPHIDs')
	->setDatasource(new PhabricatorPeopleUserFunctionDatasource()),
	id(new PhabricatorSearchDateControlField())
	->setLabel(pht('Occurs After'))
	->setKey('rangeStart'),
	id(new PhabricatorSearchDateControlField())
	->setLabel(pht('Occurs Before'))
	->setKey('rangeEnd')
	->setAliases(array('rangeEnd')),
	id(new PhabricatorSearchCheckboxesField())
	->setKey('upcoming')
	->setOptions(array(
	'upcoming' => pht('Show only upcoming events.'),
	)),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Cancelled Events'))
	->setKey('isCancelled')
	->setOptions($this->getCancelledOptions())
	->setDefault('active'),
	+ id(new PhabricatorPHIDsSearchField())
	+ ->setLabel(pht('Import Sources'))
	+ ->setKey('importSourcePHIDs')
	+ ->setAliases(array('importSourcePHID')),
	id(new PhabricatorSearchSelectField())
	->setLabel(pht('Display Options'))
	->setKey('display')
	->setOptions($this->getViewOptions())
	->setDefault('month'),
	);
	}

	private function getCancelledOptions() {
	return array(
	'active' => pht('Active Events Only'),
	'cancelled' => pht('Cancelled Events Only'),
	'both' => pht('Both Cancelled and Active Events'),
	);
	}

	private function getViewOptions() {
	return array(
	'month' => pht('Month View'),
	'day' => pht('Day View'),
	'list' => pht('List View'),
	);
	}

	protected function buildQueryFromParameters(array $map) {
	$query = $this->newQuery();
	$viewer = $this->requireViewer();

	if ($map['hostPHIDs']) {
	$query->withHostPHIDs($map['hostPHIDs']);
	}

	if ($map['invitedPHIDs']) {
	$query->withInvitedPHIDs($map['invitedPHIDs']);
	}

	$range_start = $map['rangeStart'];
	$range_end = $map['rangeEnd'];
	$display = $map['display'];

	if ($map['upcoming'] && $map['upcoming'][0] == 'upcoming') {
	$upcoming = true;
	} else {
	$upcoming = false;
	}

	list($range_start, $range_end) = $this->getQueryDateRange(
	$range_start,
	$range_end,
	$display,
	$upcoming);

	$query->withDateRange($range_start, $range_end);

	switch ($map['isCancelled']) {
	case 'active':
	$query->withIsCancelled(false);
	break;
	case 'cancelled':
	$query->withIsCancelled(true);
	break;
	}

	+ if ($map['importSourcePHIDs']) {
	+ $query->withImportSourcePHIDs($map['importSourcePHIDs']);
	+ }
	+
	// Generate ghosts (and ignore stub events) if we aren't querying for
	// specific events or exporting.
	if (!empty($map['export'])) {
	// This is a specific mode enabled by event exports.
	$query
	->withIsStub(false);
	} else if (!$map['ids'] && !$map['phids']) {
	$query
	->withIsStub(false)
	->setGenerateGhosts(true);
	}

	return $query;
	}

	private function getQueryDateRange(
	$start_date_wild,
	$end_date_wild,
	$display,
	$upcoming) {

	$start_date_value = $this->getSafeDate($start_date_wild);
	$end_date_value = $this->getSafeDate($end_date_wild);

	$viewer = $this->requireViewer();
	$timezone = new DateTimeZone($viewer->getTimezoneIdentifier());
	$min_range = null;
	$max_range = null;

	$min_range = $start_date_value->getEpoch();
	$max_range = $end_date_value->getEpoch();

	if ($display == 'month' \|\| $display == 'day') {
	list($start_year, $start_month, $start_day) =
	$this->getDisplayYearAndMonthAndDay($min_range, $max_range, $display);

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

	if ($display == 'month') {
	$next->modify('+1 month');
	} else if ($display == 'day') {
	$next->modify('+7 day');
	}

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

	$start_of_week = $viewer->getUserSetting(
	PhabricatorWeekStartDaySetting::SETTINGKEY);

	$end_of_week = ($start_of_week + 6) % 7;

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

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

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

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

	if ($upcoming) {
	$now = PhabricatorTime::getNow();
	if ($min_range) {
	$min_range = max($now, $min_range);
	} else {
	$min_range = $now;
	}
	}

	return array($min_range, $max_range);
	}

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

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

	return $names;
	}

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

	return $this;
	}

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

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

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

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

	if ($this->isMonthView($query)) {
	$result = $this->buildCalendarMonthView($events, $query);
	} else if ($this->isDayView($query)) {
	$result = $this->buildCalendarDayView($events, $query);
	} else {
	$result = $this->buildCalendarListView($events, $query);
	}

	return $result;
	}

	private function buildCalendarListView(
	array $events,
	PhabricatorSavedQuery $query) {

	assert_instances_of($events, 'PhabricatorCalendarEvent');
	$viewer = $this->requireViewer();
	$list = new PHUIObjectItemListView();

	foreach ($events as $event) {
	if ($event->getIsGhostEvent()) {
	$monogram = $event->getParentEvent()->getMonogram();
	$index = $event->getSequenceIndex();
	$monogram = "{$monogram}/{$index}";
	} else {
	$monogram = $event->getMonogram();
	}

	$item = id(new PHUIObjectItemView())
	->setUser($viewer)
	->setObject($event)
	->setObjectName($monogram)
	->setHeader($event->getName())
	->setHref($event->getURI());

	$item->addAttribute($event->renderEventDate($viewer, false));

	if ($event->isCancelledEvent()) {
	$item->setDisabled(true);
	}

	$status_icon = $event->getDisplayIcon($viewer);
	$status_color = $event->getDisplayIconColor($viewer);
	$status_label = $event->getDisplayIconLabel($viewer);

	$item->setStatusIcon("{$status_icon} {$status_color}", $status_label);

	$host = pht(
	'Hosted by %s',
	$viewer->renderHandle($event->getHostPHID()));
	$item->addByline($host);

	$list->addItem($item);
	}

	$result = new PhabricatorApplicationSearchResultView();
	$result->setObjectList($list);
	$result->setNoDataString(pht('No events found.'));

	return $result;
	}

	private function buildCalendarMonthView(
	array $events,
	PhabricatorSavedQuery $query) {
	assert_instances_of($events, 'PhabricatorCalendarEvent');

	$viewer = $this->requireViewer();
	$now = PhabricatorTime::getNow();

	list($start_year, $start_month) =
	$this->getDisplayYearAndMonthAndDay(
	$this->getQueryDateFrom($query)->getEpoch(),
	$this->getQueryDateTo($query)->getEpoch(),
	$query->getParameter('display'));

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

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

	$month_view->setUser($viewer);

	foreach ($events as $event) {
	$epoch_min = $event->getStartDateTimeEpoch();
	$epoch_max = $event->getEndDateTimeEpoch();

	$event_view = id(new AphrontCalendarEventView())
	->setHostPHID($event->getHostPHID())
	->setEpochRange($epoch_min, $epoch_max)
	->setIsCancelled($event->isCancelledEvent())
	->setName($event->getName())
	->setURI($event->getURI())
	->setIsAllDay($event->getIsAllDay())
	->setIcon($event->getDisplayIcon($viewer))
	->setIconColor($event->getDisplayIconColor($viewer));

	$month_view->addEvent($event_view);
	}

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

	$from = $this->getQueryDateFrom($query)->getDateTime();

	$crumbs = array();
	$crumbs[] = id(new PHUICrumbView())
	->setName($from->format('F Y'));

	$header = id(new PHUIHeaderView())
	->setProfileHeader(true)
	->setHeader($from->format('F Y'));

	return id(new PhabricatorApplicationSearchResultView())
	->setCrumbs($crumbs)
	->setHeader($header)
	->setContent($month_view);
	}

	private function buildCalendarDayView(
	array $events,
	PhabricatorSavedQuery $query) {

	$viewer = $this->requireViewer();

	list($start_year, $start_month, $start_day) =
	$this->getDisplayYearAndMonthAndDay(
	$this->getQueryDateFrom($query)->getEpoch(),
	$this->getQueryDateTo($query)->getEpoch(),
	$query->getParameter('display'));

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

	$day_view->setUser($viewer);

	$phids = mpull($events, 'getHostPHID');

	foreach ($events as $event) {
	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$event,
	PhabricatorPolicyCapability::CAN_EDIT);

	$epoch_min = $event->getStartDateTimeEpoch();
	$epoch_max = $event->getEndDateTimeEpoch();

	$status_icon = $event->getDisplayIcon($viewer);
	$status_color = $event->getDisplayIconColor($viewer);

	$event_view = id(new AphrontCalendarEventView())
	->setCanEdit($can_edit)
	->setEventID($event->getID())
	->setEpochRange($epoch_min, $epoch_max)
	->setIsAllDay($event->getIsAllDay())
	->setIcon($status_icon)
	->setIconColor($status_color)
	->setName($event->getName())
	->setURI($event->getURI())
	->setIsCancelled($event->isCancelledEvent());

	$day_view->addEvent($event_view);
	}

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

	$from = $this->getQueryDateFrom($query)->getDateTime();
	$month_uri = $browse_uri.$from->format('Y/m/');

	$crumbs = array(
	id(new PHUICrumbView())
	->setName($from->format('F Y'))
	->setHref($month_uri),
	id(new PHUICrumbView())
	->setName($from->format('D jS')),
	);

	$header = id(new PHUIHeaderView())
	->setProfileHeader(true)
	->setHeader($from->format('D, F jS'));

	return id(new PhabricatorApplicationSearchResultView())
	->setCrumbs($crumbs)
	->setHeader($header)
	->setContent($day_view);
	}

	private function getDisplayYearAndMonthAndDay(
	$range_start,
	$range_end,
	$display) {

	$viewer = $this->requireViewer();
	$epoch = null;

	if ($this->calendarYear && $this->calendarMonth) {
	$start_year = $this->calendarYear;
	$start_month = $this->calendarMonth;
	$start_day = $this->calendarDay ? $this->calendarDay : 1;
	} else {
	if ($range_start) {
	$epoch = $range_start;
	} else if ($range_end) {
	$epoch = $range_end;
	} else {
	$epoch = time();
	}
	if ($display == 'month') {
	$day = 1;
	} else {
	$day = phabricator_format_local_time($epoch, $viewer, 'd');
	}
	$start_year = phabricator_format_local_time($epoch, $viewer, 'Y');
	$start_month = phabricator_format_local_time($epoch, $viewer, 'm');
	$start_day = $day;
	}
	return array($start_year, $start_month, $start_day);
	}

	public function getPageSize(PhabricatorSavedQuery $saved) {
	if ($this->isMonthView($saved) \|\| $this->isDayView($saved)) {
	return $saved->getParameter('limit', 1000);
	} else {
	return $saved->getParameter('limit', 100);
	}
	}

	private function getQueryDateFrom(PhabricatorSavedQuery $saved) {
	if ($this->calendarYear && $this->calendarMonth) {
	$viewer = $this->requireViewer();

	$start_year = $this->calendarYear;
	$start_month = $this->calendarMonth;
	$start_day = $this->calendarDay ? $this->calendarDay : 1;

	return AphrontFormDateControlValue::newFromDictionary(
	$viewer,
	array(
	'd' => "{$start_year}-{$start_month}-{$start_day}",
	));
	}

	return $this->getQueryDate($saved, 'rangeStart');
	}

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

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

	$wild = $saved->getParameter($key);
	return $this->getSafeDate($wild);
	}

	private function getSafeDate($value) {
	$viewer = $this->requireViewer();
	if ($value) {
	// ideally this would be consistent and always pass in the same type
	if ($value instanceof AphrontFormDateControlValue) {
	return $value;
	} else {
	$value = AphrontFormDateControlValue::newFromWild($viewer, $value);
	}
	} else {
	$value = AphrontFormDateControlValue::newFromEpoch(
	$viewer,
	PhabricatorTime::getTodayMidnightDateTime($viewer)->format('U'));
	$value->setEnabled(false);
	}

	$value->setOptional(true);

	return $value;
	}

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

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

	return false;
	}

	public function newUseResultsActions(PhabricatorSavedQuery $saved) {
	$viewer = $this->requireViewer();
	$can_export = $viewer->isLoggedIn();

	return array(
	id(new PhabricatorActionView())
	->setIcon('fa-download')
	->setName(pht('Export Query as .ics'))
	->setDisabled(!$can_export)
	->setHref('/calendar/export/edit/?queryKey='.$saved->getQueryKey()),
	);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Jan 19 2025, 22:06 (6 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1129235
Default Alt Text: (23 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions