PhabricatorApplicationSearchController.php
b2d63d009cd2stable

PhabricatorApplicationSearchController.php
View Options

			<?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 ("%s").',
			'PhabricatorApplicationSearchResultView',
			get_class($engine),
			phutil_describe_type($list)));
			}

			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();
			} catch (PhabricatorInvalidQueryCursorException $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,
			));
			}

			public static function newOverheatedError($has_results) {
			$overheated_link = phutil_tag(
			'a',
			array(
			'href' => 'https://phurl.io/u/overheated',
			'target' => '_blank',
			),
			pht('Learn More'));

			if ($has_results) {
			$message = pht(
			'This query took too long, so only some results are shown. %s',
			$overheated_link);
			} else {
			$message = pht(
			'This query took too long. %s',
			$overheated_link);
			}

			return $message;
			}

			private function newOverheatedView(array $results) {
			$message = self::newOverheatedError((bool)$results);

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

			}

phab/src/applications/search/controller/PhabricatorApplicationSearchController.phpb2d63d009cd2stable

PhabricatorApplicationSearchController.phpView Options

phab/src/applications/search/controller/PhabricatorApplicationSearchController.php
b2d63d009cd2stable

PhabricatorApplicationSearchController.php
View Options