No OneTemporary
Actions

Size

90 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/resources/sql/autopatches/20181031.board.01.queryreset.php b/resources/sql/autopatches/20181031.board.01.queryreset.php
	new file mode 100644
	index 0000000000..781cf456ce
	--- /dev/null
	+++ b/resources/sql/autopatches/20181031.board.01.queryreset.php
	@@ -0,0 +1,50 @@
	+<?php
	+
	+// See T13208. It was previously possible to replace a saved query with another
	+// saved query, causing loss of the first query. Find projects which have their
	+// default query set to an invalid query and throw the setting away.
	+
	+$viewer = PhabricatorUser::getOmnipotentUser();
	+
	+$table = new PhabricatorProject();
	+$conn = $table->establishConnection('w');
	+
	+$iterator = new LiskMigrationIterator($table);
	+$search_engine = id(new ManiphestTaskSearchEngine())
	+ ->setViewer($viewer);
	+
	+foreach ($iterator as $project) {
	+ $default_filter = $project->getDefaultWorkboardFilter();
	+ if (!strlen($default_filter)) {
	+ continue;
	+ }
	+
	+ if ($search_engine->isBuiltinQuery($default_filter)) {
	+ continue;
	+ }
	+
	+ $saved = id(new PhabricatorSavedQueryQuery())
	+ ->setViewer($viewer)
	+ ->withQueryKeys(array($default_filter))
	+ ->executeOne();
	+ if ($saved) {
	+ continue;
	+ }
	+
	+ $properties = $project->getProperties();
	+ unset($properties['workboard.filter.default']);
	+
	+ queryfx(
	+ $conn,
	+ 'UPDATE %T SET properties = %s WHERE id = %d',
	+ $table->getTableName(),
	+ phutil_json_encode($properties),
	+ $project->getID());
	+
	+ echo tsprintf(
	+ "%s\n",
	+ pht(
	+ 'Project ("%s") had an invalid query saved as a default workboard '.
	+ 'query. The query has been reset. See T13208.',
	+ $project->getDisplayName()));
	+}
	diff --git a/src/applications/project/controller/PhabricatorProjectBoardViewController.php b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	index bb048f22ea..15e0c5d075 100644
	--- a/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	+++ b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	@@ -1,1372 +1,1372 @@
	<?php

	final class PhabricatorProjectBoardViewController
	extends PhabricatorProjectBoardController {

	const BATCH_EDIT_ALL = 'all';

	private $id;
	private $slug;
	private $queryKey;
	private $sortKey;
	private $showHidden;

	public function shouldAllowPublic() {
	return true;
	}

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

	$response = $this->loadProject();
	if ($response) {
	return $response;
	}

	$project = $this->getProject();

	$this->readRequestState();

	$board_uri = $this->getApplicationURI('board/'.$project->getID().'/');

	$search_engine = id(new ManiphestTaskSearchEngine())
	->setViewer($viewer)
	->setBaseURI($board_uri)
	->setIsBoardView(true);

	if ($request->isFormPost()
	&& !$request->getBool('initialize')
	&& !$request->getStr('move')
	&& !$request->getStr('queryColumnID')) {
	$saved = $search_engine->buildSavedQueryFromRequest($request);
	$search_engine->saveQuery($saved);
	$filter_form = id(new AphrontFormView())
	->setUser($viewer);
	$search_engine->buildSearchForm($filter_form, $saved);
	if ($search_engine->getErrors()) {
	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle(pht('Advanced Filter'))
	->appendChild($filter_form->buildLayoutView())
	->setErrors($search_engine->getErrors())
	->setSubmitURI($board_uri)
	->addSubmitButton(pht('Apply Filter'))
	->addCancelButton($board_uri);
	}
	return id(new AphrontRedirectResponse())->setURI(
	$this->getURIWithState(
	$search_engine->getQueryResultsPageURI($saved->getQueryKey())));
	}

	$query_key = $this->getDefaultFilter($project);

	$request_query = $request->getStr('filter');
	if (strlen($request_query)) {
	$query_key = $request_query;
	}

	$uri_query = $request->getURIData('queryKey');
	if (strlen($uri_query)) {
	$query_key = $uri_query;
	}

	$this->queryKey = $query_key;

	$custom_query = null;
	if ($search_engine->isBuiltinQuery($query_key)) {
	$saved = $search_engine->buildSavedQueryFromBuiltin($query_key);
	} else {
	$saved = id(new PhabricatorSavedQueryQuery())
	->setViewer($viewer)
	->withQueryKeys(array($query_key))
	->executeOne();

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

	$custom_query = $saved;
	}

	if ($request->getURIData('filter')) {
	$filter_form = id(new AphrontFormView())
	->setUser($viewer);
	$search_engine->buildSearchForm($filter_form, $saved);

	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle(pht('Advanced Filter'))
	->appendChild($filter_form->buildLayoutView())
	->setSubmitURI($board_uri)
	->addSubmitButton(pht('Apply Filter'))
	->addCancelButton($board_uri);
	}

	$task_query = $search_engine->buildQueryFromSavedQuery($saved);

	$select_phids = array($project->getPHID());
	if ($project->getHasSubprojects() \|\| $project->getHasMilestones()) {
	$descendants = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withAncestorProjectPHIDs($select_phids)
	->execute();
	foreach ($descendants as $descendant) {
	$select_phids[] = $descendant->getPHID();
	}
	}

	$tasks = $task_query
	->withEdgeLogicPHIDs(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	PhabricatorQueryConstraint::OPERATOR_ANCESTOR,
	array($select_phids))
	->setOrder(ManiphestTaskQuery::ORDER_PRIORITY)
	->setViewer($viewer)
	->execute();
	$tasks = mpull($tasks, null, 'getPHID');

	$board_phid = $project->getPHID();

	// Regardless of display order, pass tasks to the layout engine in ID order
	// so layout is consistent.
	$board_tasks = msort($tasks, 'getID');

	$layout_engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($viewer)
	->setBoardPHIDs(array($board_phid))
	->setObjectPHIDs(array_keys($board_tasks))
	->setFetchAllBoards(true)
	->executeLayout();

	$columns = $layout_engine->getColumns($board_phid);
	if (!$columns \|\| !$project->getHasWorkboard()) {
	$has_normal_columns = false;

	foreach ($columns as $column) {
	if (!$column->getProxyPHID()) {
	$has_normal_columns = true;
	break;
	}
	}

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

	if (!$has_normal_columns) {
	if (!$can_edit) {
	$content = $this->buildNoAccessContent($project);
	} else {
	$content = $this->buildInitializeContent($project);
	}
	} else {
	if (!$can_edit) {
	$content = $this->buildDisabledContent($project);
	} else {
	$content = $this->buildEnableContent($project);
	}
	}

	if ($content instanceof AphrontResponse) {
	return $content;
	}

	$nav = $this->getProfileMenu();
	$nav->selectFilter(PhabricatorProject::ITEM_WORKBOARD);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Workboard'));

	return $this->newPage()
	->setTitle(
	array(
	$project->getDisplayName(),
	pht('Workboard'),
	))
	->setNavigation($nav)
	->setCrumbs($crumbs)
	->appendChild($content);
	}

	// If the user wants to turn a particular column into a query, build an
	// apropriate filter and redirect them to the query results page.
	$query_column_id = $request->getInt('queryColumnID');
	if ($query_column_id) {
	$column_id_map = mpull($columns, null, 'getID');
	$query_column = idx($column_id_map, $query_column_id);
	if (!$query_column) {
	return new Aphront404Response();
	}

	// Create a saved query to combine the active filter on the workboard
	// with the column filter. If the user currently has constraints on the
	// board, we want to add a new column or project constraint, not
	// completely replace the constraints.
	- $saved_query = clone $saved;
	+ $saved_query = $saved->newCopy();

	if ($query_column->getProxyPHID()) {
	$project_phids = $saved_query->getParameter('projectPHIDs');
	if (!$project_phids) {
	$project_phids = array();
	}
	$project_phids[] = $query_column->getProxyPHID();
	$saved_query->setParameter('projectPHIDs', $project_phids);
	} else {
	$saved_query->setParameter(
	'columnPHIDs',
	array($query_column->getPHID()));
	}

	$search_engine = id(new ManiphestTaskSearchEngine())
	->setViewer($viewer);
	$search_engine->saveQuery($saved_query);

	$query_key = $saved_query->getQueryKey();
	$query_uri = new PhutilURI("/maniphest/query/{$query_key}/#R");

	return id(new AphrontRedirectResponse())
	->setURI($query_uri);
	}

	$task_can_edit_map = id(new PhabricatorPolicyFilter())
	->setViewer($viewer)
	->requireCapabilities(array(PhabricatorPolicyCapability::CAN_EDIT))
	->apply($tasks);

	// If this is a batch edit, select the editable tasks in the chosen column
	// and ship the user into the batch editor.
	$batch_edit = $request->getStr('batch');
	if ($batch_edit) {
	if ($batch_edit !== self::BATCH_EDIT_ALL) {
	$column_id_map = mpull($columns, null, 'getID');
	$batch_column = idx($column_id_map, $batch_edit);
	if (!$batch_column) {
	return new Aphront404Response();
	}

	$batch_task_phids = $layout_engine->getColumnObjectPHIDs(
	$board_phid,
	$batch_column->getPHID());

	foreach ($batch_task_phids as $key => $batch_task_phid) {
	if (empty($task_can_edit_map[$batch_task_phid])) {
	unset($batch_task_phids[$key]);
	}
	}

	$batch_tasks = array_select_keys($tasks, $batch_task_phids);
	} else {
	$batch_tasks = $task_can_edit_map;
	}

	if (!$batch_tasks) {
	$cancel_uri = $this->getURIWithState($board_uri);
	return $this->newDialog()
	->setTitle(pht('No Editable Tasks'))
	->appendParagraph(
	pht(
	'The selected column contains no visible tasks which you '.
	'have permission to edit.'))
	->addCancelButton($board_uri);
	}

	// Create a saved query to hold the working set. This allows us to get
	// around URI length limitations with a long "?ids=..." query string.
	// For details, see T10268.
	$search_engine = id(new ManiphestTaskSearchEngine())
	->setViewer($viewer);

	$saved_query = $search_engine->newSavedQuery();
	$saved_query->setParameter('ids', mpull($batch_tasks, 'getID'));
	$search_engine->saveQuery($saved_query);

	$query_key = $saved_query->getQueryKey();

	$bulk_uri = new PhutilURI("/maniphest/bulk/query/{$query_key}/");
	$bulk_uri->setQueryParam('board', $this->id);

	return id(new AphrontRedirectResponse())
	->setURI($bulk_uri);
	}

	$move_id = $request->getStr('move');
	if (strlen($move_id)) {
	$column_id_map = mpull($columns, null, 'getID');
	$move_column = idx($column_id_map, $move_id);
	if (!$move_column) {
	return new Aphront404Response();
	}

	$move_task_phids = $layout_engine->getColumnObjectPHIDs(
	$board_phid,
	$move_column->getPHID());

	foreach ($move_task_phids as $key => $move_task_phid) {
	if (empty($task_can_edit_map[$move_task_phid])) {
	unset($move_task_phids[$key]);
	}
	}

	$move_tasks = array_select_keys($tasks, $move_task_phids);
	$cancel_uri = $this->getURIWithState($board_uri);

	if (!$move_tasks) {
	return $this->newDialog()
	->setTitle(pht('No Movable Tasks'))
	->appendParagraph(
	pht(
	'The selected column contains no visible tasks which you '.
	'have permission to move.'))
	->addCancelButton($cancel_uri);
	}

	$move_project_phid = $project->getPHID();
	$move_column_phid = null;
	$move_project = null;
	$move_column = null;
	$columns = null;
	$errors = array();

	if ($request->isFormPost()) {
	$move_project_phid = head($request->getArr('moveProjectPHID'));
	if (!$move_project_phid) {
	$move_project_phid = $request->getStr('moveProjectPHID');
	}

	if (!$move_project_phid) {
	if ($request->getBool('hasProject')) {
	$errors[] = pht('Choose a project to move tasks to.');
	}
	} else {
	$target_project = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withPHIDs(array($move_project_phid))
	->executeOne();
	if (!$target_project) {
	$errors[] = pht('You must choose a valid project.');
	} else if (!$project->getHasWorkboard()) {
	$errors[] = pht(
	'You must choose a project with a workboard.');
	} else {
	$move_project = $target_project;
	}
	}

	if ($move_project) {
	$move_engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($viewer)
	->setBoardPHIDs(array($move_project->getPHID()))
	->setFetchAllBoards(true)
	->executeLayout();

	$columns = $move_engine->getColumns($move_project->getPHID());
	$columns = mpull($columns, null, 'getPHID');

	foreach ($columns as $key => $column) {
	if ($column->isHidden()) {
	unset($columns[$key]);
	}
	}

	$move_column_phid = $request->getStr('moveColumnPHID');
	if (!$move_column_phid) {
	if ($request->getBool('hasColumn')) {
	$errors[] = pht('Choose a column to move tasks to.');
	}
	} else {
	if (empty($columns[$move_column_phid])) {
	$errors[] = pht(
	'Choose a valid column on the target workboard to move '.
	'tasks to.');
	} else if ($columns[$move_column_phid]->getID() == $move_id) {
	$errors[] = pht(
	'You can not move tasks from a column to itself.');
	} else {
	$move_column = $columns[$move_column_phid];
	}
	}
	}
	}

	if ($move_column && $move_project) {
	foreach ($move_tasks as $move_task) {
	$xactions = array();

	// If we're switching projects, get out of the old project first
	// and move to the new project.
	if ($move_project->getID() != $project->getID()) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue(
	'edge:type',
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST)
	->setNewValue(
	array(
	'-' => array(
	$project->getPHID() => $project->getPHID(),
	),
	'+' => array(
	$move_project->getPHID() => $move_project->getPHID(),
	),
	));
	}

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_COLUMNS)
	->setNewValue(
	array(
	array(
	'columnPHID' => $move_column->getPHID(),
	),
	));

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

	$editor->applyTransactions($move_task, $xactions);
	}

	return id(new AphrontRedirectResponse())
	->setURI($cancel_uri);
	}

	if ($move_project) {
	$column_form = id(new AphrontFormView())
	->setViewer($viewer)
	->appendControl(
	id(new AphrontFormSelectControl())
	->setName('moveColumnPHID')
	->setLabel(pht('Move to Column'))
	->setValue($move_column_phid)
	->setOptions(mpull($columns, 'getDisplayName', 'getPHID')));

	return $this->newDialog()
	->setTitle(pht('Move Tasks'))
	->setWidth(AphrontDialogView::WIDTH_FORM)
	->setErrors($errors)
	->addHiddenInput('move', $move_id)
	->addHiddenInput('moveProjectPHID', $move_project->getPHID())
	->addHiddenInput('hasColumn', true)
	->addHiddenInput('hasProject', true)
	->appendParagraph(
	pht(
	'Choose a column on the %s workboard to move tasks to:',
	$viewer->renderHandle($move_project->getPHID())))
	->appendForm($column_form)
	->addSubmitButton(pht('Move Tasks'))
	->addCancelButton($cancel_uri);
	}

	if ($move_project_phid) {
	$move_project_phid_value = array($move_project_phid);
	} else {
	$move_project_phid_value = array();
	}

	$project_form = id(new AphrontFormView())
	->setViewer($viewer)
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setName('moveProjectPHID')
	->setLimit(1)
	->setLabel(pht('Move to Project'))
	->setValue($move_project_phid_value)
	->setDatasource(new PhabricatorProjectDatasource()));

	return $this->newDialog()
	->setTitle(pht('Move Tasks'))
	->setWidth(AphrontDialogView::WIDTH_FORM)
	->setErrors($errors)
	->addHiddenInput('move', $move_id)
	->addHiddenInput('hasProject', true)
	->appendForm($project_form)
	->addSubmitButton(pht('Continue'))
	->addCancelButton($cancel_uri);
	}


	$board_id = celerity_generate_unique_node_id();

	$board = id(new PHUIWorkboardView())
	->setUser($viewer)
	->setID($board_id)
	->addSigil('jx-workboard')
	->setMetadata(
	array(
	'boardPHID' => $project->getPHID(),
	));

	$visible_columns = array();
	$column_phids = array();
	$visible_phids = array();
	foreach ($columns as $column) {
	if (!$this->showHidden) {
	if ($column->isHidden()) {
	continue;
	}
	}

	$proxy = $column->getProxy();
	if ($proxy && !$proxy->isMilestone()) {
	// TODO: For now, don't show subproject columns because we can't
	// handle tasks with multiple positions yet.
	continue;
	}

	$task_phids = $layout_engine->getColumnObjectPHIDs(
	$board_phid,
	$column->getPHID());

	$column_tasks = array_select_keys($tasks, $task_phids);

	// If we aren't using "natural" order, reorder the column by the original
	// query order.
	if ($this->sortKey != PhabricatorProjectColumn::ORDER_NATURAL) {
	$column_tasks = array_select_keys($column_tasks, array_keys($tasks));
	}

	$column_phid = $column->getPHID();

	$visible_columns[$column_phid] = $column;
	$column_phids[$column_phid] = $column_tasks;

	foreach ($column_tasks as $phid => $task) {
	$visible_phids[$phid] = $phid;
	}
	}

	$rendering_engine = id(new PhabricatorBoardRenderingEngine())
	->setViewer($viewer)
	->setObjects(array_select_keys($tasks, $visible_phids))
	->setEditMap($task_can_edit_map)
	->setExcludedProjectPHIDs($select_phids);

	$templates = array();
	$column_maps = array();
	$all_tasks = array();
	foreach ($visible_columns as $column_phid => $column) {
	$column_tasks = $column_phids[$column_phid];

	$panel = id(new PHUIWorkpanelView())
	->setHeader($column->getDisplayName())
	->setSubHeader($column->getDisplayType())
	->addSigil('workpanel');

	$proxy = $column->getProxy();
	if ($proxy) {
	$proxy_id = $proxy->getID();
	$href = $this->getApplicationURI("view/{$proxy_id}/");
	$panel->setHref($href);
	}

	$header_icon = $column->getHeaderIcon();
	if ($header_icon) {
	$panel->setHeaderIcon($header_icon);
	}

	$display_class = $column->getDisplayClass();
	if ($display_class) {
	$panel->addClass($display_class);
	}

	if ($column->isHidden()) {
	$panel->addClass('project-panel-hidden');
	}

	$column_menu = $this->buildColumnMenu($project, $column);
	$panel->addHeaderAction($column_menu);

	$count_tag = id(new PHUITagView())
	->setType(PHUITagView::TYPE_SHADE)
	->setColor(PHUITagView::COLOR_BLUE)
	->addSigil('column-points')
	->setName(
	javelin_tag(
	'span',
	array(
	'sigil' => 'column-points-content',
	),
	pht('-')))
	->setStyle('display: none');

	$panel->setHeaderTag($count_tag);

	$cards = id(new PHUIObjectItemListView())
	->setUser($viewer)
	->setFlush(true)
	->setAllowEmptyList(true)
	->addSigil('project-column')
	->setItemClass('phui-workcard')
	->setMetadata(
	array(
	'columnPHID' => $column->getPHID(),
	'pointLimit' => $column->getPointLimit(),
	));

	foreach ($column_tasks as $task) {
	$object_phid = $task->getPHID();

	$card = $rendering_engine->renderCard($object_phid);
	$templates[$object_phid] = hsprintf('%s', $card->getItem());
	$column_maps[$column_phid][] = $object_phid;

	$all_tasks[$object_phid] = $task;
	}

	$panel->setCards($cards);
	$board->addPanel($panel);
	}

	$behavior_config = array(
	'moveURI' => $this->getApplicationURI('move/'.$project->getID().'/'),
	'uploadURI' => '/file/dropupload/',
	'coverURI' => $this->getApplicationURI('cover/'),
	'chunkThreshold' => PhabricatorFileStorageEngine::getChunkThreshold(),
	'pointsEnabled' => ManiphestTaskPoints::getIsEnabled(),

	'boardPHID' => $project->getPHID(),
	'order' => $this->sortKey,
	'templateMap' => $templates,
	'columnMaps' => $column_maps,
	'orderMaps' => mpull($all_tasks, 'getWorkboardOrderVectors'),
	'propertyMaps' => mpull($all_tasks, 'getWorkboardProperties'),

	'boardID' => $board_id,
	'projectPHID' => $project->getPHID(),
	);
	$this->initBehavior('project-boards', $behavior_config);


	$sort_menu = $this->buildSortMenu(
	$viewer,
	$project,
	$this->sortKey);

	$filter_menu = $this->buildFilterMenu(
	$viewer,
	$project,
	$custom_query,
	$search_engine,
	$query_key);

	$manage_menu = $this->buildManageMenu($project, $this->showHidden);

	$header_link = phutil_tag(
	'a',
	array(
	'href' => $this->getApplicationURI('profile/'.$project->getID().'/'),
	),
	$project->getName());

	$board_box = id(new PHUIBoxView())
	->appendChild($board)
	->addClass('project-board-wrapper');

	$nav = $this->getProfileMenu();

	$divider = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_DIVIDER);
	$fullscreen = $this->buildFullscreenMenu();

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Workboard'));
	$crumbs->setBorder(true);

	$crumbs->addAction($sort_menu);
	$crumbs->addAction($filter_menu);
	$crumbs->addAction($divider);
	$crumbs->addAction($manage_menu);
	$crumbs->addAction($fullscreen);

	$page = $this->newPage()
	->setTitle(
	array(
	$project->getDisplayName(),
	pht('Workboard'),
	))
	->setPageObjectPHIDs(array($project->getPHID()))
	->setShowFooter(false)
	->setNavigation($nav)
	->setCrumbs($crumbs)
	->addQuicksandConfig(
	array(
	'boardConfig' => $behavior_config,
	))
	->appendChild(
	array(
	$board_box,
	));

	$background = $project->getDisplayWorkboardBackgroundColor();
	require_celerity_resource('phui-workboard-color-css');
	if ($background !== null) {
	$background_color_class = "phui-workboard-{$background}";

	$page->addClass('phui-workboard-color');
	$page->addClass($background_color_class);
	} else {
	$page->addClass('phui-workboard-no-color');
	}

	return $page;
	}

	private function readRequestState() {
	$request = $this->getRequest();
	$project = $this->getProject();

	$this->showHidden = $request->getBool('hidden');
	$this->id = $project->getID();

	$sort_key = $this->getDefaultSort($project);

	$request_sort = $request->getStr('order');
	if ($this->isValidSort($request_sort)) {
	$sort_key = $request_sort;
	}

	$this->sortKey = $sort_key;
	}

	private function getDefaultSort(PhabricatorProject $project) {
	$default_sort = $project->getDefaultWorkboardSort();

	if ($this->isValidSort($default_sort)) {
	return $default_sort;
	}

	return PhabricatorProjectColumn::DEFAULT_ORDER;
	}

	private function getDefaultFilter(PhabricatorProject $project) {
	$default_filter = $project->getDefaultWorkboardFilter();

	if (strlen($default_filter)) {
	return $default_filter;
	}

	return 'open';
	}

	private function isValidSort($sort) {
	switch ($sort) {
	case PhabricatorProjectColumn::ORDER_NATURAL:
	case PhabricatorProjectColumn::ORDER_PRIORITY:
	return true;
	}

	return false;
	}

	private function buildSortMenu(
	PhabricatorUser $viewer,
	PhabricatorProject $project,
	$sort_key) {

	$sort_icon = id(new PHUIIconView())
	->setIcon('fa-sort-amount-asc bluegrey');

	$named = array(
	PhabricatorProjectColumn::ORDER_NATURAL => pht('Natural'),
	PhabricatorProjectColumn::ORDER_PRIORITY => pht('Sort by Priority'),
	);

	$base_uri = $this->getURIWithState();

	$items = array();
	foreach ($named as $key => $name) {
	$is_selected = ($key == $sort_key);
	if ($is_selected) {
	$active_order = $name;
	}

	$item = id(new PhabricatorActionView())
	->setIcon('fa-sort-amount-asc')
	->setSelected($is_selected)
	->setName($name);

	$uri = $base_uri->alter('order', $key);
	$item->setHref($uri);

	$items[] = $item;
	}

	$id = $project->getID();

	$save_uri = "default/{$id}/sort/";
	$save_uri = $this->getApplicationURI($save_uri);
	$save_uri = $this->getURIWithState($save_uri, $force = true);

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

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-floppy-o')
	->setName(pht('Save as Default'))
	->setHref($save_uri)
	->setWorkflow(true)
	->setDisabled(!$can_edit);

	$sort_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($items as $item) {
	$sort_menu->addAction($item);
	}

	$sort_button = id(new PHUIListItemView())
	->setName($active_order)
	->setIcon('fa-sort-amount-asc')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $sort_menu),
	));

	return $sort_button;
	}

	private function buildFilterMenu(
	PhabricatorUser $viewer,
	PhabricatorProject $project,
	$custom_query,
	PhabricatorApplicationSearchEngine $engine,
	$query_key) {

	$named = array(
	'open' => pht('Open Tasks'),
	'all' => pht('All Tasks'),
	);

	if ($viewer->isLoggedIn()) {
	$named['assigned'] = pht('Assigned to Me');
	}

	if ($custom_query) {
	$named[$custom_query->getQueryKey()] = pht('Custom Filter');
	}

	$items = array();
	foreach ($named as $key => $name) {
	$is_selected = ($key == $query_key);
	if ($is_selected) {
	$active_filter = $name;
	}

	$is_custom = false;
	if ($custom_query) {
	$is_custom = ($key == $custom_query->getQueryKey());
	}

	$item = id(new PhabricatorActionView())
	->setIcon('fa-search')
	->setSelected($is_selected)
	->setName($name);

	if ($is_custom) {
	$uri = $this->getApplicationURI(
	'board/'.$this->id.'/filter/query/'.$key.'/');
	$item->setWorkflow(true);
	} else {
	$uri = $engine->getQueryResultsPageURI($key);
	}

	$uri = $this->getURIWithState($uri)
	->setQueryParam('filter', null);
	$item->setHref($uri);

	$items[] = $item;
	}

	$id = $project->getID();

	$filter_uri = $this->getApplicationURI("board/{$id}/filter/");
	$filter_uri = $this->getURIWithState($filter_uri, $force = true);

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-cog')
	->setHref($filter_uri)
	->setWorkflow(true)
	->setName(pht('Advanced Filter...'));

	$save_uri = "default/{$id}/filter/";
	$save_uri = $this->getApplicationURI($save_uri);
	$save_uri = $this->getURIWithState($save_uri, $force = true);

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

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-floppy-o')
	->setName(pht('Save as Default'))
	->setHref($save_uri)
	->setWorkflow(true)
	->setDisabled(!$can_edit);

	$filter_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($items as $item) {
	$filter_menu->addAction($item);
	}

	$filter_button = id(new PHUIListItemView())
	->setName($active_filter)
	->setIcon('fa-search')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $filter_menu),
	));

	return $filter_button;
	}

	private function buildManageMenu(
	PhabricatorProject $project,
	$show_hidden) {

	$request = $this->getRequest();
	$viewer = $request->getUser();

	$id = $project->getID();

	$manage_uri = $this->getApplicationURI("board/{$id}/manage/");
	$add_uri = $this->getApplicationURI("board/{$id}/edit/");

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

	$manage_items = array();

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-plus')
	->setName(pht('Add Column'))
	->setHref($add_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(true);

	$reorder_uri = $this->getApplicationURI("board/{$id}/reorder/");
	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-exchange')
	->setName(pht('Reorder Columns'))
	->setHref($reorder_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(true);

	if ($show_hidden) {
	$hidden_uri = $this->getURIWithState()
	->setQueryParam('hidden', null);
	$hidden_icon = 'fa-eye-slash';
	$hidden_text = pht('Hide Hidden Columns');
	} else {
	$hidden_uri = $this->getURIWithState()
	->setQueryParam('hidden', 'true');
	$hidden_icon = 'fa-eye';
	$hidden_text = pht('Show Hidden Columns');
	}

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon($hidden_icon)
	->setName($hidden_text)
	->setHref($hidden_uri);

	$manage_items[] = id(new PhabricatorActionView())
	->setType(PhabricatorActionView::TYPE_DIVIDER);

	$background_uri = $this->getApplicationURI("board/{$id}/background/");
	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-paint-brush')
	->setName(pht('Change Background Color'))
	->setHref($background_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(false);

	$manage_uri = $this->getApplicationURI("board/{$id}/manage/");
	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-gear')
	->setName(pht('Manage Workboard'))
	->setHref($manage_uri);

	$batch_edit_uri = $request->getRequestURI();
	$batch_edit_uri->setQueryParam('batch', self::BATCH_EDIT_ALL);
	$can_batch_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
	ManiphestBulkEditCapability::CAPABILITY);

	$manage_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($manage_items as $item) {
	$manage_menu->addAction($item);
	}

	$manage_button = id(new PHUIListItemView())
	->setIcon('fa-cog')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->addSigil('has-tooltip')
	->setMetadata(
	array(
	'tip' => pht('Manage'),
	'align' => 'S',
	'items' => hsprintf('%s', $manage_menu),
	));

	return $manage_button;
	}

	private function buildFullscreenMenu() {

	$up = id(new PHUIListItemView())
	->setIcon('fa-arrows-alt')
	->setHref('#')
	->addClass('phui-workboard-expand-icon')
	->addSigil('jx-toggle-class')
	->addSigil('has-tooltip')
	->setMetaData(array(
	'tip' => pht('Fullscreen'),
	'map' => array(
	'phabricator-standard-page' => 'phui-workboard-fullscreen',
	),
	));

	return $up;
	}

	private function buildColumnMenu(
	PhabricatorProject $project,
	PhabricatorProjectColumn $column) {

	$request = $this->getRequest();
	$viewer = $request->getUser();

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

	$column_items = array();

	if ($column->getProxyPHID()) {
	$default_phid = $column->getProxyPHID();
	} else {
	$default_phid = $column->getProjectPHID();
	}

	$specs = id(new ManiphestEditEngine())
	->setViewer($viewer)
	->newCreateActionSpecifications(array());

	foreach ($specs as $spec) {
	$column_items[] = id(new PhabricatorActionView())
	->setIcon($spec['icon'])
	->setName($spec['name'])
	->setHref($spec['uri'])
	->setDisabled($spec['disabled'])
	->addSigil('column-add-task')
	->setMetadata(
	array(
	'createURI' => $spec['uri'],
	'columnPHID' => $column->getPHID(),
	'boardPHID' => $project->getPHID(),
	'projectPHID' => $default_phid,
	));
	}

	if (count($specs) > 1) {
	$column_items[] = id(new PhabricatorActionView())
	->setType(PhabricatorActionView::TYPE_DIVIDER);
	}

	$batch_edit_uri = $request->getRequestURI();
	$batch_edit_uri->setQueryParam('batch', $column->getID());
	$can_batch_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
	ManiphestBulkEditCapability::CAPABILITY);

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-list-ul')
	->setName(pht('Bulk Edit Tasks...'))
	->setHref($batch_edit_uri)
	->setDisabled(!$can_batch_edit);

	$batch_move_uri = $request->getRequestURI();
	$batch_move_uri->setQueryParam('move', $column->getID());
	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-arrow-right')
	->setName(pht('Move Tasks to Column...'))
	->setHref($batch_move_uri)
	->setWorkflow(true);

	$query_uri = $request->getRequestURI();
	$query_uri->setQueryParam('queryColumnID', $column->getID());

	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('View as Query'))
	->setIcon('fa-search')
	->setHref($query_uri);

	$edit_uri = 'board/'.$this->id.'/edit/'.$column->getID().'/';
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Edit Column'))
	->setIcon('fa-pencil')
	->setHref($this->getApplicationURI($edit_uri))
	->setDisabled(!$can_edit)
	->setWorkflow(true);

	$can_hide = ($can_edit && !$column->isDefaultColumn());
	$hide_uri = 'board/'.$this->id.'/hide/'.$column->getID().'/';
	$hide_uri = $this->getApplicationURI($hide_uri);
	$hide_uri = $this->getURIWithState($hide_uri);

	if (!$column->isHidden()) {
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Hide Column'))
	->setIcon('fa-eye-slash')
	->setHref($hide_uri)
	->setDisabled(!$can_hide)
	->setWorkflow(true);
	} else {
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Show Column'))
	->setIcon('fa-eye')
	->setHref($hide_uri)
	->setDisabled(!$can_hide)
	->setWorkflow(true);
	}

	$column_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($column_items as $item) {
	$column_menu->addAction($item);
	}

	$column_button = id(new PHUIIconView())
	->setIcon('fa-caret-down')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $column_menu),
	));

	return $column_button;
	}


	/**
	* Add current state parameters (like order and the visibility of hidden
	* columns) to a URI.
	*
	* This allows actions which toggle or adjust one piece of state to keep
	* the rest of the board state persistent. If no URI is provided, this method
	* starts with the request URI.
	*
	* @param string\|null URI to add state parameters to.
	* @param bool True to explicitly include all state.
	* @return PhutilURI URI with state parameters.
	*/
	private function getURIWithState($base = null, $force = false) {
	$project = $this->getProject();

	if ($base === null) {
	$base = $this->getRequest()->getRequestURI();
	}

	$base = new PhutilURI($base);

	if ($force \|\| ($this->sortKey != $this->getDefaultSort($project))) {
	$base->setQueryParam('order', $this->sortKey);
	} else {
	$base->setQueryParam('order', null);
	}

	if ($force \|\| ($this->queryKey != $this->getDefaultFilter($project))) {
	$base->setQueryParam('filter', $this->queryKey);
	} else {
	$base->setQueryParam('filter', null);
	}

	$base->setQueryParam('hidden', $this->showHidden ? 'true' : null);

	return $base;
	}

	private function buildInitializeContent(PhabricatorProject $project) {
	$request = $this->getRequest();
	$viewer = $this->getViewer();

	$type = $request->getStr('initialize-type');

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");
	$board_uri = $this->getApplicationURI("board/{$id}/");
	$import_uri = $this->getApplicationURI("board/{$id}/import/");

	$set_default = $request->getBool('default');
	if ($set_default) {
	$this
	->getProfileMenuEngine()
	->adjustDefault(PhabricatorProject::ITEM_WORKBOARD);
	}

	if ($request->isFormPost()) {
	if ($type == 'backlog-only') {
	$column = PhabricatorProjectColumn::initializeNewColumn($viewer)
	->setSequence(0)
	->setProperty('isDefault', true)
	->setProjectPHID($project->getPHID())
	->save();

	$xactions = array();
	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(
	PhabricatorProjectWorkboardTransaction::TRANSACTIONTYPE)
	->setNewValue(1);

	id(new PhabricatorProjectTransactionEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->applyTransactions($project, $xactions);

	return id(new AphrontRedirectResponse())
	->setURI($board_uri);
	} else {
	return id(new AphrontRedirectResponse())
	->setURI($import_uri);
	}
	}

	// TODO: Tailor this UI if the project is already a parent project. We
	// should not offer options for creating a parent project workboard, since
	// they can't have their own columns.

	$new_selector = id(new AphrontFormRadioButtonControl())
	->setLabel(pht('Columns'))
	->setName('initialize-type')
	->setValue('backlog-only')
	->addButton(
	'backlog-only',
	pht('New Empty Board'),
	pht('Create a new board with just a backlog column.'))
	->addButton(
	'import',
	pht('Import Columns'),
	pht('Import board columns from another project.'));

	$default_checkbox = id(new AphrontFormCheckboxControl())
	->setLabel(pht('Make Default'))
	->addCheckbox(
	'default',
	1,
	pht('Make the workboard the default view for this project.'),
	true);

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->addHiddenInput('initialize', 1)
	->appendRemarkupInstructions(
	pht('The workboard for this project has not been created yet.'))
	->appendControl($new_selector)
	->appendControl($default_checkbox)
	->appendControl(
	id(new AphrontFormSubmitControl())
	->addCancelButton($profile_uri)
	->setValue(pht('Create Workboard')));

	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Create Workboard'))
	->setForm($form);

	return $box;
	}

	private function buildNoAccessContent(PhabricatorProject $project) {
	$viewer = $this->getViewer();

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");

	return $this->newDialog()
	->setTitle(pht('Unable to Create Workboard'))
	->appendParagraph(
	pht(
	'The workboard for this project has not been created yet, '.
	'but you do not have permission to create it. Only users '.
	'who can edit this project can create a workboard for it.'))
	->addCancelButton($profile_uri);
	}


	private function buildEnableContent(PhabricatorProject $project) {
	$request = $this->getRequest();
	$viewer = $this->getViewer();

	$id = $project->getID();
	$profile_uri = $this->getApplicationURI("profile/{$id}/");
	$board_uri = $this->getApplicationURI("board/{$id}/");

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

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(
	PhabricatorProjectWorkboardTransaction::TRANSACTIONTYPE)
	->setNewValue(1);

	id(new PhabricatorProjectTransactionEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->applyTransactions($project, $xactions);

	return id(new AphrontRedirectResponse())
	->setURI($board_uri);
	}

	return $this->newDialog()
	->setTitle(pht('Workboard Disabled'))
	->addHiddenInput('initialize', 1)
	->appendParagraph(
	pht(
	'This workboard has been disabled, but can be restored to its '.
	'former glory.'))
	->addCancelButton($profile_uri)
	->addSubmitButton(pht('Enable Workboard'));
	}

	private function buildDisabledContent(PhabricatorProject $project) {
	$viewer = $this->getViewer();

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");

	return $this->newDialog()
	->setTitle(pht('Workboard Disabled'))
	->appendParagraph(
	pht(
	'This workboard has been disabled, and you do not have permission '.
	'to enable it. Only users who can edit this project can restore '.
	'the workboard.'))
	->addCancelButton($profile_uri);
	}

	}
	diff --git a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	index b808291a52..a89a017e85 100644
	--- a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	+++ b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	@@ -1,1599 +1,1607 @@
	<?php

	/**
	* Represents an abstract search engine for an application. It supports
	* creating and storing saved queries.
	*
	* @task construct Constructing Engines
	* @task app Applications
	* @task builtin Builtin Queries
	* @task uri Query URIs
	* @task dates Date Filters
	* @task order Result Ordering
	* @task read Reading Utilities
	* @task exec Paging and Executing Queries
	* @task render Rendering Results
	*/
	abstract class PhabricatorApplicationSearchEngine extends Phobject {

	private $application;
	private $viewer;
	private $errors = array();
	private $request;
	private $context;
	private $controller;
	private $namedQueries;
	private $navigationItems = array();

	const CONTEXT_LIST = 'list';
	const CONTEXT_PANEL = 'panel';

	const BUCKET_NONE = 'none';

	public function setController(PhabricatorController $controller) {
	$this->controller = $controller;
	return $this;
	}

	public function getController() {
	return $this->controller;
	}

	public function buildResponse() {
	$controller = $this->getController();
	$request = $controller->getRequest();

	$search = id(new PhabricatorApplicationSearchController())
	->setQueryKey($request->getURIData('queryKey'))
	->setSearchEngine($this);

	return $controller->delegateToController($search);
	}

	public function newResultObject() {
	// We may be able to get this automatically if newQuery() is implemented.
	$query = $this->newQuery();
	if ($query) {
	$object = $query->newResultObject();
	if ($object) {
	return $object;
	}
	}

	return null;
	}

	public function newQuery() {
	return null;
	}

	public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}

	protected function requireViewer() {
	if (!$this->viewer) {
	throw new PhutilInvalidStateException('setViewer');
	}
	return $this->viewer;
	}

	public function setContext($context) {
	$this->context = $context;
	return $this;
	}

	public function isPanelContext() {
	return ($this->context == self::CONTEXT_PANEL);
	}

	public function setNavigationItems(array $navigation_items) {
	assert_instances_of($navigation_items, 'PHUIListItemView');
	$this->navigationItems = $navigation_items;
	return $this;
	}

	public function getNavigationItems() {
	return $this->navigationItems;
	}

	public function canUseInPanelContext() {
	return true;
	}

	public function saveQuery(PhabricatorSavedQuery $query) {
	+ if ($query->getID()) {
	+ throw new Exception(
	+ pht(
	+ 'Query (with ID "%s") has already been saved. Queries are '.
	+ 'immutable once saved.',
	+ $query->getID()));
	+ }
	+
	$query->setEngineClassName(get_class($this));

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	try {
	$query->save();
	} catch (AphrontDuplicateKeyQueryException $ex) {
	// Ignore, this is just a repeated search.
	}
	unset($unguarded);
	}

	/**
	* Create a saved query object from the request.
	*
	* @param AphrontRequest The search request.
	* @return PhabricatorSavedQuery
	*/
	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$fields = $this->buildSearchFields();
	$viewer = $this->requireViewer();

	$saved = new PhabricatorSavedQuery();
	foreach ($fields as $field) {
	$field->setViewer($viewer);

	$value = $field->readValueFromRequest($request);
	$saved->setParameter($field->getKey(), $value);
	}

	return $saved;
	}

	/**
	* Executes the saved query.
	*
	* @param PhabricatorSavedQuery The saved query to operate on.
	* @return PhabricatorQuery The result of the query.
	*/
	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $original) {
	$saved = clone $original;
	$this->willUseSavedQuery($saved);

	$fields = $this->buildSearchFields();
	$viewer = $this->requireViewer();

	$map = array();
	foreach ($fields as $field) {
	$field->setViewer($viewer);
	$field->readValueFromSavedQuery($saved);
	$value = $field->getValueForQuery($field->getValue());
	$map[$field->getKey()] = $value;
	}

	$original->attachParameterMap($map);
	$query = $this->buildQueryFromParameters($map);

	$object = $this->newResultObject();
	if (!$object) {
	return $query;
	}

	$extensions = $this->getEngineExtensions();
	foreach ($extensions as $extension) {
	$extension->applyConstraintsToQuery($object, $query, $saved, $map);
	}

	$order = $saved->getParameter('order');
	$builtin = $query->getBuiltinOrderAliasMap();
	if (strlen($order) && isset($builtin[$order])) {
	$query->setOrder($order);
	} else {
	// If the order is invalid or not available, we choose the first
	// builtin order. This isn't always the default order for the query,
	// but is the first value in the "Order" dropdown, and makes the query
	// behavior more consistent with the UI. In queries where the two
	// orders differ, this order is the preferred order for humans.
	$query->setOrder(head_key($builtin));
	}

	return $query;
	}

	/**
	* Hook for subclasses to adjust saved queries prior to use.
	*
	* If an application changes how queries are saved, it can implement this
	* hook to keep old queries working the way users expect, by reading,
	* adjusting, and overwriting parameters.
	*
	* @param PhabricatorSavedQuery Saved query which will be executed.
	* @return void
	*/
	protected function willUseSavedQuery(PhabricatorSavedQuery $saved) {
	return;
	}

	protected function buildQueryFromParameters(array $parameters) {
	throw new PhutilMethodNotImplementedException();
	}

	/**
	* Builds the search form using the request.
	*
	* @param AphrontFormView Form to populate.
	* @param PhabricatorSavedQuery The query from which to build the form.
	* @return void
	*/
	public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved) {

	$saved = clone $saved;
	$this->willUseSavedQuery($saved);

	$fields = $this->buildSearchFields();
	$fields = $this->adjustFieldsForDisplay($fields);
	$viewer = $this->requireViewer();

	foreach ($fields as $field) {
	$field->setViewer($viewer);
	$field->readValueFromSavedQuery($saved);
	}

	foreach ($fields as $field) {
	foreach ($field->getErrors() as $error) {
	$this->addError(last($error));
	}
	}

	foreach ($fields as $field) {
	$field->appendToForm($form);
	}
	}

	protected function buildSearchFields() {
	$fields = array();

	foreach ($this->buildCustomSearchFields() as $field) {
	$fields[] = $field;
	}

	$object = $this->newResultObject();
	if ($object) {
	$extensions = $this->getEngineExtensions();
	foreach ($extensions as $extension) {
	$extension_fields = $extension->getSearchFields($object);
	foreach ($extension_fields as $extension_field) {
	$fields[] = $extension_field;
	}
	}
	}

	$query = $this->newQuery();
	if ($query && $this->shouldShowOrderField()) {
	$orders = $query->getBuiltinOrders();
	$orders = ipull($orders, 'name');

	$fields[] = id(new PhabricatorSearchOrderField())
	->setLabel(pht('Order By'))
	->setKey('order')
	->setOrderAliases($query->getBuiltinOrderAliasMap())
	->setOptions($orders);
	}

	$buckets = $this->newResultBuckets();
	if ($query && $buckets) {
	$bucket_options = array(
	self::BUCKET_NONE => pht('No Bucketing'),
	) + mpull($buckets, 'getResultBucketName');

	$fields[] = id(new PhabricatorSearchSelectField())
	->setLabel(pht('Bucket'))
	->setKey('bucket')
	->setOptions($bucket_options);
	}

	$field_map = array();
	foreach ($fields as $field) {
	$key = $field->getKey();
	if (isset($field_map[$key])) {
	throw new Exception(
	pht(
	'Two fields in this SearchEngine use the same key ("%s"), but '.
	'each field must use a unique key.',
	$key));
	}
	$field_map[$key] = $field;
	}

	return $field_map;
	}

	protected function shouldShowOrderField() {
	return true;
	}

	private function adjustFieldsForDisplay(array $field_map) {
	$order = $this->getDefaultFieldOrder();

	$head_keys = array();
	$tail_keys = array();
	$seen_tail = false;
	foreach ($order as $order_key) {
	if ($order_key === '...') {
	$seen_tail = true;
	continue;
	}

	if (!$seen_tail) {
	$head_keys[] = $order_key;
	} else {
	$tail_keys[] = $order_key;
	}
	}

	$head = array_select_keys($field_map, $head_keys);
	$body = array_diff_key($field_map, array_fuse($tail_keys));
	$tail = array_select_keys($field_map, $tail_keys);

	$result = $head + $body + $tail;

	// Force the fulltext "query" field to the top unconditionally.
	$result = array_select_keys($result, array('query')) + $result;

	foreach ($this->getHiddenFields() as $hidden_key) {
	unset($result[$hidden_key]);
	}

	return $result;
	}

	protected function buildCustomSearchFields() {
	throw new PhutilMethodNotImplementedException();
	}


	/**
	* Define the default display order for fields by returning a list of
	* field keys.
	*
	* You can use the special key `...` to mean "all unspecified fields go
	* here". This lets you easily put important fields at the top of the form,
	* standard fields in the middle of the form, and less important fields at
	* the bottom.
	*
	* For example, you might return a list like this:
	*
	* return array(
	* 'authorPHIDs',
	* 'reviewerPHIDs',
	* '...',
	* 'createdAfter',
	* 'createdBefore',
	* );
	*
	* Any unspecified fields (including custom fields and fields added
	* automatically by infrastructure) will be put in the middle.
	*
	* @return list<string> Default ordering for field keys.
	*/
	protected function getDefaultFieldOrder() {
	return array();
	}

	/**
	* Return a list of field keys which should be hidden from the viewer.
	*
	* @return list<string> Fields to hide.
	*/
	protected function getHiddenFields() {
	return array();
	}

	public function getErrors() {
	return $this->errors;
	}

	public function addError($error) {
	$this->errors[] = $error;
	return $this;
	}

	/**
	* Return an application URI corresponding to the results page of a query.
	* Normally, this is something like `/application/query/QUERYKEY/`.
	*
	* @param string The query key to build a URI for.
	* @return string URI where the query can be executed.
	* @task uri
	*/
	public function getQueryResultsPageURI($query_key) {
	return $this->getURI('query/'.$query_key.'/');
	}


	/**
	* Return an application URI for query management. This is used when, e.g.,
	* a query deletion operation is cancelled.
	*
	* @return string URI where queries can be managed.
	* @task uri
	*/
	public function getQueryManagementURI() {
	return $this->getURI('query/edit/');
	}

	public function getQueryBaseURI() {
	return $this->getURI('');
	}

	public function getExportURI($query_key) {
	return $this->getURI('query/'.$query_key.'/export/');
	}


	/**
	* Return the URI to a path within the application. Used to construct default
	* URIs for management and results.
	*
	* @return string URI to path.
	* @task uri
	*/
	abstract protected function getURI($path);


	/**
	* Return a human readable description of the type of objects this query
	* searches for.
	*
	* For example, "Tasks" or "Commits".
	*
	* @return string Human-readable description of what this engine is used to
	* find.
	*/
	abstract public function getResultTypeDescription();


	public function newSavedQuery() {
	return id(new PhabricatorSavedQuery())
	->setEngineClassName(get_class($this));
	}

	public function addNavigationItems(PHUIListView $menu) {
	$viewer = $this->requireViewer();

	$menu->newLabel(pht('Queries'));

	$named_queries = $this->loadEnabledNamedQueries();

	foreach ($named_queries as $query) {
	$key = $query->getQueryKey();
	$uri = $this->getQueryResultsPageURI($key);
	$menu->newLink($query->getQueryName(), $uri, 'query/'.$key);
	}

	if ($viewer->isLoggedIn()) {
	$manage_uri = $this->getQueryManagementURI();
	$menu->newLink(pht('Edit Queries...'), $manage_uri, 'query/edit');
	}

	$menu->newLabel(pht('Search'));
	$advanced_uri = $this->getQueryResultsPageURI('advanced');
	$menu->newLink(pht('Advanced Search'), $advanced_uri, 'query/advanced');

	foreach ($this->navigationItems as $extra_item) {
	$menu->addMenuItem($extra_item);
	}

	return $this;
	}

	public function loadAllNamedQueries() {
	$viewer = $this->requireViewer();
	$builtin = $this->getBuiltinQueries();

	if ($this->namedQueries === null) {
	$named_queries = id(new PhabricatorNamedQueryQuery())
	->setViewer($viewer)
	->withEngineClassNames(array(get_class($this)))
	->withUserPHIDs(
	array(
	$viewer->getPHID(),
	PhabricatorNamedQuery::SCOPE_GLOBAL,
	))
	->execute();
	$named_queries = mpull($named_queries, null, 'getQueryKey');

	$builtin = mpull($builtin, null, 'getQueryKey');

	foreach ($named_queries as $key => $named_query) {
	if ($named_query->getIsBuiltin()) {
	if (isset($builtin[$key])) {
	$named_queries[$key]->setQueryName($builtin[$key]->getQueryName());
	unset($builtin[$key]);
	} else {
	unset($named_queries[$key]);
	}
	}

	unset($builtin[$key]);
	}

	$named_queries = msortv($named_queries, 'getNamedQuerySortVector');
	$this->namedQueries = $named_queries;
	}

	return $this->namedQueries + $builtin;
	}

	public function loadEnabledNamedQueries() {
	$named_queries = $this->loadAllNamedQueries();
	foreach ($named_queries as $key => $named_query) {
	if ($named_query->getIsBuiltin() && $named_query->getIsDisabled()) {
	unset($named_queries[$key]);
	}
	}
	return $named_queries;
	}

	public function getDefaultQueryKey() {
	$viewer = $this->requireViewer();

	$configs = id(new PhabricatorNamedQueryConfigQuery())
	->setViewer($viewer)
	->withEngineClassNames(array(get_class($this)))
	->withScopePHIDs(
	array(
	$viewer->getPHID(),
	PhabricatorNamedQueryConfig::SCOPE_GLOBAL,
	))
	->execute();
	$configs = msortv($configs, 'getStrengthSortVector');

	$key_pinned = PhabricatorNamedQueryConfig::PROPERTY_PINNED;
	$map = $this->loadEnabledNamedQueries();
	foreach ($configs as $config) {
	$pinned = $config->getConfigProperty($key_pinned);
	if (!isset($map[$pinned])) {
	continue;
	}

	return $pinned;
	}

	return head_key($map);
	}

	protected function setQueryProjects(
	PhabricatorCursorPagedPolicyAwareQuery $query,
	PhabricatorSavedQuery $saved) {

	$datasource = id(new PhabricatorProjectLogicalDatasource())
	->setViewer($this->requireViewer());

	$projects = $saved->getParameter('projects', array());
	$constraints = $datasource->evaluateTokens($projects);

	if ($constraints) {
	$query->withEdgeLogicConstraints(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	$constraints);
	}

	return $this;
	}


	/* -( Applications )------------------------------------------------------- */


	protected function getApplicationURI($path = '') {
	return $this->getApplication()->getApplicationURI($path);
	}

	protected function getApplication() {
	if (!$this->application) {
	$class = $this->getApplicationClassName();

	$this->application = id(new PhabricatorApplicationQuery())
	->setViewer($this->requireViewer())
	->withClasses(array($class))
	->withInstalled(true)
	->executeOne();

	if (!$this->application) {
	throw new Exception(
	pht(
	'Application "%s" is not installed!',
	$class));
	}
	}

	return $this->application;
	}

	abstract public function getApplicationClassName();


	/* -( Constructing Engines )----------------------------------------------- */


	/**
	* Load all available application search engines.
	*
	* @return list<PhabricatorApplicationSearchEngine> All available engines.
	* @task construct
	*/
	public static function getAllEngines() {
	return id(new PhutilClassMapQuery())
	->setAncestorClass(__CLASS__)
	->execute();
	}


	/**
	* Get an engine by class name, if it exists.
	*
	* @return PhabricatorApplicationSearchEngine\|null Engine, or null if it does
	* not exist.
	* @task construct
	*/
	public static function getEngineByClassName($class_name) {
	return idx(self::getAllEngines(), $class_name);
	}


	/* -( Builtin Queries )---------------------------------------------------- */


	/**
	* @task builtin
	*/
	public function getBuiltinQueries() {
	$names = $this->getBuiltinQueryNames();

	$queries = array();
	$sequence = 0;
	foreach ($names as $key => $name) {
	$queries[$key] = id(new PhabricatorNamedQuery())
	->setUserPHID(PhabricatorNamedQuery::SCOPE_GLOBAL)
	->setEngineClassName(get_class($this))
	->setQueryName($name)
	->setQueryKey($key)
	->setSequence((1 << 24) + $sequence++)
	->setIsBuiltin(true);
	}

	return $queries;
	}


	/**
	* @task builtin
	*/
	public function getBuiltinQuery($query_key) {
	if (!$this->isBuiltinQuery($query_key)) {
	throw new Exception(pht("'%s' is not a builtin!", $query_key));
	}
	return idx($this->getBuiltinQueries(), $query_key);
	}


	/**
	* @task builtin
	*/
	protected function getBuiltinQueryNames() {
	return array();
	}


	/**
	* @task builtin
	*/
	public function isBuiltinQuery($query_key) {
	$builtins = $this->getBuiltinQueries();
	return isset($builtins[$query_key]);
	}


	/**
	* @task builtin
	*/
	public function buildSavedQueryFromBuiltin($query_key) {
	throw new Exception(pht("Builtin '%s' is not supported!", $query_key));
	}


	/* -( Reading Utilities )--------------------------------------------------- */


	/**
	* Read a list of user PHIDs from a request in a flexible way. This method
	* supports either of these forms:
	*
	* users[]=alincoln&users[]=htaft
	* users=alincoln,htaft
	*
	* Additionally, users can be specified either by PHID or by name.
	*
	* The main goal of this flexibility is to allow external programs to generate
	* links to pages (like "alincoln's open revisions") without needing to make
	* API calls.
	*
	* @param AphrontRequest Request to read user PHIDs from.
	* @param string Key to read in the request.
	* @param list<const> Other permitted PHID types.
	* @return list<phid> List of user PHIDs and selector functions.
	* @task read
	*/
	protected function readUsersFromRequest(
	AphrontRequest $request,
	$key,
	array $allow_types = array()) {

	$list = $this->readListFromRequest($request, $key);

	$phids = array();
	$names = array();
	$allow_types = array_fuse($allow_types);
	$user_type = PhabricatorPeopleUserPHIDType::TYPECONST;
	foreach ($list as $item) {
	$type = phid_get_type($item);
	if ($type == $user_type) {
	$phids[] = $item;
	} else if (isset($allow_types[$type])) {
	$phids[] = $item;
	} else {
	if (PhabricatorTypeaheadDatasource::isFunctionToken($item)) {
	// If this is a function, pass it through unchanged; we'll evaluate
	// it later.
	$phids[] = $item;
	} else {
	$names[] = $item;
	}
	}
	}

	if ($names) {
	$users = id(new PhabricatorPeopleQuery())
	->setViewer($this->requireViewer())
	->withUsernames($names)
	->execute();
	foreach ($users as $user) {
	$phids[] = $user->getPHID();
	}
	$phids = array_unique($phids);
	}

	return $phids;
	}


	/**
	* Read a list of subscribers from a request in a flexible way.
	*
	* @param AphrontRequest Request to read PHIDs from.
	* @param string Key to read in the request.
	* @return list<phid> List of object PHIDs.
	* @task read
	*/
	protected function readSubscribersFromRequest(
	AphrontRequest $request,
	$key) {
	return $this->readUsersFromRequest(
	$request,
	$key,
	array(
	PhabricatorProjectProjectPHIDType::TYPECONST,
	));
	}


	/**
	* Read a list of generic PHIDs from a request in a flexible way. Like
	* @{method:readUsersFromRequest}, this method supports either array or
	* comma-delimited forms. Objects can be specified either by PHID or by
	* object name.
	*
	* @param AphrontRequest Request to read PHIDs from.
	* @param string Key to read in the request.
	* @param list<const> Optional, list of permitted PHID types.
	* @return list<phid> List of object PHIDs.
	*
	* @task read
	*/
	protected function readPHIDsFromRequest(
	AphrontRequest $request,
	$key,
	array $allow_types = array()) {

	$list = $this->readListFromRequest($request, $key);

	$objects = id(new PhabricatorObjectQuery())
	->setViewer($this->requireViewer())
	->withNames($list)
	->execute();
	$list = mpull($objects, 'getPHID');

	if (!$list) {
	return array();
	}

	// If only certain PHID types are allowed, filter out all the others.
	if ($allow_types) {
	$allow_types = array_fuse($allow_types);
	foreach ($list as $key => $phid) {
	if (empty($allow_types[phid_get_type($phid)])) {
	unset($list[$key]);
	}
	}
	}

	return $list;
	}


	/**
	* Read a list of items from the request, in either array format or string
	* format:
	*
	* list[]=item1&list[]=item2
	* list=item1,item2
	*
	* This provides flexibility when constructing URIs, especially from external
	* sources.
	*
	* @param AphrontRequest Request to read strings from.
	* @param string Key to read in the request.
	* @return list<string> List of values.
	*/
	protected function readListFromRequest(
	AphrontRequest $request,
	$key) {
	$list = $request->getArr($key, null);
	if ($list === null) {
	$list = $request->getStrList($key);
	}

	if (!$list) {
	return array();
	}

	return $list;
	}

	protected function readBoolFromRequest(
	AphrontRequest $request,
	$key) {
	if (!strlen($request->getStr($key))) {
	return null;
	}
	return $request->getBool($key);
	}


	protected function getBoolFromQuery(PhabricatorSavedQuery $query, $key) {
	$value = $query->getParameter($key);
	if ($value === null) {
	return $value;
	}
	return $value ? 'true' : 'false';
	}


	/* -( Dates )-------------------------------------------------------------- */


	/**
	* @task dates
	*/
	protected function parseDateTime($date_time) {
	if (!strlen($date_time)) {
	return null;
	}

	return PhabricatorTime::parseLocalTime($date_time, $this->requireViewer());
	}


	/**
	* @task dates
	*/
	protected function buildDateRange(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved_query,
	$start_key,
	$start_name,
	$end_key,
	$end_name) {

	$start_str = $saved_query->getParameter($start_key);
	$start = null;
	if (strlen($start_str)) {
	$start = $this->parseDateTime($start_str);
	if (!$start) {
	$this->addError(
	pht(
	'"%s" date can not be parsed.',
	$start_name));
	}
	}


	$end_str = $saved_query->getParameter($end_key);
	$end = null;
	if (strlen($end_str)) {
	$end = $this->parseDateTime($end_str);
	if (!$end) {
	$this->addError(
	pht(
	'"%s" date can not be parsed.',
	$end_name));
	}
	}

	if ($start && $end && ($start >= $end)) {
	$this->addError(
	pht(
	'"%s" must be a date before "%s".',
	$start_name,
	$end_name));
	}

	$form
	->appendChild(
	id(new PHUIFormFreeformDateControl())
	->setName($start_key)
	->setLabel($start_name)
	->setValue($start_str))
	->appendChild(
	id(new AphrontFormTextControl())
	->setName($end_key)
	->setLabel($end_name)
	->setValue($end_str));
	}


	/* -( Paging and Executing Queries )--------------------------------------- */


	protected function newResultBuckets() {
	return array();
	}

	public function getResultBucket(PhabricatorSavedQuery $saved) {
	$key = $saved->getParameter('bucket');
	if ($key == self::BUCKET_NONE) {
	return null;
	}

	$buckets = $this->newResultBuckets();
	return idx($buckets, $key);
	}


	public function getPageSize(PhabricatorSavedQuery $saved) {
	$bucket = $this->getResultBucket($saved);

	$limit = (int)$saved->getParameter('limit');

	if ($limit > 0) {
	if ($bucket) {
	$bucket->setPageSize($limit);
	}
	return $limit;
	}

	if ($bucket) {
	return $bucket->getPageSize();
	}

	return 100;
	}


	public function shouldUseOffsetPaging() {
	return false;
	}


	public function newPagerForSavedQuery(PhabricatorSavedQuery $saved) {
	if ($this->shouldUseOffsetPaging()) {
	$pager = new PHUIPagerView();
	} else {
	$pager = new AphrontCursorPagerView();
	}

	$page_size = $this->getPageSize($saved);
	if (is_finite($page_size)) {
	$pager->setPageSize($page_size);
	} else {
	// Consider an INF pagesize to mean a large finite pagesize.

	// TODO: It would be nice to handle this more gracefully, but math
	// with INF seems to vary across PHP versions, systems, and runtimes.
	$pager->setPageSize(0xFFFF);
	}

	return $pager;
	}


	public function executeQuery(
	PhabricatorPolicyAwareQuery $query,
	AphrontView $pager) {

	$query->setViewer($this->requireViewer());

	if ($this->shouldUseOffsetPaging()) {
	$objects = $query->executeWithOffsetPager($pager);
	} else {
	$objects = $query->executeWithCursorPager($pager);
	}

	$this->didExecuteQuery($query);

	return $objects;
	}

	protected function didExecuteQuery(PhabricatorPolicyAwareQuery $query) {
	return;
	}


	/* -( Rendering )---------------------------------------------------------- */


	public function setRequest(AphrontRequest $request) {
	$this->request = $request;
	return $this;
	}

	public function getRequest() {
	return $this->request;
	}

	public function renderResults(
	array $objects,
	PhabricatorSavedQuery $query) {

	$phids = $this->getRequiredHandlePHIDsForResultList($objects, $query);

	if ($phids) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireViewer())
	->witHPHIDs($phids)
	->execute();
	} else {
	$handles = array();
	}

	return $this->renderResultList($objects, $query, $handles);
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $objects,
	PhabricatorSavedQuery $query) {
	return array();
	}

	abstract protected function renderResultList(
	array $objects,
	PhabricatorSavedQuery $query,
	array $handles);


	/* -( Application Search )------------------------------------------------- */


	public function getSearchFieldsForConduit() {
	$standard_fields = $this->buildSearchFields();

	$fields = array();
	foreach ($standard_fields as $field_key => $field) {
	$conduit_key = $field->getConduitKey();

	if (isset($fields[$conduit_key])) {
	$other = $fields[$conduit_key];
	$other_key = $other->getKey();

	throw new Exception(
	pht(
	'SearchFields "%s" (of class "%s") and "%s" (of class "%s") both '.
	'define the same Conduit key ("%s"). Keys must be unique.',
	$field_key,
	get_class($field),
	$other_key,
	get_class($other),
	$conduit_key));
	}

	$fields[$conduit_key] = $field;
	}

	// These are handled separately for Conduit, so don't show them as
	// supported.
	unset($fields['order']);
	unset($fields['limit']);

	$viewer = $this->requireViewer();
	foreach ($fields as $key => $field) {
	$field->setViewer($viewer);
	}

	return $fields;
	}

	public function buildConduitResponse(
	ConduitAPIRequest $request,
	ConduitAPIMethod $method) {
	$viewer = $this->requireViewer();

	$query_key = $request->getValue('queryKey');
	if (!strlen($query_key)) {
	$saved_query = new PhabricatorSavedQuery();
	} else if ($this->isBuiltinQuery($query_key)) {
	$saved_query = $this->buildSavedQueryFromBuiltin($query_key);
	} else {
	$saved_query = id(new PhabricatorSavedQueryQuery())
	->setViewer($viewer)
	->withQueryKeys(array($query_key))
	->executeOne();
	if (!$saved_query) {
	throw new Exception(
	pht(
	'Query key "%s" does not correspond to a valid query.',
	$query_key));
	}
	}

	$constraints = $request->getValue('constraints', array());

	$fields = $this->getSearchFieldsForConduit();

	foreach ($fields as $key => $field) {
	if (!$field->getConduitParameterType()) {
	unset($fields[$key]);
	}
	}

	$valid_constraints = array();
	foreach ($fields as $field) {
	foreach ($field->getValidConstraintKeys() as $key) {
	$valid_constraints[$key] = true;
	}
	}

	foreach ($constraints as $key => $constraint) {
	if (empty($valid_constraints[$key])) {
	throw new Exception(
	pht(
	'Constraint "%s" is not a valid constraint for this query.',
	$key));
	}
	}

	foreach ($fields as $field) {
	if (!$field->getValueExistsInConduitRequest($constraints)) {
	continue;
	}

	$value = $field->readValueFromConduitRequest(
	$constraints,
	$request->getIsStrictlyTyped());
	$saved_query->setParameter($field->getKey(), $value);
	}

	// NOTE: Currently, when running an ad-hoc query we never persist it into
	// a saved query. We might want to add an option to do this in the future
	// (for example, to enable a CLI-to-Web workflow where user can view more
	// details about results by following a link), but have no use cases for
	// it today. If we do identify a use case, we could save the query here.

	$query = $this->buildQueryFromSavedQuery($saved_query);
	$pager = $this->newPagerForSavedQuery($saved_query);

	$attachments = $this->getConduitSearchAttachments();

	// TODO: Validate this better.
	$attachment_specs = $request->getValue('attachments', array());
	$attachments = array_select_keys(
	$attachments,
	array_keys($attachment_specs));

	foreach ($attachments as $key => $attachment) {
	$attachment->setViewer($viewer);
	}

	foreach ($attachments as $key => $attachment) {
	$attachment->willLoadAttachmentData($query, $attachment_specs[$key]);
	}

	$this->setQueryOrderForConduit($query, $request);
	$this->setPagerLimitForConduit($pager, $request);
	$this->setPagerOffsetsForConduit($pager, $request);

	$objects = $this->executeQuery($query, $pager);

	$data = array();
	if ($objects) {
	$field_extensions = $this->getConduitFieldExtensions();

	$extension_data = array();
	foreach ($field_extensions as $key => $extension) {
	$extension_data[$key] = $extension->loadExtensionConduitData($objects);
	}

	$attachment_data = array();
	foreach ($attachments as $key => $attachment) {
	$attachment_data[$key] = $attachment->loadAttachmentData(
	$objects,
	$attachment_specs[$key]);
	}

	foreach ($objects as $object) {
	$field_map = $this->getObjectWireFieldsForConduit(
	$object,
	$field_extensions,
	$extension_data);

	$attachment_map = array();
	foreach ($attachments as $key => $attachment) {
	$attachment_map[$key] = $attachment->getAttachmentForObject(
	$object,
	$attachment_data[$key],
	$attachment_specs[$key]);
	}

	// If this is empty, we still want to emit a JSON object, not a
	// JSON list.
	if (!$attachment_map) {
	$attachment_map = (object)$attachment_map;
	}

	$id = (int)$object->getID();
	$phid = $object->getPHID();

	$data[] = array(
	'id' => $id,
	'type' => phid_get_type($phid),
	'phid' => $phid,
	'fields' => $field_map,
	'attachments' => $attachment_map,
	);
	}
	}

	return array(
	'data' => $data,
	'maps' => $method->getQueryMaps($query),
	'query' => array(
	// This may be `null` if we have not saved the query.
	'queryKey' => $saved_query->getQueryKey(),
	),
	'cursor' => array(
	'limit' => $pager->getPageSize(),
	'after' => $pager->getNextPageID(),
	'before' => $pager->getPrevPageID(),
	'order' => $request->getValue('order'),
	),
	);
	}

	public function getAllConduitFieldSpecifications() {
	$extensions = $this->getConduitFieldExtensions();
	$object = $this->newQuery()->newResultObject();

	$map = array();
	foreach ($extensions as $extension) {
	$specifications = $extension->getFieldSpecificationsForConduit($object);
	foreach ($specifications as $specification) {
	$key = $specification->getKey();
	if (isset($map[$key])) {
	throw new Exception(
	pht(
	'Two field specifications share the same key ("%s"). Each '.
	'specification must have a unique key.',
	$key));
	}
	$map[$key] = $specification;
	}
	}

	return $map;
	}

	private function getEngineExtensions() {
	$extensions = PhabricatorSearchEngineExtension::getAllEnabledExtensions();

	foreach ($extensions as $key => $extension) {
	$extension
	->setViewer($this->requireViewer())
	->setSearchEngine($this);
	}

	$object = $this->newResultObject();
	foreach ($extensions as $key => $extension) {
	if (!$extension->supportsObject($object)) {
	unset($extensions[$key]);
	}
	}

	return $extensions;
	}


	private function getConduitFieldExtensions() {
	$extensions = $this->getEngineExtensions();
	$object = $this->newResultObject();

	foreach ($extensions as $key => $extension) {
	if (!$extension->getFieldSpecificationsForConduit($object)) {
	unset($extensions[$key]);
	}
	}

	return $extensions;
	}

	private function setQueryOrderForConduit($query, ConduitAPIRequest $request) {
	$order = $request->getValue('order');
	if ($order === null) {
	return;
	}

	if (is_scalar($order)) {
	$query->setOrder($order);
	} else {
	$query->setOrderVector($order);
	}
	}

	private function setPagerLimitForConduit($pager, ConduitAPIRequest $request) {
	$limit = $request->getValue('limit');

	// If there's no limit specified and the query uses a weird huge page
	// size, just leave it at the default gigantic page size. Otherwise,
	// make sure it's between 1 and 100, inclusive.

	if ($limit === null) {
	if ($pager->getPageSize() >= 0xFFFF) {
	return;
	} else {
	$limit = 100;
	}
	}

	if ($limit > 100) {
	throw new Exception(
	pht(
	'Maximum page size for Conduit API method calls is 100, but '.
	'this call specified %s.',
	$limit));
	}

	if ($limit < 1) {
	throw new Exception(
	pht(
	'Minimum page size for API searches is 1, but this call '.
	'specified %s.',
	$limit));
	}

	$pager->setPageSize($limit);
	}

	private function setPagerOffsetsForConduit(
	$pager,
	ConduitAPIRequest $request) {
	$before_id = $request->getValue('before');
	if ($before_id !== null) {
	$pager->setBeforeID($before_id);
	}

	$after_id = $request->getValue('after');
	if ($after_id !== null) {
	$pager->setAfterID($after_id);
	}
	}

	protected function getObjectWireFieldsForConduit(
	$object,
	array $field_extensions,
	array $extension_data) {

	$fields = array();
	foreach ($field_extensions as $key => $extension) {
	$data = idx($extension_data, $key, array());
	$fields += $extension->getFieldValuesForConduit($object, $data);
	}

	return $fields;
	}

	public function getConduitSearchAttachments() {
	$extensions = $this->getEngineExtensions();
	$object = $this->newResultObject();

	$attachments = array();
	foreach ($extensions as $extension) {
	$extension_attachments = $extension->getSearchAttachments($object);
	foreach ($extension_attachments as $attachment) {
	$attachment_key = $attachment->getAttachmentKey();
	if (isset($attachments[$attachment_key])) {
	$other = $attachments[$attachment_key];
	throw new Exception(
	pht(
	'Two search engine attachments (of classes "%s" and "%s") '.
	'specify the same attachment key ("%s"); keys must be unique.',
	get_class($attachment),
	get_class($other),
	$attachment_key));
	}
	$attachments[$attachment_key] = $attachment;
	}
	}

	return $attachments;
	}

	final public function renderNewUserView() {
	$body = $this->getNewUserBody();

	if (!$body) {
	return null;
	}

	return $body;
	}

	protected function getNewUserHeader() {
	return null;
	}

	protected function getNewUserBody() {
	return null;
	}

	public function newUseResultsActions(PhabricatorSavedQuery $saved) {
	return array();
	}


	/* -( Export )------------------------------------------------------------- */


	public function canExport() {
	$fields = $this->newExportFields();
	return (bool)$fields;
	}

	final public function newExportFieldList() {
	$object = $this->newResultObject();

	$builtin_fields = array(
	id(new PhabricatorIDExportField())
	->setKey('id')
	->setLabel(pht('ID')),
	);

	if ($object->getConfigOption(LiskDAO::CONFIG_AUX_PHID)) {
	$builtin_fields[] = id(new PhabricatorPHIDExportField())
	->setKey('phid')
	->setLabel(pht('PHID'));
	}

	$fields = mpull($builtin_fields, null, 'getKey');

	$export_fields = $this->newExportFields();
	foreach ($export_fields as $export_field) {
	$key = $export_field->getKey();

	if (isset($fields[$key])) {
	throw new Exception(
	pht(
	'Search engine ("%s") defines an export field with a key ("%s") '.
	'that collides with another field. Each field must have a '.
	'unique key.',
	get_class($this),
	$key));
	}

	$fields[$key] = $export_field;
	}

	$extensions = $this->newExportExtensions();
	foreach ($extensions as $extension) {
	$extension_fields = $extension->newExportFields();
	foreach ($extension_fields as $extension_field) {
	$key = $extension_field->getKey();

	if (isset($fields[$key])) {
	throw new Exception(
	pht(
	'Export engine extension ("%s") defines an export field with '.
	'a key ("%s") that collides with another field. Each field '.
	'must have a unique key.',
	get_class($extension_field),
	$key));
	}

	$fields[$key] = $extension_field;
	}
	}

	return $fields;
	}

	final public function newExport(array $objects) {
	$object = $this->newResultObject();
	$has_phid = $object->getConfigOption(LiskDAO::CONFIG_AUX_PHID);

	$objects = array_values($objects);
	$n = count($objects);

	$maps = array();
	foreach ($objects as $object) {
	$map = array(
	'id' => $object->getID(),
	);

	if ($has_phid) {
	$map['phid'] = $object->getPHID();
	}

	$maps[] = $map;
	}

	$export_data = $this->newExportData($objects);
	$export_data = array_values($export_data);
	if (count($export_data) !== count($objects)) {
	throw new Exception(
	pht(
	'Search engine ("%s") exported the wrong number of objects, '.
	'expected %s but got %s.',
	get_class($this),
	phutil_count($objects),
	phutil_count($export_data)));
	}

	for ($ii = 0; $ii < $n; $ii++) {
	$maps[$ii] += $export_data[$ii];
	}

	$extensions = $this->newExportExtensions();
	foreach ($extensions as $extension) {
	$extension_data = $extension->newExportData($objects);
	$extension_data = array_values($extension_data);
	if (count($export_data) !== count($objects)) {
	throw new Exception(
	pht(
	'Export engine extension ("%s") exported the wrong number of '.
	'objects, expected %s but got %s.',
	get_class($extension),
	phutil_count($objects),
	phutil_count($export_data)));
	}

	for ($ii = 0; $ii < $n; $ii++) {
	$maps[$ii] += $extension_data[$ii];
	}
	}

	return $maps;
	}

	protected function newExportFields() {
	return array();
	}

	protected function newExportData(array $objects) {
	throw new PhutilMethodNotImplementedException();
	}

	private function newExportExtensions() {
	$object = $this->newResultObject();
	$viewer = $this->requireViewer();

	$extensions = PhabricatorExportEngineExtension::getAllExtensions();

	$supported = array();
	foreach ($extensions as $extension) {
	$extension = clone $extension;
	$extension->setViewer($viewer);

	if ($extension->supportsObject($object)) {
	$supported[] = $extension;
	}
	}

	return $supported;
	}

	}
	diff --git a/src/applications/search/storage/PhabricatorSavedQuery.php b/src/applications/search/storage/PhabricatorSavedQuery.php
	index 3f75027888..837f4fde42 100644
	--- a/src/applications/search/storage/PhabricatorSavedQuery.php
	+++ b/src/applications/search/storage/PhabricatorSavedQuery.php
	@@ -1,84 +1,91 @@
	<?php

	final class PhabricatorSavedQuery extends PhabricatorSearchDAO
	implements PhabricatorPolicyInterface {

	protected $parameters = array();
	protected $queryKey;
	protected $engineClassName;

	private $parameterMap = self::ATTACHABLE;

	protected function getConfiguration() {
	return array(
	self::CONFIG_SERIALIZATION => array(
	'parameters' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'engineClassName' => 'text255',
	'queryKey' => 'text12',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_queryKey' => array(
	'columns' => array('queryKey'),
	'unique' => true,
	),
	),
	) + parent::getConfiguration();
	}

	public function setParameter($key, $value) {
	$this->parameters[$key] = $value;
	return $this;
	}

	public function getParameter($key, $default = null) {
	return idx($this->parameters, $key, $default);
	}

	public function save() {
	if ($this->getEngineClassName() === null) {
	throw new Exception(pht('Engine class is null.'));
	}

	// Instantiate the engine to make sure it's valid.
	$this->newEngine();

	$serial = $this->getEngineClassName().serialize($this->parameters);
	$this->queryKey = PhabricatorHash::digestForIndex($serial);

	return parent::save();
	}

	public function newEngine() {
	return newv($this->getEngineClassName(), array());
	}

	public function attachParameterMap(array $map) {
	$this->parameterMap = $map;
	return $this;
	}

	public function getEvaluatedParameter($key) {
	return $this->assertAttachedKey($this->parameterMap, $key);
	}

	+ public function newCopy() {
	+ return id(new self())
	+ ->setParameters($this->getParameters())
	+ ->setQueryKey(null)
	+ ->setEngineClassName($this->getEngineClassName());
	+ }
	+

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


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

	public function getPolicy($capability) {
	return PhabricatorPolicies::POLICY_PUBLIC;
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return false;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Aug 15, 12:31 AM (1 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 196197
Default Alt Text: (90 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions