No OneTemporary
Actions

Size

54 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/search/controller/PhabricatorApplicationSearchController.php b/src/applications/search/controller/PhabricatorApplicationSearchController.php
	index 6b43883c78..286158c4fb 100644
	--- a/src/applications/search/controller/PhabricatorApplicationSearchController.php
	+++ b/src/applications/search/controller/PhabricatorApplicationSearchController.php
	@@ -1,975 +1,978 @@
	<?php

	final class PhabricatorApplicationSearchController
	extends PhabricatorSearchBaseController {

	private $searchEngine;
	private $navigation;
	private $queryKey;
	private $preface;
	private $activeQuery;

	public function setPreface($preface) {
	$this->preface = $preface;
	return $this;
	}

	public function getPreface() {
	return $this->preface;
	}

	public function setQueryKey($query_key) {
	$this->queryKey = $query_key;
	return $this;
	}

	protected function getQueryKey() {
	return $this->queryKey;
	}

	public function setNavigation(AphrontSideNavFilterView $navigation) {
	$this->navigation = $navigation;
	return $this;
	}

	protected function getNavigation() {
	return $this->navigation;
	}

	public function setSearchEngine(
	PhabricatorApplicationSearchEngine $search_engine) {
	$this->searchEngine = $search_engine;
	return $this;
	}

	protected function getSearchEngine() {
	return $this->searchEngine;
	}

	protected function getActiveQuery() {
	if (!$this->activeQuery) {
	throw new Exception(pht('There is no active query yet.'));
	}

	return $this->activeQuery;
	}

	protected function validateDelegatingController() {
	$parent = $this->getDelegatingController();

	if (!$parent) {
	throw new Exception(
	pht('You must delegate to this controller, not invoke it directly.'));
	}

	$engine = $this->getSearchEngine();
	if (!$engine) {
	throw new PhutilInvalidStateException('setEngine');
	}

	$engine->setViewer($this->getRequest()->getUser());

	$parent = $this->getDelegatingController();
	}

	public function processRequest() {
	$this->validateDelegatingController();

	$query_action = $this->getRequest()->getURIData('queryAction');
	if ($query_action == 'export') {
	return $this->processExportRequest();
	}

	$key = $this->getQueryKey();
	if ($key == 'edit') {
	return $this->processEditRequest();
	} else {
	return $this->processSearchRequest();
	}
	}

	private function processSearchRequest() {
	$parent = $this->getDelegatingController();
	$request = $this->getRequest();
	$user = $request->getUser();
	$engine = $this->getSearchEngine();
	$nav = $this->getNavigation();
	if (!$nav) {
	$nav = $this->buildNavigation();
	}

	if ($request->isFormPost()) {
	$saved_query = $engine->buildSavedQueryFromRequest($request);
	$engine->saveQuery($saved_query);
	return id(new AphrontRedirectResponse())->setURI(
	$engine->getQueryResultsPageURI($saved_query->getQueryKey()).'#R');
	}

	$named_query = null;
	$run_query = true;
	$query_key = $this->queryKey;
	if ($this->queryKey == 'advanced') {
	$run_query = false;
	$query_key = $request->getStr('query');
	} else if (!strlen($this->queryKey)) {
	$found_query_data = false;

	if ($request->isHTTPGet() \|\| $request->isQuicksand()) {
	// If this is a GET request and it has some query data, don't
	// do anything unless it's only before= or after=. We'll build and
	// execute a query from it below. This allows external tools to build
	// URIs like "/query/?users=a,b".
	$pt_data = $request->getPassthroughRequestData();

	$exempt = array(
	'before' => true,
	'after' => true,
	'nux' => true,
	'overheated' => true,
	);

	foreach ($pt_data as $pt_key => $pt_value) {
	if (isset($exempt[$pt_key])) {
	continue;
	}

	$found_query_data = true;
	break;
	}
	}

	if (!$found_query_data) {
	// Otherwise, there's no query data so just run the user's default
	// query for this application.
	$query_key = $engine->getDefaultQueryKey();
	}
	}

	if ($engine->isBuiltinQuery($query_key)) {
	$saved_query = $engine->buildSavedQueryFromBuiltin($query_key);
	$named_query = idx($engine->loadEnabledNamedQueries(), $query_key);
	} else if ($query_key) {
	$saved_query = id(new PhabricatorSavedQueryQuery())
	->setViewer($user)
	->withQueryKeys(array($query_key))
	->executeOne();

	if (!$saved_query) {
	return new Aphront404Response();
	}

	$named_query = idx($engine->loadEnabledNamedQueries(), $query_key);
	} else {
	$saved_query = $engine->buildSavedQueryFromRequest($request);

	// Save the query to generate a query key, so "Save Custom Query..." and
	// other features like "Bulk Edit" and "Export Data" work correctly.
	$engine->saveQuery($saved_query);
	}

	$this->activeQuery = $saved_query;

	$nav->selectFilter(
	'query/'.$saved_query->getQueryKey(),
	'query/advanced');

	$form = id(new AphrontFormView())
	->setUser($user)
	->setAction($request->getPath());

	$engine->buildSearchForm($form, $saved_query);

	$errors = $engine->getErrors();
	if ($errors) {
	$run_query = false;
	}

	$submit = id(new AphrontFormSubmitControl())
	->setValue(pht('Search'));

	if ($run_query && !$named_query && $user->isLoggedIn()) {
	$save_button = id(new PHUIButtonView())
	->setTag('a')
	->setHref('/search/edit/key/'.$saved_query->getQueryKey().'/')
	->setText(pht('Save Query'))
	->setIcon('fa-floppy-o');
	$submit->addButton($save_button);
	}

	// TODO: A "Create Dashboard Panel" action goes here somewhere once
	// we sort out T5307.

	$form->appendChild($submit);
	$body = array();

	if ($this->getPreface()) {
	$body[] = $this->getPreface();
	}

	if ($named_query) {
	$title = $named_query->getQueryName();
	} else {
	$title = pht('Advanced Search');
	}

	$header = id(new PHUIHeaderView())
	->setHeader($title)
	->setProfileHeader(true);

	$box = id(new PHUIObjectBoxView())
	->setHeader($header)
	->addClass('application-search-results');

	if ($run_query \|\| $named_query) {
	$box->setShowHide(
	pht('Edit Query'),
	pht('Hide Query'),
	$form,
	$this->getApplicationURI('query/advanced/?query='.$query_key),
	(!$named_query ? true : false));
	} else {
	$box->setForm($form);
	}

	$body[] = $box;
	$more_crumbs = null;

	if ($run_query) {
	$exec_errors = array();

	$box->setAnchor(
	id(new PhabricatorAnchorView())
	->setAnchorName('R'));

	try {
	$engine->setRequest($request);

	$query = $engine->buildQueryFromSavedQuery($saved_query);

	$pager = $engine->newPagerForSavedQuery($saved_query);
	$pager->readFromRequest($request);

	+ $query->setReturnPartialResultsOnOverheat(true);
	+
	$objects = $engine->executeQuery($query, $pager);

	$force_nux = $request->getBool('nux');
	if (!$objects \|\| $force_nux) {
	$nux_view = $this->renderNewUserView($engine, $force_nux);
	} else {
	$nux_view = null;
	}

	$is_overflowing =
	$pager->willShowPagingControls() &&
	$engine->getResultBucket($saved_query);

	$force_overheated = $request->getBool('overheated');
	$is_overheated = $query->getIsOverheated() \|\| $force_overheated;

	if ($nux_view) {
	$box->appendChild($nux_view);
	} else {
	$list = $engine->renderResults($objects, $saved_query);

	if (!($list instanceof PhabricatorApplicationSearchResultView)) {
	throw new Exception(
	pht(
	'SearchEngines must render a "%s" object, but this engine '.
	'(of class "%s") rendered something else.',
	'PhabricatorApplicationSearchResultView',
	get_class($engine)));
	}

	if ($list->getObjectList()) {
	$box->setObjectList($list->getObjectList());
	}
	if ($list->getTable()) {
	$box->setTable($list->getTable());
	}
	if ($list->getInfoView()) {
	$box->setInfoView($list->getInfoView());
	}

	if ($is_overflowing) {
	$box->appendChild($this->newOverflowingView());
	}

	if ($list->getContent()) {
	$box->appendChild($list->getContent());
	}

	if ($is_overheated) {
	$box->appendChild($this->newOverheatedView($objects));
	}

	$result_header = $list->getHeader();
	if ($result_header) {
	$box->setHeader($result_header);
	$header = $result_header;
	}

	$actions = $list->getActions();
	if ($actions) {
	foreach ($actions as $action) {
	$header->addActionLink($action);
	}
	}

	$use_actions = $engine->newUseResultsActions($saved_query);

	// TODO: Eventually, modularize all this stuff.
	$builtin_use_actions = $this->newBuiltinUseActions();
	if ($builtin_use_actions) {
	foreach ($builtin_use_actions as $builtin_use_action) {
	$use_actions[] = $builtin_use_action;
	}
	}

	if ($use_actions) {
	$use_dropdown = $this->newUseResultsDropdown(
	$saved_query,
	$use_actions);
	$header->addActionLink($use_dropdown);
	}

	$more_crumbs = $list->getCrumbs();

	if ($pager->willShowPagingControls()) {
	$pager_box = id(new PHUIBoxView())
	->setColor(PHUIBoxView::GREY)
	->addClass('application-search-pager')
	->appendChild($pager);
	$body[] = $pager_box;
	}
	}
	} catch (PhabricatorTypeaheadInvalidTokenException $ex) {
	$exec_errors[] = pht(
	'This query specifies an invalid parameter. Review the '.
	'query parameters and correct errors.');
	} catch (PhutilSearchQueryCompilerSyntaxException $ex) {
	$exec_errors[] = $ex->getMessage();
	} catch (PhabricatorSearchConstraintException $ex) {
	$exec_errors[] = $ex->getMessage();
	}

	// The engine may have encountered additional errors during rendering;
	// merge them in and show everything.
	foreach ($engine->getErrors() as $error) {
	$exec_errors[] = $error;
	}

	$errors = $exec_errors;
	}

	if ($errors) {
	$box->setFormErrors($errors, pht('Query Errors'));
	}

	$crumbs = $parent
	->buildApplicationCrumbs()
	->setBorder(true);

	if ($more_crumbs) {
	$query_uri = $engine->getQueryResultsPageURI($saved_query->getQueryKey());
	$crumbs->addTextCrumb($title, $query_uri);

	foreach ($more_crumbs as $crumb) {
	$crumbs->addCrumb($crumb);
	}
	} else {
	$crumbs->addTextCrumb($title);
	}

	require_celerity_resource('application-search-view-css');

	return $this->newPage()
	->setApplicationMenu($this->buildApplicationMenu())
	->setTitle(pht('Query: %s', $title))
	->setCrumbs($crumbs)
	->setNavigation($nav)
	->addClass('application-search-view')
	->appendChild($body);
	}

	private function processExportRequest() {
	$viewer = $this->getViewer();
	$engine = $this->getSearchEngine();
	$request = $this->getRequest();

	if (!$this->canExport()) {
	return new Aphront404Response();
	}

	$query_key = $this->getQueryKey();
	if ($engine->isBuiltinQuery($query_key)) {
	$saved_query = $engine->buildSavedQueryFromBuiltin($query_key);
	} else if ($query_key) {
	$saved_query = id(new PhabricatorSavedQueryQuery())
	->setViewer($viewer)
	->withQueryKeys(array($query_key))
	->executeOne();
	} else {
	$saved_query = null;
	}

	if (!$saved_query) {
	return new Aphront404Response();
	}

	$cancel_uri = $engine->getQueryResultsPageURI($query_key);

	$named_query = idx($engine->loadEnabledNamedQueries(), $query_key);

	if ($named_query) {
	$filename = $named_query->getQueryName();
	$sheet_title = $named_query->getQueryName();
	} else {
	$filename = $engine->getResultTypeDescription();
	$sheet_title = $engine->getResultTypeDescription();
	}
	$filename = phutil_utf8_strtolower($filename);
	$filename = PhabricatorFile::normalizeFileName($filename);

	$all_formats = PhabricatorExportFormat::getAllExportFormats();

	$available_options = array();
	$unavailable_options = array();
	$formats = array();
	$unavailable_formats = array();
	foreach ($all_formats as $key => $format) {
	if ($format->isExportFormatEnabled()) {
	$available_options[$key] = $format->getExportFormatName();
	$formats[$key] = $format;
	} else {
	$unavailable_options[$key] = pht(
	'%s (Not Available)',
	$format->getExportFormatName());
	$unavailable_formats[$key] = $format;
	}
	}
	$format_options = $available_options + $unavailable_options;

	// Try to default to the format the user used last time. If you just
	// exported to Excel, you probably want to export to Excel again.
	$format_key = $this->readExportFormatPreference();
	if (!isset($formats[$format_key])) {
	$format_key = head_key($format_options);
	}

	// Check if this is a large result set or not. If we're exporting a
	// large amount of data, we'll build the actual export file in the daemons.

	$threshold = 1000;
	$query = $engine->buildQueryFromSavedQuery($saved_query);
	$pager = $engine->newPagerForSavedQuery($saved_query);
	$pager->setPageSize($threshold + 1);
	$objects = $engine->executeQuery($query, $pager);
	$object_count = count($objects);
	$is_large_export = ($object_count > $threshold);

	$errors = array();

	$e_format = null;
	if ($request->isFormPost()) {
	$format_key = $request->getStr('format');

	if (isset($unavailable_formats[$format_key])) {
	$unavailable = $unavailable_formats[$format_key];
	$instructions = $unavailable->getInstallInstructions();

	$markup = id(new PHUIRemarkupView($viewer, $instructions))
	->setRemarkupOption(
	PHUIRemarkupView::OPTION_PRESERVE_LINEBREAKS,
	false);

	return $this->newDialog()
	->setTitle(pht('Export Format Not Available'))
	->appendChild($markup)
	->addCancelButton($cancel_uri, pht('Done'));
	}

	$format = idx($formats, $format_key);

	if (!$format) {
	$e_format = pht('Invalid');
	$errors[] = pht('Choose a valid export format.');
	}

	if (!$errors) {
	$this->writeExportFormatPreference($format_key);

	$export_engine = id(new PhabricatorExportEngine())
	->setViewer($viewer)
	->setSearchEngine($engine)
	->setSavedQuery($saved_query)
	->setTitle($sheet_title)
	->setFilename($filename)
	->setExportFormat($format);

	if ($is_large_export) {
	$job = $export_engine->newBulkJob($request);

	return id(new AphrontRedirectResponse())
	->setURI($job->getMonitorURI());
	} else {
	$file = $export_engine->exportFile();
	return $file->newDownloadResponse();
	}
	}
	}

	$export_form = id(new AphrontFormView())
	->setViewer($viewer)
	->appendControl(
	id(new AphrontFormSelectControl())
	->setName('format')
	->setLabel(pht('Format'))
	->setError($e_format)
	->setValue($format_key)
	->setOptions($format_options));

	if ($is_large_export) {
	$submit_button = pht('Continue');
	} else {
	$submit_button = pht('Download Data');
	}

	return $this->newDialog()
	->setTitle(pht('Export Results'))
	->setErrors($errors)
	->appendForm($export_form)
	->addCancelButton($cancel_uri)
	->addSubmitButton($submit_button);
	}

	private function processEditRequest() {
	$parent = $this->getDelegatingController();
	$request = $this->getRequest();
	$viewer = $request->getUser();
	$engine = $this->getSearchEngine();

	$nav = $this->getNavigation();
	if (!$nav) {
	$nav = $this->buildNavigation();
	}

	$named_queries = $engine->loadAllNamedQueries();

	$can_global = $viewer->getIsAdmin();

	$groups = array(
	'personal' => array(
	'name' => pht('Personal Saved Queries'),
	'items' => array(),
	'edit' => true,
	),
	'global' => array(
	'name' => pht('Global Saved Queries'),
	'items' => array(),
	'edit' => $can_global,
	),
	);

	foreach ($named_queries as $named_query) {
	if ($named_query->isGlobal()) {
	$group = 'global';
	} else {
	$group = 'personal';
	}

	$groups[$group]['items'][] = $named_query;
	}

	$default_key = $engine->getDefaultQueryKey();

	$lists = array();
	foreach ($groups as $group) {
	$lists[] = $this->newQueryListView(
	$group['name'],
	$group['items'],
	$default_key,
	$group['edit']);
	}

	$crumbs = $parent
	->buildApplicationCrumbs()
	->addTextCrumb(pht('Saved Queries'), $engine->getQueryManagementURI())
	->setBorder(true);

	$nav->selectFilter('query/edit');

	$header = id(new PHUIHeaderView())
	->setHeader(pht('Saved Queries'))
	->setProfileHeader(true);

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setFooter($lists);

	return $this->newPage()
	->setApplicationMenu($this->buildApplicationMenu())
	->setTitle(pht('Saved Queries'))
	->setCrumbs($crumbs)
	->setNavigation($nav)
	->appendChild($view);
	}

	private function newQueryListView(
	$list_name,
	array $named_queries,
	$default_key,
	$can_edit) {

	$engine = $this->getSearchEngine();
	$viewer = $this->getViewer();

	$list = id(new PHUIObjectItemListView())
	->setViewer($viewer);

	if ($can_edit) {
	$list_id = celerity_generate_unique_node_id();
	$list->setID($list_id);

	Javelin::initBehavior(
	'search-reorder-queries',
	array(
	'listID' => $list_id,
	'orderURI' => '/search/order/'.get_class($engine).'/',
	));
	}

	foreach ($named_queries as $named_query) {
	$class = get_class($engine);
	$key = $named_query->getQueryKey();

	$item = id(new PHUIObjectItemView())
	->setHeader($named_query->getQueryName())
	->setHref($engine->getQueryResultsPageURI($key));

	if ($named_query->getIsDisabled()) {
	if ($can_edit) {
	$item->setDisabled(true);
	} else {
	// If an item is disabled and you don't have permission to edit it,
	// just skip it.
	continue;
	}
	}

	if ($can_edit) {
	if ($named_query->getIsBuiltin() && $named_query->getIsDisabled()) {
	$icon = 'fa-plus';
	$disable_name = pht('Enable');
	} else {
	$icon = 'fa-times';
	if ($named_query->getIsBuiltin()) {
	$disable_name = pht('Disable');
	} else {
	$disable_name = pht('Delete');
	}
	}

	if ($named_query->getID()) {
	$disable_href = '/search/delete/id/'.$named_query->getID().'/';
	} else {
	$disable_href = '/search/delete/key/'.$key.'/'.$class.'/';
	}

	$item->addAction(
	id(new PHUIListItemView())
	->setIcon($icon)
	->setHref($disable_href)
	->setRenderNameAsTooltip(true)
	->setName($disable_name)
	->setWorkflow(true));
	}

	$default_disabled = $named_query->getIsDisabled();
	$default_icon = 'fa-thumb-tack';

	if ($default_key === $key) {
	$default_color = 'green';
	} else {
	$default_color = null;
	}

	$item->addAction(
	id(new PHUIListItemView())
	->setIcon("{$default_icon} {$default_color}")
	->setHref('/search/default/'.$key.'/'.$class.'/')
	->setRenderNameAsTooltip(true)
	->setName(pht('Make Default'))
	->setWorkflow(true)
	->setDisabled($default_disabled));

	if ($can_edit) {
	if ($named_query->getIsBuiltin()) {
	$edit_icon = 'fa-lock lightgreytext';
	$edit_disabled = true;
	$edit_name = pht('Builtin');
	$edit_href = null;
	} else {
	$edit_icon = 'fa-pencil';
	$edit_disabled = false;
	$edit_name = pht('Edit');
	$edit_href = '/search/edit/id/'.$named_query->getID().'/';
	}

	$item->addAction(
	id(new PHUIListItemView())
	->setIcon($edit_icon)
	->setHref($edit_href)
	->setRenderNameAsTooltip(true)
	->setName($edit_name)
	->setDisabled($edit_disabled));
	}

	$item->setGrippable($can_edit);
	$item->addSigil('named-query');
	$item->setMetadata(
	array(
	'queryKey' => $named_query->getQueryKey(),
	));

	$list->addItem($item);
	}

	$list->setNoDataString(pht('No saved queries.'));

	return id(new PHUIObjectBoxView())
	->setHeaderText($list_name)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->setObjectList($list);
	}

	public function buildApplicationMenu() {
	$menu = $this->getDelegatingController()
	->buildApplicationMenu();

	if ($menu instanceof PHUIApplicationMenuView) {
	$menu->setSearchEngine($this->getSearchEngine());
	}

	return $menu;
	}

	private function buildNavigation() {
	$viewer = $this->getViewer();
	$engine = $this->getSearchEngine();

	$nav = id(new AphrontSideNavFilterView())
	->setUser($viewer)
	->setBaseURI(new PhutilURI($this->getApplicationURI()));

	$engine->addNavigationItems($nav->getMenu());

	return $nav;
	}

	private function renderNewUserView(
	PhabricatorApplicationSearchEngine $engine,
	$force_nux) {

	// Don't render NUX if the user has clicked away from the default page.
	if (strlen($this->getQueryKey())) {
	return null;
	}

	// Don't put NUX in panels because it would be weird.
	if ($engine->isPanelContext()) {
	return null;
	}

	// Try to render the view itself first, since this should be very cheap
	// (just returning some text).
	$nux_view = $engine->renderNewUserView();

	if (!$nux_view) {
	return null;
	}

	$query = $engine->newQuery();
	if (!$query) {
	return null;
	}

	// Try to load any object at all. If we can, the application has seen some
	// use so we just render the normal view.
	if (!$force_nux) {
	$object = $query
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->setLimit(1)
	+ ->setReturnPartialResultsOnOverheat(true)
	->execute();
	if ($object) {
	return null;
	}
	}

	return $nux_view;
	}

	private function newUseResultsDropdown(
	PhabricatorSavedQuery $query,
	array $dropdown_items) {

	$viewer = $this->getViewer();

	$action_list = id(new PhabricatorActionListView())
	->setViewer($viewer);
	foreach ($dropdown_items as $dropdown_item) {
	$action_list->addAction($dropdown_item);
	}

	return id(new PHUIButtonView())
	->setTag('a')
	->setHref('#')
	->setText(pht('Use Results'))
	->setIcon('fa-bars')
	->setDropdownMenu($action_list)
	->addClass('dropdown');
	}

	private function newOverflowingView() {
	$message = pht(
	'The query matched more than one page of results. Results are '.
	'paginated before bucketing, so later pages may contain additional '.
	'results in any bucket.');

	return id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setFlush(true)
	->setTitle(pht('Buckets Overflowing'))
	->setErrors(
	array(
	$message,
	));
	}

	private function newOverheatedView(array $results) {
	if ($results) {
	$message = pht(
	'Most objects matching your query are not visible to you, so '.
	'filtering results is taking a long time. Only some results are '.
	'shown. Refine your query to find results more quickly.');
	} else {
	$message = pht(
	'Most objects matching your query are not visible to you, so '.
	'filtering results is taking a long time. Refine your query to '.
	'find results more quickly.');
	}

	return id(new PHUIInfoView())
	->setSeverity(PHUIInfoView::SEVERITY_WARNING)
	->setFlush(true)
	->setTitle(pht('Query Overheated'))
	->setErrors(
	array(
	$message,
	));
	}

	private function newBuiltinUseActions() {
	$actions = array();
	$request = $this->getRequest();
	$viewer = $request->getUser();

	$is_dev = PhabricatorEnv::getEnvConfig('phabricator.developer-mode');

	$engine = $this->getSearchEngine();
	$engine_class = get_class($engine);

	$query_key = $this->getActiveQuery()->getQueryKey();

	$can_use = $engine->canUseInPanelContext();
	$is_installed = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorDashboardApplication',
	$viewer);

	if ($can_use && $is_installed) {
	$actions[] = id(new PhabricatorActionView())
	->setIcon('fa-dashboard')
	->setName(pht('Add to Dashboard'))
	->setWorkflow(true)
	->setHref("/dashboard/panel/install/{$engine_class}/{$query_key}/");
	}

	if ($this->canExport()) {
	$export_uri = $engine->getExportURI($query_key);
	$actions[] = id(new PhabricatorActionView())
	->setIcon('fa-download')
	->setName(pht('Export Data'))
	->setWorkflow(true)
	->setHref($export_uri);
	}

	if ($is_dev) {
	$engine = $this->getSearchEngine();
	$nux_uri = $engine->getQueryBaseURI();
	$nux_uri = id(new PhutilURI($nux_uri))
	->replaceQueryParam('nux', true);

	$actions[] = id(new PhabricatorActionView())
	->setIcon('fa-user-plus')
	->setName(pht('DEV: New User State'))
	->setHref($nux_uri);
	}

	if ($is_dev) {
	$overheated_uri = $this->getRequest()->getRequestURI()
	->replaceQueryParam('overheated', true);

	$actions[] = id(new PhabricatorActionView())
	->setIcon('fa-fire')
	->setName(pht('DEV: Overheated State'))
	->setHref($overheated_uri);
	}

	return $actions;
	}

	private function canExport() {
	$engine = $this->getSearchEngine();
	if (!$engine->canExport()) {
	return false;
	}

	// Don't allow logged-out users to perform exports. There's no technical
	// or policy reason they can't, but we don't normally give them access
	// to write files or jobs. For now, just err on the side of caution.

	$viewer = $this->getViewer();
	if (!$viewer->getPHID()) {
	return false;
	}

	return true;
	}

	private function readExportFormatPreference() {
	$viewer = $this->getViewer();
	$export_key = PhabricatorPolicyFavoritesSetting::SETTINGKEY;
	return $viewer->getUserSetting($export_key);
	}

	private function writeExportFormatPreference($value) {
	$viewer = $this->getViewer();
	$request = $this->getRequest();

	if (!$viewer->isLoggedIn()) {
	return;
	}

	$export_key = PhabricatorPolicyFavoritesSetting::SETTINGKEY;
	$preferences = PhabricatorUserPreferences::loadUserPreferences($viewer);

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

	$xactions = array();
	$xactions[] = $preferences->newTransaction($export_key, $value);
	$editor->applyTransactions($preferences, $xactions);
	}

	}
	diff --git a/src/infrastructure/query/policy/PhabricatorPolicyAwareQuery.php b/src/infrastructure/query/policy/PhabricatorPolicyAwareQuery.php
	index 5561f374fb..8780584f94 100644
	--- a/src/infrastructure/query/policy/PhabricatorPolicyAwareQuery.php
	+++ b/src/infrastructure/query/policy/PhabricatorPolicyAwareQuery.php
	@@ -1,756 +1,781 @@
	<?php

	/**
	* A @{class:PhabricatorQuery} which filters results according to visibility
	* policies for the querying user. Broadly, this class allows you to implement
	* a query that returns only objects the user is allowed to see.
	*
	* $results = id(new ExampleQuery())
	* ->setViewer($user)
	* ->withConstraint($example)
	* ->execute();
	*
	* Normally, you should extend @{class:PhabricatorCursorPagedPolicyAwareQuery},
	* not this class. @{class:PhabricatorCursorPagedPolicyAwareQuery} provides a
	* more practical interface for building usable queries against most object
	* types.
	*
	* NOTE: Although this class extends @{class:PhabricatorOffsetPagedQuery},
	* offset paging with policy filtering is not efficient. All results must be
	* loaded into the application and filtered here: skipping `N` rows via offset
	* is an `O(N)` operation with a large constant. Prefer cursor-based paging
	* with @{class:PhabricatorCursorPagedPolicyAwareQuery}, which can filter far
	* more efficiently in MySQL.
	*
	* @task config Query Configuration
	* @task exec Executing Queries
	* @task policyimpl Policy Query Implementation
	*/
	abstract class PhabricatorPolicyAwareQuery extends PhabricatorOffsetPagedQuery {

	private $viewer;
	private $parentQuery;
	private $rawResultLimit;
	private $capabilities;
	private $workspace = array();
	private $inFlightPHIDs = array();
	private $policyFilteredPHIDs = array();

	/**
	* Should we continue or throw an exception when a query result is filtered
	* by policy rules?
	*
	* Values are `true` (raise exceptions), `false` (do not raise exceptions)
	* and `null` (inherit from parent query, with no exceptions by default).
	*/
	private $raisePolicyExceptions;
	private $isOverheated;
	+ private $returnPartialResultsOnOverheat;
	+ private $disableOverheating;


	/* -( Query Configuration )------------------------------------------------ */


	/**
	* Set the viewer who is executing the query. Results will be filtered
	* according to the viewer's capabilities. You must set a viewer to execute
	* a policy query.
	*
	* @param PhabricatorUser The viewing user.
	* @return this
	* @task config
	*/
	final public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}


	/**
	* Get the query's viewer.
	*
	* @return PhabricatorUser The viewing user.
	* @task config
	*/
	final public function getViewer() {
	return $this->viewer;
	}


	/**
	* Set the parent query of this query. This is useful for nested queries so
	* that configuration like whether or not to raise policy exceptions is
	* seamlessly passed along to child queries.
	*
	* @return this
	* @task config
	*/
	final public function setParentQuery(PhabricatorPolicyAwareQuery $query) {
	$this->parentQuery = $query;
	return $this;
	}


	/**
	* Get the parent query. See @{method:setParentQuery} for discussion.
	*
	* @return PhabricatorPolicyAwareQuery The parent query.
	* @task config
	*/
	final public function getParentQuery() {
	return $this->parentQuery;
	}


	/**
	* Hook to configure whether this query should raise policy exceptions.
	*
	* @return this
	* @task config
	*/
	final public function setRaisePolicyExceptions($bool) {
	$this->raisePolicyExceptions = $bool;
	return $this;
	}


	/**
	* @return bool
	* @task config
	*/
	final public function shouldRaisePolicyExceptions() {
	return (bool)$this->raisePolicyExceptions;
	}


	/**
	* @task config
	*/
	final public function requireCapabilities(array $capabilities) {
	$this->capabilities = $capabilities;
	return $this;
	}

	+ final public function setReturnPartialResultsOnOverheat($bool) {
	+ $this->returnPartialResultsOnOverheat = $bool;
	+ return $this;
	+ }
	+
	+ final public function setDisableOverheating($disable_overheating) {
	+ $this->disableOverheating = $disable_overheating;
	+ return $this;
	+ }
	+

	/* -( Query Execution )---------------------------------------------------- */


	/**
	* Execute the query, expecting a single result. This method simplifies
	* loading objects for detail pages or edit views.
	*
	* // Load one result by ID.
	* $obj = id(new ExampleQuery())
	* ->setViewer($user)
	* ->withIDs(array($id))
	* ->executeOne();
	* if (!$obj) {
	* return new Aphront404Response();
	* }
	*
	* If zero results match the query, this method returns `null`.
	* If one result matches the query, this method returns that result.
	*
	* If two or more results match the query, this method throws an exception.
	* You should use this method only when the query constraints guarantee at
	* most one match (e.g., selecting a specific ID or PHID).
	*
	* If one result matches the query but it is caught by the policy filter (for
	* example, the user is trying to view or edit an object which exists but
	* which they do not have permission to see) a policy exception is thrown.
	*
	* @return mixed Single result, or null.
	* @task exec
	*/
	final public function executeOne() {

	$this->setRaisePolicyExceptions(true);
	try {
	$results = $this->execute();
	} catch (Exception $ex) {
	$this->setRaisePolicyExceptions(false);
	throw $ex;
	}

	if (count($results) > 1) {
	throw new Exception(pht('Expected a single result!'));
	}

	if (!$results) {
	return null;
	}

	return head($results);
	}


	/**
	* Execute the query, loading all visible results.
	*
	* @return list<PhabricatorPolicyInterface> Result objects.
	* @task exec
	*/
	final public function execute() {
	if (!$this->viewer) {
	throw new PhutilInvalidStateException('setViewer');
	}

	$parent_query = $this->getParentQuery();
	if ($parent_query && ($this->raisePolicyExceptions === null)) {
	$this->setRaisePolicyExceptions(
	$parent_query->shouldRaisePolicyExceptions());
	}

	$results = array();

	$filter = $this->getPolicyFilter();

	$offset = (int)$this->getOffset();
	$limit = (int)$this->getLimit();
	$count = 0;

	if ($limit) {
	$need = $offset + $limit;
	} else {
	$need = 0;
	}

	$this->willExecute();

	// If we examine and filter significantly more objects than the query
	// limit, we stop early. This prevents us from looping through a huge
	// number of records when the viewer can see few or none of them. See
	// T11773 for some discussion.
	$this->isOverheated = false;
	$overheat_limit = $limit * 10;
	$total_seen = 0;

	do {
	if ($need) {
	$this->rawResultLimit = min($need - $count, 1024);
	} else {
	$this->rawResultLimit = 0;
	}

	if ($this->canViewerUseQueryApplication()) {
	try {
	$page = $this->loadPage();
	} catch (PhabricatorEmptyQueryException $ex) {
	$page = array();
	}
	} else {
	$page = array();
	}

	$total_seen += count($page);

	if ($page) {
	$maybe_visible = $this->willFilterPage($page);
	if ($maybe_visible) {
	$maybe_visible = $this->applyWillFilterPageExtensions($maybe_visible);
	}
	} else {
	$maybe_visible = array();
	}

	if ($this->shouldDisablePolicyFiltering()) {
	$visible = $maybe_visible;
	} else {
	$visible = $filter->apply($maybe_visible);

	$policy_filtered = array();
	foreach ($maybe_visible as $key => $object) {
	if (empty($visible[$key])) {
	$phid = $object->getPHID();
	if ($phid) {
	$policy_filtered[$phid] = $phid;
	}
	}
	}
	$this->addPolicyFilteredPHIDs($policy_filtered);
	}

	if ($visible) {
	$visible = $this->didFilterPage($visible);
	}

	$removed = array();
	foreach ($maybe_visible as $key => $object) {
	if (empty($visible[$key])) {
	$removed[$key] = $object;
	}
	}

	$this->didFilterResults($removed);

	// NOTE: We call "nextPage()" before checking if we've found enough
	// results because we want to build the internal cursor object even
	// if we don't need to execute another query: the internal cursor may
	// be used by a parent query that is using this query to translate an
	// external cursor into an internal cursor.
	$this->nextPage($page);

	foreach ($visible as $key => $result) {
	++$count;

	// If we have an offset, we just ignore that many results and start
	// storing them only once we've hit the offset. This reduces memory
	// requirements for large offsets, compared to storing them all and
	// slicing them away later.
	if ($count > $offset) {
	$results[$key] = $result;
	}

	if ($need && ($count >= $need)) {
	// If we have all the rows we need, break out of the paging query.
	break 2;
	}
	}

	if (!$this->rawResultLimit) {
	// If we don't have a load count, we loaded all the results. We do
	// not need to load another page.
	break;
	}

	if (count($page) < $this->rawResultLimit) {
	// If we have a load count but the unfiltered results contained fewer
	// objects, we know this was the last page of objects; we do not need
	// to load another page because we can deduce it would be empty.
	break;
	}

	- if ($overheat_limit && ($total_seen >= $overheat_limit)) {
	- $this->isOverheated = true;
	- break;
	+ if (!$this->disableOverheating) {
	+ if ($overheat_limit && ($total_seen >= $overheat_limit)) {
	+ $this->isOverheated = true;
	+
	+ if (!$this->returnPartialResultsOnOverheat) {
	+ throw new Exception(
	+ pht(
	+ 'Query (of class "%s") overheated: examined more than %s '.
	+ 'raw rows without finding %s visible objects.',
	+ get_class($this),
	+ new PhutilNumber($overheat_limit),
	+ new PhutilNumber($need)));
	+ }
	+
	+ break;
	+ }
	}
	} while (true);

	$results = $this->didLoadResults($results);

	return $results;
	}

	private function getPolicyFilter() {
	$filter = new PhabricatorPolicyFilter();
	$filter->setViewer($this->viewer);
	$capabilities = $this->getRequiredCapabilities();
	$filter->requireCapabilities($capabilities);
	$filter->raisePolicyExceptions($this->shouldRaisePolicyExceptions());

	return $filter;
	}

	protected function getRequiredCapabilities() {
	if ($this->capabilities) {
	return $this->capabilities;
	}

	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}

	protected function applyPolicyFilter(array $objects, array $capabilities) {
	if ($this->shouldDisablePolicyFiltering()) {
	return $objects;
	}
	$filter = $this->getPolicyFilter();
	$filter->requireCapabilities($capabilities);
	return $filter->apply($objects);
	}

	protected function didRejectResult(PhabricatorPolicyInterface $object) {
	// Some objects (like commits) may be rejected because related objects
	// (like repositories) can not be loaded. In some cases, we may need these
	// related objects to determine the object policy, so it's expected that
	// we may occasionally be unable to determine the policy.

	try {
	$policy = $object->getPolicy(PhabricatorPolicyCapability::CAN_VIEW);
	} catch (Exception $ex) {
	$policy = null;
	}

	// Mark this object as filtered so handles can render "Restricted" instead
	// of "Unknown".
	$phid = $object->getPHID();
	$this->addPolicyFilteredPHIDs(array($phid => $phid));

	$this->getPolicyFilter()->rejectObject(
	$object,
	$policy,
	PhabricatorPolicyCapability::CAN_VIEW);
	}

	public function addPolicyFilteredPHIDs(array $phids) {
	$this->policyFilteredPHIDs += $phids;
	if ($this->getParentQuery()) {
	$this->getParentQuery()->addPolicyFilteredPHIDs($phids);
	}
	return $this;
	}


	public function getIsOverheated() {
	if ($this->isOverheated === null) {
	throw new PhutilInvalidStateException('execute');
	}
	return $this->isOverheated;
	}


	/**
	* Return a map of all object PHIDs which were loaded in the query but
	* filtered out by policy constraints. This allows a caller to distinguish
	* between objects which do not exist (or, at least, were filtered at the
	* content level) and objects which exist but aren't visible.
	*
	* @return map<phid, phid> Map of object PHIDs which were filtered
	* by policies.
	* @task exec
	*/
	public function getPolicyFilteredPHIDs() {
	return $this->policyFilteredPHIDs;
	}


	/* -( Query Workspace )---------------------------------------------------- */


	/**
	* Put a map of objects into the query workspace. Many queries perform
	* subqueries, which can eventually end up loading the same objects more than
	* once (often to perform policy checks).
	*
	* For example, loading a user may load the user's profile image, which might
	* load the user object again in order to verify that the viewer has
	* permission to see the file.
	*
	* The "query workspace" allows queries to load objects from elsewhere in a
	* query block instead of refetching them.
	*
	* When using the query workspace, it's important to obey two rules:
	*
	* **Never put objects into the workspace which the viewer may not be able
	* to see**. You need to apply all policy filtering //before// putting
	* objects in the workspace. Otherwise, subqueries may read the objects and
	* use them to permit access to content the user shouldn't be able to view.
	*
	* Fully enrich objects pulled from the workspace. After pulling objects
	* from the workspace, you still need to load and attach any additional
	* content the query requests. Otherwise, a query might return objects
	* without requested content.
	*
	* Generally, you do not need to update the workspace yourself: it is
	* automatically populated as a side effect of objects surviving policy
	* filtering.
	*
	* @param map<phid, PhabricatorPolicyInterface> Objects to add to the query
	* workspace.
	* @return this
	* @task workspace
	*/
	public function putObjectsInWorkspace(array $objects) {
	$parent = $this->getParentQuery();
	if ($parent) {
	$parent->putObjectsInWorkspace($objects);
	return $this;
	}

	assert_instances_of($objects, 'PhabricatorPolicyInterface');

	$viewer_fragment = $this->getViewer()->getCacheFragment();

	// The workspace is scoped per viewer to prevent accidental contamination.
	if (empty($this->workspace[$viewer_fragment])) {
	$this->workspace[$viewer_fragment] = array();
	}

	$this->workspace[$viewer_fragment] += $objects;

	return $this;
	}


	/**
	* Retrieve objects from the query workspace. For more discussion about the
	* workspace mechanism, see @{method:putObjectsInWorkspace}. This method
	* searches both the current query's workspace and the workspaces of parent
	* queries.
	*
	* @param list<phid> List of PHIDs to retrieve.
	* @return this
	* @task workspace
	*/
	public function getObjectsFromWorkspace(array $phids) {
	$parent = $this->getParentQuery();
	if ($parent) {
	return $parent->getObjectsFromWorkspace($phids);
	}

	$viewer_fragment = $this->getViewer()->getCacheFragment();

	$results = array();
	foreach ($phids as $key => $phid) {
	if (isset($this->workspace[$viewer_fragment][$phid])) {
	$results[$phid] = $this->workspace[$viewer_fragment][$phid];
	unset($phids[$key]);
	}
	}

	return $results;
	}


	/**
	* Mark PHIDs as in flight.
	*
	* PHIDs which are "in flight" are actively being queried for. Using this
	* list can prevent infinite query loops by aborting queries which cycle.
	*
	* @param list<phid> List of PHIDs which are now in flight.
	* @return this
	*/
	public function putPHIDsInFlight(array $phids) {
	foreach ($phids as $phid) {
	$this->inFlightPHIDs[$phid] = $phid;
	}
	return $this;
	}


	/**
	* Get PHIDs which are currently in flight.
	*
	* PHIDs which are "in flight" are actively being queried for.
	*
	* @return map<phid, phid> PHIDs currently in flight.
	*/
	public function getPHIDsInFlight() {
	$results = $this->inFlightPHIDs;
	if ($this->getParentQuery()) {
	$results += $this->getParentQuery()->getPHIDsInFlight();
	}
	return $results;
	}


	/* -( Policy Query Implementation )---------------------------------------- */


	/**
	* Get the number of results @{method:loadPage} should load. If the value is
	* 0, @{method:loadPage} should load all available results.
	*
	* @return int The number of results to load, or 0 for all results.
	* @task policyimpl
	*/
	final protected function getRawResultLimit() {
	return $this->rawResultLimit;
	}


	/**
	* Hook invoked before query execution. Generally, implementations should
	* reset any internal cursors.
	*
	* @return void
	* @task policyimpl
	*/
	protected function willExecute() {
	return;
	}


	/**
	* Load a raw page of results. Generally, implementations should load objects
	* from the database. They should attempt to return the number of results
	* hinted by @{method:getRawResultLimit}.
	*
	* @return list<PhabricatorPolicyInterface> List of filterable policy objects.
	* @task policyimpl
	*/
	abstract protected function loadPage();


	/**
	* Update internal state so that the next call to @{method:loadPage} will
	* return new results. Generally, you should adjust a cursor position based
	* on the provided result page.
	*
	* @param list<PhabricatorPolicyInterface> The current page of results.
	* @return void
	* @task policyimpl
	*/
	abstract protected function nextPage(array $page);


	/**
	* Hook for applying a page filter prior to the privacy filter. This allows
	* you to drop some items from the result set without creating problems with
	* pagination or cursor updates. You can also load and attach data which is
	* required to perform policy filtering.
	*
	* Generally, you should load non-policy data and perform non-policy filtering
	* later, in @{method:didFilterPage}. Strictly fewer objects will make it that
	* far (so the program will load less data) and subqueries from that context
	* can use the query workspace to further reduce query load.
	*
	* This method will only be called if data is available. Implementations
	* do not need to handle the case of no results specially.
	*
	* @param list<wild> Results from `loadPage()`.
	* @return list<PhabricatorPolicyInterface> Objects for policy filtering.
	* @task policyimpl
	*/
	protected function willFilterPage(array $page) {
	return $page;
	}

	/**
	* Hook for performing additional non-policy loading or filtering after an
	* object has satisfied all policy checks. Generally, this means loading and
	* attaching related data.
	*
	* Subqueries executed during this phase can use the query workspace, which
	* may improve performance or make circular policies resolvable. Data which
	* is not necessary for policy filtering should generally be loaded here.
	*
	* This callback can still filter objects (for example, if attachable data
	* is discovered to not exist), but should not do so for policy reasons.
	*
	* This method will only be called if data is available. Implementations do
	* not need to handle the case of no results specially.
	*
	* @param list<wild> Results from @{method:willFilterPage()}.
	* @return list<PhabricatorPolicyInterface> Objects after additional
	* non-policy processing.
	*/
	protected function didFilterPage(array $page) {
	return $page;
	}


	/**
	* Hook for removing filtered results from alternate result sets. This
	* hook will be called with any objects which were returned by the query but
	* filtered for policy reasons. The query should remove them from any cached
	* or partial result sets.
	*
	* @param list<wild> List of objects that should not be returned by alternate
	* result mechanisms.
	* @return void
	* @task policyimpl
	*/
	protected function didFilterResults(array $results) {
	return;
	}


	/**
	* Hook for applying final adjustments before results are returned. This is
	* used by @{class:PhabricatorCursorPagedPolicyAwareQuery} to reverse results
	* that are queried during reverse paging.
	*
	* @param list<PhabricatorPolicyInterface> Query results.
	* @return list<PhabricatorPolicyInterface> Final results.
	* @task policyimpl
	*/
	protected function didLoadResults(array $results) {
	return $results;
	}


	/**
	* Allows a subclass to disable policy filtering. This method is dangerous.
	* It should be used only if the query loads data which has already been
	* filtered (for example, because it wraps some other query which uses
	* normal policy filtering).
	*
	* @return bool True to disable all policy filtering.
	* @task policyimpl
	*/
	protected function shouldDisablePolicyFiltering() {
	return false;
	}


	/**
	* If this query belongs to an application, return the application class name
	* here. This will prevent the query from returning results if the viewer can
	* not access the application.
	*
	* If this query does not belong to an application, return `null`.
	*
	* @return string\|null Application class name.
	*/
	abstract public function getQueryApplicationClass();


	/**
	* Determine if the viewer has permission to use this query's application.
	* For queries which aren't part of an application, this method always returns
	* true.
	*
	* @return bool True if the viewer has application-level permission to
	* execute the query.
	*/
	public function canViewerUseQueryApplication() {
	$class = $this->getQueryApplicationClass();
	if (!$class) {
	return true;
	}

	$viewer = $this->getViewer();
	return PhabricatorApplication::isClassInstalledForViewer($class, $viewer);
	}

	private function applyWillFilterPageExtensions(array $page) {
	$bridges = array();
	foreach ($page as $key => $object) {
	if ($object instanceof DoorkeeperBridgedObjectInterface) {
	$bridges[$key] = $object;
	}
	}

	if ($bridges) {
	$external_phids = array();
	foreach ($bridges as $bridge) {
	$external_phid = $bridge->getBridgedObjectPHID();
	if ($external_phid) {
	$external_phids[$key] = $external_phid;
	}
	}

	if ($external_phids) {
	$external_objects = id(new DoorkeeperExternalObjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($external_phids)
	->execute();
	$external_objects = mpull($external_objects, null, 'getPHID');
	} else {
	$external_objects = array();
	}

	foreach ($bridges as $key => $bridge) {
	$external_phid = idx($external_phids, $key);
	if (!$external_phid) {
	$bridge->attachBridgedObject(null);
	continue;
	}

	$external_object = idx($external_objects, $external_phid);
	if (!$external_object) {
	$this->didRejectResult($bridge);
	unset($page[$key]);
	continue;
	}

	$bridge->attachBridgedObject($external_object);
	}
	}

	return $page;
	}

	}
	diff --git a/src/infrastructure/storage/lisk/PhabricatorQueryIterator.php b/src/infrastructure/storage/lisk/PhabricatorQueryIterator.php
	index 03aaf5707e..648b83863a 100644
	--- a/src/infrastructure/storage/lisk/PhabricatorQueryIterator.php
	+++ b/src/infrastructure/storage/lisk/PhabricatorQueryIterator.php
	@@ -1,41 +1,43 @@
	<?php

	final class PhabricatorQueryIterator extends PhutilBufferedIterator {

	private $query;
	private $pager;

	public function __construct(PhabricatorCursorPagedPolicyAwareQuery $query) {
	$this->query = $query;
	}

	protected function didRewind() {
	$this->pager = new AphrontCursorPagerView();
	}

	public function key() {
	return $this->current()->getID();
	}

	protected function loadPage() {
	if (!$this->pager) {
	return array();
	}

	$pager = clone $this->pager;
	$query = clone $this->query;

	+ $query->setDisableOverheating(true);
	+
	$results = $query->executeWithCursorPager($pager);

	// If we got less than a full page of results, this was the last set of
	// results. Throw away the pager so we end iteration.
	if (!$pager->getHasMoreResults()) {
	$this->pager = null;
	} else {
	$this->pager->setAfterID($pager->getNextPageID());
	}

	return $results;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Jan 19 2025, 22:20 (6 w, 3 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1129320
Default Alt Text: (54 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions