No OneTemporary
Actions

Size

96 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/owners/controller/PhabricatorOwnersListController.php b/src/applications/owners/controller/PhabricatorOwnersListController.php
	index 8a3a1e8ec3..ef7b01ebfb 100644
	--- a/src/applications/owners/controller/PhabricatorOwnersListController.php
	+++ b/src/applications/owners/controller/PhabricatorOwnersListController.php
	@@ -1,343 +1,343 @@
	<?php

	final class PhabricatorOwnersListController
	extends PhabricatorOwnersController {

	protected $view;

	public function willProcessRequest(array $data) {
	$this->view = idx($data, 'view', 'owned');
	$this->setSideNavFilter('view/'.$this->view);
	}

	public function processRequest() {

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

	$package = new PhabricatorOwnersPackage();
	$owner = new PhabricatorOwnersOwner();
	$path = new PhabricatorOwnersPath();

	$repository_phid = '';
	if ($request->getStr('repository') != '') {
	$repository_phid = id(new PhabricatorRepositoryQuery())
	->setViewer($user)
	->withCallsigns(array($request->getStr('repository')))
	->executeOne()
	->getPHID();
	}

	switch ($this->view) {
	case 'search':
	$packages = array();

	$conn_r = $package->establishConnection('r');

	$where = array('1 = 1');
	$join = array();
	$having = '';

	if ($request->getStr('name')) {
	$where[] = qsprintf(
	$conn_r,
	'p.name LIKE %~',
	$request->getStr('name'));
	}

	if ($repository_phid \|\| $request->getStr('path')) {

	$join[] = qsprintf(
	$conn_r,
	'JOIN %T path ON path.packageID = p.id',
	$path->getTableName());

	if ($repository_phid) {
	$where[] = qsprintf(
	$conn_r,
	'path.repositoryPHID = %s',
	$repository_phid);
	}

	if ($request->getStr('path')) {
	$where[] = qsprintf(
	$conn_r,
	'(path.path LIKE %~ AND NOT path.excluded) OR
	%s LIKE CONCAT(REPLACE(path.path, %s, %s), %s)',
	$request->getStr('path'),
	$request->getStr('path'),
	'_',
	'\_',
	'%');
	$having = 'HAVING MAX(path.excluded) = 0';
	}

	}

	if ($request->getArr('owner')) {
	$join[] = qsprintf(
	$conn_r,
	'JOIN %T o ON o.packageID = p.id',
	$owner->getTableName());
	$where[] = qsprintf(
	$conn_r,
	'o.userPHID IN (%Ls)',
	$request->getArr('owner'));
	}

	$data = queryfx_all(
	$conn_r,
	'SELECT p.* FROM %T p %Q WHERE %Q GROUP BY p.id %Q',
	$package->getTableName(),
	implode(' ', $join),
	'('.implode(') AND (', $where).')',
	$having);
	$packages = $package->loadAllFromArray($data);

	$header = pht('Search Results');
	$nodata = pht('No packages match your query.');
	break;
	case 'owned':
	$data = queryfx_all(
	$package->establishConnection('r'),
	'SELECT p.* FROM %T p JOIN %T o ON p.id = o.packageID
	WHERE o.userPHID = %s GROUP BY p.id',
	$package->getTableName(),
	$owner->getTableName(),
	$user->getPHID());
	$packages = $package->loadAllFromArray($data);

	$header = pht('Owned Packages');
	$nodata = pht('No owned packages');
	break;
	case 'projects':
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withMemberPHIDs(array($user->getPHID()))
	->withStatus(PhabricatorProjectQuery::STATUS_ANY)
	->execute();
	$owner_phids = mpull($projects, 'getPHID');
	if ($owner_phids) {
	$data = queryfx_all(
	$package->establishConnection('r'),
	'SELECT p.* FROM %T p JOIN %T o ON p.id = o.packageID
	WHERE o.userPHID IN (%Ls) GROUP BY p.id',
	$package->getTableName(),
	$owner->getTableName(),
	$owner_phids);
	} else {
	$data = array();
	}
	$packages = $package->loadAllFromArray($data);

	$header = pht('Project Packages');
	$nodata = pht('No owned packages');
	break;
	case 'all':
	$packages = $package->loadAll();

	$header = pht('All Packages');
	$nodata = pht('There are no defined packages.');
	break;
	}

	$content = $this->renderPackageTable(
	$packages,
	$header,
	$nodata);

	$filter = new AphrontListFilterView();

	$owner_phids = $request->getArr('owner');

	$callsigns = array('' => pht('(Any Repository)'));
	$repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($user)
	- ->setOrder(PhabricatorRepositoryQuery::ORDER_CALLSIGN)
	+ ->setOrder('callsign')
	->execute();
	foreach ($repositories as $repository) {
	$callsigns[$repository->getCallsign()] =
	$repository->getCallsign().': '.$repository->getName();
	}

	$form = id(new AphrontFormView())
	->setUser($user)
	->setAction('/owners/view/search/')
	->setMethod('GET')
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('name')
	->setLabel(pht('Name'))
	->setValue($request->getStr('name')))
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorProjectOrUserDatasource())
	->setLimit(1)
	->setName('owner')
	->setLabel(pht('Owner'))
	->setValue($owner_phids))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('repository')
	->setLabel(pht('Repository'))
	->setOptions($callsigns)
	->setValue($request->getStr('repository')))
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('path')
	->setLabel(pht('Path'))
	->setValue($request->getStr('path')))
	->appendChild(
	id(new AphrontFormSubmitControl())
	->setValue(pht('Search for Packages')));

	$filter->appendChild($form);
	$title = pht('Package Index');

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($header);
	$crumbs->setBorder(true);

	$nav = $this->buildSideNavView();
	$nav->appendChild($crumbs);
	$nav->appendChild($filter);
	$nav->appendChild($content);

	return $this->buildApplicationPage(
	$nav,
	array(
	'title' => pht('Package Index'),
	));
	}

	private function renderPackageTable(array $packages, $header, $nodata) {
	assert_instances_of($packages, 'PhabricatorOwnersPackage');

	if ($packages) {
	$package_ids = mpull($packages, 'getID');

	$owners = id(new PhabricatorOwnersOwner())->loadAllWhere(
	'packageID IN (%Ld)',
	$package_ids);

	$paths = id(new PhabricatorOwnersPath())->loadAllWhere(
	'packageID in (%Ld)',
	$package_ids);

	$phids = array();
	foreach ($owners as $owner) {
	$phids[$owner->getUserPHID()] = true;
	}
	$phids = array_keys($phids);
	$handles = $this->loadViewerHandles($phids);

	$repository_phids = array();
	foreach ($paths as $path) {
	$repository_phids[$path->getRepositoryPHID()] = true;
	}

	if ($repository_phids) {
	$repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getRequest()->getUser())
	->withPHIDs(array_keys($repository_phids))
	->execute();
	} else {
	$repositories = array();
	}

	$repositories = mpull($repositories, null, 'getPHID');
	$owners = mgroup($owners, 'getPackageID');
	$paths = mgroup($paths, 'getPackageID');
	} else {
	$handles = array();
	$repositories = array();
	$owners = array();
	$paths = array();
	}

	$rows = array();
	foreach ($packages as $package) {

	$pkg_owners = idx($owners, $package->getID(), array());
	foreach ($pkg_owners as $key => $owner) {
	$pkg_owners[$key] = $handles[$owner->getUserPHID()]->renderLink();
	if ($owner->getUserPHID() == $package->getPrimaryOwnerPHID()) {
	$pkg_owners[$key] = phutil_tag('strong', array(), $pkg_owners[$key]);
	}
	}
	$pkg_owners = phutil_implode_html(phutil_tag('br'), $pkg_owners);

	$pkg_paths = idx($paths, $package->getID(), array());
	foreach ($pkg_paths as $key => $path) {
	$repo = idx($repositories, $path->getRepositoryPHID());
	if ($repo) {
	$href = DiffusionRequest::generateDiffusionURI(
	array(
	'callsign' => $repo->getCallsign(),
	'branch' => $repo->getDefaultBranch(),
	'path' => $path->getPath(),
	'action' => 'browse',
	));
	$pkg_paths[$key] = hsprintf(
	'%s %s%s',
	($path->getExcluded() ? "\xE2\x80\x93" : '+'),
	phutil_tag('strong', array(), $repo->getName()),
	phutil_tag(
	'a',
	array(
	'href' => (string) $href,
	),
	$path->getPath()));
	} else {
	$pkg_paths[$key] = $path->getPath();
	}
	}
	$pkg_paths = phutil_implode_html(phutil_tag('br'), $pkg_paths);

	$rows[] = array(
	phutil_tag(
	'a',
	array(
	'href' => '/owners/package/'.$package->getID().'/',
	),
	$package->getName()),
	$pkg_owners,
	$pkg_paths,
	phutil_tag(
	'a',
	array(
	'href' => '/audit/?auditorPHIDs='.$package->getPHID(),
	),
	pht('Related Commits')),
	);
	}

	$table = new AphrontTableView($rows);
	$table->setHeaders(
	array(
	pht('Name'),
	pht('Owners'),
	pht('Paths'),
	pht('Related Commits'),
	));
	$table->setColumnClasses(
	array(
	'pri',
	'',
	'wide wrap',
	'narrow',
	));

	$panel = new PHUIObjectBoxView();
	$panel->setHeaderText($header);
	$panel->appendChild($table);

	return $panel;
	}

	protected function getExtraPackageViews(AphrontSideNavFilterView $view) {
	if ($this->view == 'search') {
	$view->addFilter('view/search', pht('Search Results'));
	}
	}
	}
	diff --git a/src/applications/ponder/query/PonderQuestionQuery.php b/src/applications/ponder/query/PonderQuestionQuery.php
	index bd387b62f9..9cb8c81d40 100644
	--- a/src/applications/ponder/query/PonderQuestionQuery.php
	+++ b/src/applications/ponder/query/PonderQuestionQuery.php
	@@ -1,202 +1,182 @@
	<?php

	final class PonderQuestionQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	- const ORDER_CREATED = 'order-created';
	- const ORDER_HOTTEST = 'order-hottest';
	-
	private $ids;
	private $phids;
	private $authorPHIDs;
	private $answererPHIDs;
	- private $order = self::ORDER_CREATED;

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';

	private $needAnswers;
	private $needViewerVotes;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withAuthorPHIDs(array $phids) {
	$this->authorPHIDs = $phids;
	return $this;
	}

	public function withStatus($status) {
	$this->status = $status;
	return $this;
	}

	public function withAnswererPHIDs(array $phids) {
	$this->answererPHIDs = $phids;
	return $this;
	}

	public function needAnswers($need_answers) {
	$this->needAnswers = $need_answers;
	return $this;
	}

	public function needViewerVotes($need_viewer_votes) {
	$this->needViewerVotes = $need_viewer_votes;
	return $this;
	}

	- public function setOrder($order) {
	- $this->order = $order;
	- return $this;
	- }
	-
	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->ids) {
	$where[] = qsprintf(
	$conn_r,
	'q.id IN (%Ld)',
	$this->ids);
	}

	if ($this->phids) {
	$where[] = qsprintf(
	$conn_r,
	'q.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->authorPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'q.authorPHID IN (%Ls)',
	$this->authorPHIDs);
	}

	if ($this->status) {
	switch ($this->status) {
	case self::STATUS_ANY:
	break;
	case self::STATUS_OPEN:
	$where[] = qsprintf(
	$conn_r,
	'q.status = %d',
	PonderQuestionStatus::STATUS_OPEN);
	break;
	case self::STATUS_CLOSED:
	$where[] = qsprintf(
	$conn_r,
	'q.status = %d',
	PonderQuestionStatus::STATUS_CLOSED);
	break;
	default:
	throw new Exception("Unknown status query '{$this->status}'!");
	}
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

	- private function buildOrderByClause(AphrontDatabaseConnection $conn_r) {
	- switch ($this->order) {
	- case self::ORDER_HOTTEST:
	- return qsprintf($conn_r, 'ORDER BY q.heat DESC, q.id DESC');
	- case self::ORDER_CREATED:
	- return qsprintf($conn_r, 'ORDER BY q.id DESC');
	- default:
	- throw new Exception("Unknown order '{$this->order}'!");
	- }
	- }
	-
	protected function loadPage() {
	$question = new PonderQuestion();
	$conn_r = $question->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT q.* FROM %T q %Q %Q %Q %Q',
	$question->getTableName(),
	$this->buildJoinsClause($conn_r),
	$this->buildWhereClause($conn_r),
	- $this->buildOrderByClause($conn_r),
	+ $this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	return $question->loadAllFromArray($data);
	}

	protected function willFilterPage(array $questions) {
	if ($this->needAnswers) {
	$aquery = id(new PonderAnswerQuery())
	->setViewer($this->getViewer())
	->setOrderVector(array('-id'))
	->withQuestionIDs(mpull($questions, 'getID'));

	if ($this->needViewerVotes) {
	$aquery->needViewerVotes($this->needViewerVotes);
	}

	$answers = $aquery->execute();
	$answers = mgroup($answers, 'getQuestionID');

	foreach ($questions as $question) {
	$question_answers = idx($answers, $question->getID(), array());
	$question->attachAnswers(mpull($question_answers, null, 'getPHID'));
	}
	}

	if ($this->needViewerVotes) {
	$viewer_phid = $this->getViewer()->getPHID();

	$etype = PonderQuestionHasVotingUserEdgeType::EDGECONST;
	$edges = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(mpull($questions, 'getPHID'))
	->withDestinationPHIDs(array($viewer_phid))
	->withEdgeTypes(array($etype))
	->needEdgeData(true)
	->execute();
	foreach ($questions as $question) {
	$user_edge = idx(
	$edges[$question->getPHID()][$etype],
	$viewer_phid,
	array());

	$question->attachUserVote($viewer_phid, idx($user_edge, 'data', 0));
	}
	}

	return $questions;
	}

	private function buildJoinsClause(AphrontDatabaseConnection $conn_r) {
	$joins = array();

	if ($this->answererPHIDs) {
	$answer_table = new PonderAnswer();
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T a ON a.questionID = q.id AND a.authorPHID IN (%Ls)',
	$answer_table->getTableName(),
	$this->answererPHIDs);
	}

	return implode(' ', $joins);
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorPonderApplication';
	}

	}
	diff --git a/src/applications/repository/query/PhabricatorRepositoryQuery.php b/src/applications/repository/query/PhabricatorRepositoryQuery.php
	index 05d5bba58a..385ad37eaf 100644
	--- a/src/applications/repository/query/PhabricatorRepositoryQuery.php
	+++ b/src/applications/repository/query/PhabricatorRepositoryQuery.php
	@@ -1,539 +1,531 @@
	<?php

	final class PhabricatorRepositoryQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $callsigns;
	private $types;
	private $uuids;
	private $nameContains;
	private $remoteURIs;
	private $anyProjectPHIDs;

	private $numericIdentifiers;
	private $callsignIdentifiers;
	private $phidIdentifiers;

	private $identifierMap;

	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_ALL = 'status-all';
	private $status = self::STATUS_ALL;

	- const ORDER_CREATED = 'order-created';
	- const ORDER_COMMITTED = 'order-committed';
	- const ORDER_CALLSIGN = 'order-callsign';
	- const ORDER_NAME = 'order-name';
	- const ORDER_SIZE = 'order-size';
	-
	const HOSTED_PHABRICATOR = 'hosted-phab';
	const HOSTED_REMOTE = 'hosted-remote';
	const HOSTED_ALL = 'hosted-all';
	private $hosted = self::HOSTED_ALL;

	private $needMostRecentCommits;
	private $needCommitCounts;
	private $needProjectPHIDs;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withCallsigns(array $callsigns) {
	$this->callsigns = $callsigns;
	return $this;
	}

	public function withIdentifiers(array $identifiers) {
	$ids = array(); $callsigns = array(); $phids = array();
	foreach ($identifiers as $identifier) {
	if (ctype_digit($identifier)) {
	$ids[$identifier] = $identifier;
	} else {
	$repository_type = PhabricatorRepositoryRepositoryPHIDType::TYPECONST;
	if (phid_get_type($identifier) === $repository_type) {
	$phids[$identifier] = $identifier;
	} else {
	$callsigns[$identifier] = $identifier;
	}
	}
	}

	$this->numericIdentifiers = $ids;
	$this->callsignIdentifiers = $callsigns;
	$this->phidIdentifiers = $phids;
	return $this;
	}

	public function withStatus($status) {
	$this->status = $status;
	return $this;
	}

	public function withHosted($hosted) {
	$this->hosted = $hosted;
	return $this;
	}

	public function withTypes(array $types) {
	$this->types = $types;
	return $this;
	}

	public function withUUIDs(array $uuids) {
	$this->uuids = $uuids;
	return $this;
	}

	public function withNameContains($contains) {
	$this->nameContains = $contains;
	return $this;
	}

	public function withRemoteURIs(array $uris) {
	$this->remoteURIs = $uris;
	return $this;
	}

	public function withAnyProjects(array $projects) {
	$this->anyProjectPHIDs = $projects;
	return $this;
	}

	public function needCommitCounts($need_counts) {
	$this->needCommitCounts = $need_counts;
	return $this;
	}

	public function needMostRecentCommits($need_commits) {
	$this->needMostRecentCommits = $need_commits;
	return $this;
	}

	public function needProjectPHIDs($need_phids) {
	$this->needProjectPHIDs = $need_phids;
	return $this;
	}

	- public function setOrder($order) {
	- switch ($order) {
	- case self::ORDER_CREATED:
	- $this->setOrderVector(array('id'));
	- break;
	- case self::ORDER_COMMITTED:
	- $this->setOrderVector(array('committed', 'id'));
	- break;
	- case self::ORDER_CALLSIGN:
	- $this->setOrderVector(array('callsign'));
	- break;
	- case self::ORDER_NAME:
	- $this->setOrderVector(array('name', 'id'));
	- break;
	- case self::ORDER_SIZE:
	- $this->setOrderVector(array('size', 'id'));
	- break;
	- default:
	- throw new Exception(pht('Unknown order "%s".', $order));
	- }
	- return $this;
	+ public function getBuiltinOrders() {
	+ return array(
	+ 'committed' => array(
	+ 'vector' => array('committed', 'id'),
	+ 'name' => pht('Most Recent Commit'),
	+ ),
	+ 'name' => array(
	+ 'vector' => array('name', 'id'),
	+ 'name' => pht('Name'),
	+ ),
	+ 'callsign' => array(
	+ 'vector' => array('callsign'),
	+ 'name' => pht('Callsign'),
	+ ),
	+ 'size' => array(
	+ 'vector' => array('size', 'id'),
	+ 'name' => pht('Size'),
	+ ),
	+ ) + parent::getBuiltinOrders();
	}

	public function getIdentifierMap() {
	if ($this->identifierMap === null) {
	throw new Exception(
	'You must execute() the query before accessing the identifier map.');
	}
	return $this->identifierMap;
	}

	protected function willExecute() {
	$this->identifierMap = array();
	}

	protected function loadPage() {
	$table = new PhabricatorRepository();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T r %Q %Q %Q %Q',
	$table->getTableName(),
	$this->buildJoinsClause($conn_r),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	$repositories = $table->loadAllFromArray($data);

	if ($this->needCommitCounts) {
	$sizes = ipull($data, 'size', 'id');
	foreach ($repositories as $id => $repository) {
	$repository->attachCommitCount(nonempty($sizes[$id], 0));
	}
	}

	if ($this->needMostRecentCommits) {
	$commit_ids = ipull($data, 'lastCommitID', 'id');
	$commit_ids = array_filter($commit_ids);
	if ($commit_ids) {
	$commits = id(new DiffusionCommitQuery())
	->setViewer($this->getViewer())
	->withIDs($commit_ids)
	->execute();
	} else {
	$commits = array();
	}
	foreach ($repositories as $id => $repository) {
	$commit = null;
	if (idx($commit_ids, $id)) {
	$commit = idx($commits, $commit_ids[$id]);
	}
	$repository->attachMostRecentCommit($commit);
	}
	}

	return $repositories;
	}

	protected function willFilterPage(array $repositories) {
	assert_instances_of($repositories, 'PhabricatorRepository');

	// TODO: Denormalize repository status into the PhabricatorRepository
	// table so we can do this filtering in the database.
	foreach ($repositories as $key => $repo) {
	$status = $this->status;
	switch ($status) {
	case self::STATUS_OPEN:
	if (!$repo->isTracked()) {
	unset($repositories[$key]);
	}
	break;
	case self::STATUS_CLOSED:
	if ($repo->isTracked()) {
	unset($repositories[$key]);
	}
	break;
	case self::STATUS_ALL:
	break;
	default:
	throw new Exception("Unknown status '{$status}'!");
	}

	// TODO: This should also be denormalized.
	$hosted = $this->hosted;
	switch ($hosted) {
	case self::HOSTED_PHABRICATOR:
	if (!$repo->isHosted()) {
	unset($repositories[$key]);
	}
	break;
	case self::HOSTED_REMOTE:
	if ($repo->isHosted()) {
	unset($repositories[$key]);
	}
	break;
	case self::HOSTED_ALL:
	break;
	default:
	throw new Exception("Uknown hosted failed '${hosted}'!");
	}
	}

	// TODO: Denormalize this, too.
	if ($this->remoteURIs) {
	$try_uris = $this->getNormalizedPaths();
	$try_uris = array_fuse($try_uris);
	foreach ($repositories as $key => $repository) {
	if (!isset($try_uris[$repository->getNormalizedPath()])) {
	unset($repositories[$key]);
	}
	}
	}

	// Build the identifierMap
	if ($this->numericIdentifiers) {
	foreach ($this->numericIdentifiers as $id) {
	if (isset($repositories[$id])) {
	$this->identifierMap[$id] = $repositories[$id];
	}
	}
	}

	if ($this->callsignIdentifiers) {
	$repository_callsigns = mpull($repositories, null, 'getCallsign');

	foreach ($this->callsignIdentifiers as $callsign) {
	if (isset($repository_callsigns[$callsign])) {
	$this->identifierMap[$callsign] = $repository_callsigns[$callsign];
	}
	}
	}

	if ($this->phidIdentifiers) {
	$repository_phids = mpull($repositories, null, 'getPHID');

	foreach ($this->phidIdentifiers as $phid) {
	if (isset($repository_phids[$phid])) {
	$this->identifierMap[$phid] = $repository_phids[$phid];
	}
	}
	}

	return $repositories;
	}

	protected function didFilterPage(array $repositories) {
	if ($this->needProjectPHIDs) {
	$type_project = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;

	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(mpull($repositories, 'getPHID'))
	->withEdgeTypes(array($type_project));
	$edge_query->execute();

	foreach ($repositories as $repository) {
	$project_phids = $edge_query->getDestinationPHIDs(
	array(
	$repository->getPHID(),
	));
	$repository->attachProjectPHIDs($project_phids);
	}
	}

	return $repositories;
	}

	protected function getPrimaryTableAlias() {
	return 'r';
	}

	public function getOrderableColumns() {
	return parent::getOrderableColumns() + array(
	'committed' => array(
	'table' => 's',
	'column' => 'epoch',
	'type' => 'int',
	'null' => 'tail',
	),
	'callsign' => array(
	'table' => 'r',
	'column' => 'callsign',
	'type' => 'string',
	'unique' => true,
	'reverse' => true,
	),
	'name' => array(
	'table' => 'r',
	'column' => 'name',
	'type' => 'string',
	'reverse' => true,
	),
	'size' => array(
	'table' => 's',
	'column' => 'size',
	'type' => 'int',
	'null' => 'tail',
	),
	);
	}

	protected function willExecuteCursorQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query) {
	$vector = $this->getOrderVector();

	if ($vector->containsKey('committed')) {
	$query->needMostRecentCommits(true);
	}

	if ($vector->containsKey('size')) {
	$query->needCommitCounts(true);
	}
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$repository = $this->loadCursorObject($cursor);

	$map = array(
	'id' => $repository->getID(),
	'callsign' => $repository->getCallsign(),
	'name' => $repository->getName(),
	);

	foreach ($keys as $key) {
	switch ($key) {
	case 'committed':
	$commit = $repository->getMostRecentCommit();
	if ($commit) {
	$map[$key] = $commit->getEpoch();
	} else {
	$map[$key] = null;
	}
	break;
	case 'size':
	$count = $repository->getCommitCount();
	if ($count) {
	$map[$key] = $count;
	} else {
	$map[$key] = null;
	}
	break;
	}
	}

	return $map;
	}

	private function buildJoinsClause(AphrontDatabaseConnection $conn_r) {
	$joins = array();

	$join_summary_table = $this->needCommitCounts \|\|
	$this->needMostRecentCommits;

	$vector = $this->getOrderVector();
	if ($vector->containsKey('committed') \|\|
	$vector->containsKey('size')) {
	$join_summary_table = true;
	}

	if ($join_summary_table) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T s ON r.id = s.repositoryID',
	PhabricatorRepository::TABLE_SUMMARY);
	}

	if ($this->anyProjectPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN edge e ON e.src = r.phid');
	}

	return implode(' ', $joins);
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->ids) {
	$where[] = qsprintf(
	$conn_r,
	'r.id IN (%Ld)',
	$this->ids);
	}

	if ($this->phids) {
	$where[] = qsprintf(
	$conn_r,
	'r.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->callsigns) {
	$where[] = qsprintf(
	$conn_r,
	'r.callsign IN (%Ls)',
	$this->callsigns);
	}

	if ($this->numericIdentifiers \|\|
	$this->callsignIdentifiers \|\|
	$this->phidIdentifiers) {
	$identifier_clause = array();

	if ($this->numericIdentifiers) {
	$identifier_clause[] = qsprintf(
	$conn_r,
	'r.id IN (%Ld)',
	$this->numericIdentifiers);
	}

	if ($this->callsignIdentifiers) {
	$identifier_clause[] = qsprintf(
	$conn_r,
	'r.callsign IN (%Ls)',
	$this->callsignIdentifiers);
	}

	if ($this->phidIdentifiers) {
	$identifier_clause[] = qsprintf(
	$conn_r,
	'r.phid IN (%Ls)',
	$this->phidIdentifiers);
	}

	$where = array('('.implode(' OR ', $identifier_clause).')');
	}

	if ($this->types) {
	$where[] = qsprintf(
	$conn_r,
	'r.versionControlSystem IN (%Ls)',
	$this->types);
	}

	if ($this->uuids) {
	$where[] = qsprintf(
	$conn_r,
	'r.uuid IN (%Ls)',
	$this->uuids);
	}

	if (strlen($this->nameContains)) {
	$where[] = qsprintf(
	$conn_r,
	'name LIKE %~',
	$this->nameContains);
	}

	if ($this->anyProjectPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'e.dst IN (%Ls)',
	$this->anyProjectPHIDs);
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}



	public function getQueryApplicationClass() {
	return 'PhabricatorDiffusionApplication';
	}

	private function getNormalizedPaths() {
	$normalized_uris = array();

	// Since we don't know which type of repository this URI is in the general
	// case, just generate all the normalizations. We could refine this in some
	// cases: if the query specifies VCS types, or the URI is a git-style URI
	// or an `svn+ssh` URI, we could deduce how to normalize it. However, this
	// would be more complicated and it's not clear if it matters in practice.

	foreach ($this->remoteURIs as $uri) {
	$normalized_uris[] = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_GIT,
	$uri);
	$normalized_uris[] = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_SVN,
	$uri);
	$normalized_uris[] = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_MERCURIAL,
	$uri);
	}

	return array_unique(mpull($normalized_uris, 'getNormalizedPath'));
	}

	}
	diff --git a/src/applications/repository/query/PhabricatorRepositorySearchEngine.php b/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	index 103f07c87f..1b8009fec5 100644
	--- a/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	+++ b/src/applications/repository/query/PhabricatorRepositorySearchEngine.php
	@@ -1,298 +1,273 @@
	<?php

	final class PhabricatorRepositorySearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Repositories');
	}

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

	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$saved = new PhabricatorSavedQuery();

	$saved->setParameter('callsigns', $request->getStrList('callsigns'));
	$saved->setParameter('status', $request->getStr('status'));
	$saved->setParameter('order', $request->getStr('order'));
	$saved->setParameter('hosted', $request->getStr('hosted'));
	$saved->setParameter('types', $request->getArr('types'));
	$saved->setParameter('name', $request->getStr('name'));
	$saved->setParameter('anyProjectPHIDs', $request->getArr('anyProjects'));

	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new PhabricatorRepositoryQuery())
	+ ->setDefaultBuiltinOrder()
	->needProjectPHIDs(true)
	->needCommitCounts(true)
	->needMostRecentCommits(true);

	$callsigns = $saved->getParameter('callsigns');
	if ($callsigns) {
	$query->withCallsigns($callsigns);
	}

	$status = $saved->getParameter('status');
	$status = idx($this->getStatusValues(), $status);
	if ($status) {
	$query->withStatus($status);
	}

	$order = $saved->getParameter('order');
	- $order = idx($this->getOrderValues(), $order);
	if ($order) {
	$query->setOrder($order);
	- } else {
	- $query->setOrder(head($this->getOrderValues()));
	}

	$hosted = $saved->getParameter('hosted');
	$hosted = idx($this->getHostedValues(), $hosted);
	if ($hosted) {
	$query->withHosted($hosted);
	}

	$types = $saved->getParameter('types');
	if ($types) {
	$query->withTypes($types);
	}

	$name = $saved->getParameter('name');
	if (strlen($name)) {
	$query->withNameContains($name);
	}

	$any_project_phids = $saved->getParameter('anyProjectPHIDs');
	if ($any_project_phids) {
	$query->withAnyProjects($any_project_phids);
	}

	return $query;
	}

	public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved_query) {

	$callsigns = $saved_query->getParameter('callsigns', array());
	$types = $saved_query->getParameter('types', array());
	$types = array_fuse($types);
	$name = $saved_query->getParameter('name');
	$any_project_phids = $saved_query->getParameter('anyProjectPHIDs', array());

	$form
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('callsigns')
	->setLabel(pht('Callsigns'))
	->setValue(implode(', ', $callsigns)))
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('name')
	->setLabel(pht('Name Contains'))
	->setValue($name))
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorProjectDatasource())
	->setName('anyProjects')
	->setLabel(pht('In Any Project'))
	->setValue($any_project_phids))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('status')
	->setLabel(pht('Status'))
	->setValue($saved_query->getParameter('status'))
	->setOptions($this->getStatusOptions()))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('hosted')
	->setLabel(pht('Hosted'))
	->setValue($saved_query->getParameter('hosted'))
	->setOptions($this->getHostedOptions()));

	$type_control = id(new AphrontFormCheckboxControl())
	->setLabel(pht('Types'));

	$all_types = PhabricatorRepositoryType::getAllRepositoryTypes();
	foreach ($all_types as $key => $name) {
	$type_control->addCheckbox(
	'types[]',
	$key,
	$name,
	isset($types[$key]));
	}
	+ $form->appendChild($type_control);

	- $form
	- ->appendChild($type_control)
	- ->appendChild(
	- id(new AphrontFormSelectControl())
	- ->setName('order')
	- ->setLabel(pht('Order'))
	- ->setValue($saved_query->getParameter('order'))
	- ->setOptions($this->getOrderOptions()));
	+ $this->appendOrderFieldsToForm(
	+ $form,
	+ $saved_query,
	+ new PhabricatorRepositoryQuery());
	}

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

	protected function getBuiltinQueryNames() {
	$names = array(
	'active' => pht('Active Repositories'),
	'all' => pht('All Repositories'),
	);

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {

	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	switch ($query_key) {
	case 'active':
	return $query->setParameter('status', 'open');
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	private function getStatusOptions() {
	return array(
	'' => pht('Active and Inactive Repositories'),
	'open' => pht('Active Repositories'),
	'closed' => pht('Inactive Repositories'),
	);
	}

	private function getStatusValues() {
	return array(
	'' => PhabricatorRepositoryQuery::STATUS_ALL,
	'open' => PhabricatorRepositoryQuery::STATUS_OPEN,
	'closed' => PhabricatorRepositoryQuery::STATUS_CLOSED,
	);
	}

	- private function getOrderOptions() {
	- return array(
	- 'committed' => pht('Most Recent Commit'),
	- 'name' => pht('Name'),
	- 'callsign' => pht('Callsign'),
	- 'created' => pht('Date Created'),
	- 'size' => pht('Commit Count'),
	- );
	- }
	-
	- private function getOrderValues() {
	- return array(
	- 'committed' => PhabricatorRepositoryQuery::ORDER_COMMITTED,
	- 'name' => PhabricatorRepositoryQuery::ORDER_NAME,
	- 'callsign' => PhabricatorRepositoryQuery::ORDER_CALLSIGN,
	- 'created' => PhabricatorRepositoryQuery::ORDER_CREATED,
	- 'size' => PhabricatorRepositoryQuery::ORDER_SIZE,
	- );
	- }
	-
	private function getHostedOptions() {
	return array(
	'' => pht('Hosted and Remote Repositories'),
	'phabricator' => pht('Hosted Repositories'),
	'remote' => pht('Remote Repositories'),
	);
	}

	private function getHostedValues() {
	return array(
	'' => PhabricatorRepositoryQuery::HOSTED_ALL,
	'phabricator' => PhabricatorRepositoryQuery::HOSTED_PHABRICATOR,
	'remote' => PhabricatorRepositoryQuery::HOSTED_REMOTE,
	);
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $repositories,
	PhabricatorSavedQuery $query) {
	return array_mergev(mpull($repositories, 'getProjectPHIDs'));
	}

	protected function renderResultList(
	array $repositories,
	PhabricatorSavedQuery $query,
	array $handles) {
	assert_instances_of($repositories, 'PhabricatorRepository');

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

	$list = new PHUIObjectItemListView();
	foreach ($repositories as $repository) {
	$id = $repository->getID();

	$item = id(new PHUIObjectItemView())
	->setUser($viewer)
	->setHeader($repository->getName())
	->setObjectName('r'.$repository->getCallsign())
	->setHref($this->getApplicationURI($repository->getCallsign().'/'));

	$commit = $repository->getMostRecentCommit();
	if ($commit) {
	$commit_link = DiffusionView::linkCommit(
	$repository,
	$commit->getCommitIdentifier(),
	$commit->getSummary());
	$item->setSubhead($commit_link);
	$item->setEpoch($commit->getEpoch());
	}

	$item->addIcon(
	'none',
	PhabricatorRepositoryType::getNameForRepositoryType(
	$repository->getVersionControlSystem()));

	$size = $repository->getCommitCount();
	if ($size) {
	$history_uri = DiffusionRequest::generateDiffusionURI(
	array(
	'callsign' => $repository->getCallsign(),
	'action' => 'history',
	));

	$item->addAttribute(
	phutil_tag(
	'a',
	array(
	'href' => $history_uri,
	),
	pht('%s Commit(s)', new PhutilNumber($size))));
	} else {
	$item->addAttribute(pht('No Commits'));
	}

	$project_handles = array_select_keys(
	$handles,
	$repository->getProjectPHIDs());
	if ($project_handles) {
	$item->addAttribute(
	id(new PHUIHandleTagListView())
	->setSlim(true)
	->setHandles($project_handles));
	}

	if (!$repository->isTracked()) {
	$item->setDisabled(true);
	$item->addIcon('disable-grey', pht('Inactive'));
	}

	$list->addItem($item);
	}

	return $list;
	}

	}
	diff --git a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	index 109bec8533..dec842f1f8 100644
	--- a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	+++ b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	@@ -1,884 +1,903 @@
	<?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 {

	private $application;
	private $viewer;
	private $errors = array();
	private $customFields = false;
	private $request;
	private $context;

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

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

	protected function requireViewer() {
	if (!$this->viewer) {
	throw new Exception('Call setViewer() before using an engine!');
	}
	return $this->viewer;
	}

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

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

	public function canUseInPanelContext() {
	return true;
	}

	public function saveQuery(PhabricatorSavedQuery $query) {
	$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
	*/
	abstract public function buildSavedQueryFromRequest(
	AphrontRequest $request);

	/**
	* Executes the saved query.
	*
	* @param PhabricatorSavedQuery The saved query to operate on.
	* @return The result of the query.
	*/
	abstract public function buildQueryFromSavedQuery(
	PhabricatorSavedQuery $saved);

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

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


	/**
	* 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');

	return $this;
	}

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

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

	$builtin = $this->getBuiltinQueries($viewer);
	$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 = msort($named_queries, 'getSortKey');

	return $named_queries + $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;
	}


	/* -( 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() {
	$engines = id(new PhutilSymbolLoader())
	->setAncestorClass(__CLASS__)
	->loadObjects();

	return $engines;
	}


	/**
	* 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($this->requireViewer()->getPHID())
	->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("'{$query_key}' is not a builtin!");
	}
	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("Builtin '{$query_key}' is not supported!");
	}


	/* -( 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.
	*
	* @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 = PhabricatorPHIDConstants::PHID_TYPE_USER;
	foreach ($list as $item) {
	$type = phid_get_type($item);
	if ($type == $user_type) {
	$phids[] = $item;
	} else if (isset($allow_types[$type])) {
	$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 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 readDateFromRequest(
	AphrontRequest $request,
	$key) {

	return id(new AphrontFormDateControl())
	->setUser($this->requireViewer())
	->setName($key)
	->setAllowNull(true)
	->readValueFromRequest($request);
	}

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


	+/* -( Result Ordering )---------------------------------------------------- */
	+
	+ protected function appendOrderFieldsToForm(
	+ AphrontFormView $form,
	+ PhabricatorSavedQuery $saved,
	+ PhabricatorCursorPagedPolicyAwareQuery $query) {
	+
	+ $orders = $query->getBuiltinOrders();
	+ $orders = ipull($orders, 'name');
	+
	+ $form->appendControl(
	+ id(new AphrontFormSelectControl())
	+ ->setLabel(pht('Order'))
	+ ->setName('order')
	+ ->setOptions($orders)
	+ ->setValue($saved->getParameter('order')));
	+ }
	+
	/* -( Paging and Executing Queries )--------------------------------------- */


	public function getPageSize(PhabricatorSavedQuery $saved) {
	return $saved->getParameter('limit', 100);
	}


	public function shouldUseOffsetPaging() {
	return false;
	}


	public function newPagerForSavedQuery(PhabricatorSavedQuery $saved) {
	if ($this->shouldUseOffsetPaging()) {
	$pager = new AphrontPagerView();
	} 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);
	}

	return $objects;
	}


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

	protected function renderResultList(
	array $objects,
	PhabricatorSavedQuery $query,
	array $handles) {
	throw new Exception(pht('Not supported here yet!'));
	}


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


	/**
	* Retrieve an object to use to define custom fields for this search.
	*
	* To integrate with custom fields, subclasses should override this method
	* and return an instance of the application object which implements
	* @{interface:PhabricatorCustomFieldInterface}.
	*
	* @return PhabricatorCustomFieldInterface\|null Object with custom fields.
	* @task appsearch
	*/
	public function getCustomFieldObject() {
	return null;
	}


	/**
	* Get the custom fields for this search.
	*
	* @return PhabricatorCustomFieldList\|null Custom fields, if this search
	* supports custom fields.
	* @task appsearch
	*/
	public function getCustomFieldList() {
	if ($this->customFields === false) {
	$object = $this->getCustomFieldObject();
	if ($object) {
	$fields = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	$fields->setViewer($this->requireViewer());
	} else {
	$fields = null;
	}
	$this->customFields = $fields;
	}
	return $this->customFields;
	}


	/**
	* Moves data from the request into a saved query.
	*
	* @param AphrontRequest Request to read.
	* @param PhabricatorSavedQuery Query to write to.
	* @return void
	* @task appsearch
	*/
	protected function readCustomFieldsFromRequest(
	AphrontRequest $request,
	PhabricatorSavedQuery $saved) {

	$list = $this->getCustomFieldList();
	if (!$list) {
	return;
	}

	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);
	$value = $field->readApplicationSearchValueFromRequest(
	$this,
	$request);
	$saved->setParameter($key, $value);
	}
	}


	/**
	* Applies data from a saved query to an executable query.
	*
	* @param PhabricatorCursorPagedPolicyAwareQuery Query to constrain.
	* @param PhabricatorSavedQuery Saved query to read.
	* @return void
	*/
	protected function applyCustomFieldsToQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query,
	PhabricatorSavedQuery $saved) {

	$list = $this->getCustomFieldList();
	if (!$list) {
	return;
	}

	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);
	$value = $field->applyApplicationSearchConstraintToQuery(
	$this,
	$query,
	$saved->getParameter($key));
	}
	}

	protected function applyOrderByToQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query,
	array $standard_values,
	$order) {

	if (substr($order, 0, 7) === 'custom:') {
	$list = $this->getCustomFieldList();
	if (!$list) {
	$query->setOrderBy(head($standard_values));
	return;
	}

	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);

	if ($key === $order) {
	$index = $field->buildOrderIndex();

	if ($index === null) {
	$query->setOrderBy(head($standard_values));
	return;
	}

	$query->withApplicationSearchOrder(
	$field,
	$index,
	false);
	break;
	}
	}
	} else {
	$order = idx($standard_values, $order);
	if ($order) {
	$query->setOrderBy($order);
	} else {
	$query->setOrderBy(head($standard_values));
	}
	}
	}


	protected function getCustomFieldOrderOptions() {
	$list = $this->getCustomFieldList();
	if (!$list) {
	return;
	}

	$custom_order = array();
	foreach ($list->getFields() as $field) {
	if ($field->shouldAppearInApplicationSearch()) {
	if ($field->buildOrderIndex() !== null) {
	$key = $this->getKeyForCustomField($field);
	$custom_order[$key] = $field->getFieldName();
	}
	}
	}

	return $custom_order;
	}

	/**
	* Get a unique key identifying a field.
	*
	* @param PhabricatorCustomField Field to identify.
	* @return string Unique identifier, suitable for use as an input name.
	*/
	public function getKeyForCustomField(PhabricatorCustomField $field) {
	return 'custom:'.$field->getFieldIndex();
	}


	/**
	* Add inputs to an application search form so the user can query on custom
	* fields.
	*
	* @param AphrontFormView Form to update.
	* @param PhabricatorSavedQuery Values to prefill.
	* @return void
	*/
	protected function appendCustomFieldsToForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved) {

	$list = $this->getCustomFieldList();
	if (!$list) {
	return;
	}

	$phids = array();
	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);
	$value = $saved->getParameter($key);
	$phids[$key] = $field->getRequiredHandlePHIDsForApplicationSearch($value);
	}
	$all_phids = array_mergev($phids);

	$handles = array();
	if ($all_phids) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireViewer())
	->withPHIDs($all_phids)
	->execute();
	}

	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);
	$value = $saved->getParameter($key);
	$field->appendToApplicationSearchForm(
	$this,
	$form,
	$value,
	array_select_keys($handles, $phids[$key]));
	}
	}

	}
	diff --git a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	index b98648529b..068229c9ef 100644
	--- a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	+++ b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	@@ -1,975 +1,1112 @@
	<?php

	/**
	* A query class which uses cursor-based paging. This paging is much more
	* performant than offset-based paging in the presence of policy filtering.
	*
	* @task appsearch Integration with ApplicationSearch
	* @task paging Paging
	* @task order Result Ordering
	*/
	abstract class PhabricatorCursorPagedPolicyAwareQuery
	extends PhabricatorPolicyAwareQuery {

	private $afterID;
	private $beforeID;
	private $applicationSearchConstraints = array();
	protected $applicationSearchOrders = array();
	private $internalPaging;
	private $orderVector;
	+ private $builtinOrder;

	protected function getPagingValue($result) {
	if (!is_object($result)) {
	// This interface can't be typehinted and PHP gets really angry if we
	// call a method on a non-object, so add an explicit check here.
	throw new Exception(pht('Expected object, got "%s"!', gettype($result)));
	}
	return $result->getID();
	}

	protected function nextPage(array $page) {
	// See getPagingViewer() for a description of this flag.
	$this->internalPaging = true;

	if ($this->beforeID) {
	$this->beforeID = $this->getPagingValue(last($page));
	} else {
	$this->afterID = $this->getPagingValue(last($page));
	}
	}

	final public function setAfterID($object_id) {
	$this->afterID = $object_id;
	return $this;
	}

	final protected function getAfterID() {
	return $this->afterID;
	}

	final public function setBeforeID($object_id) {
	$this->beforeID = $object_id;
	return $this;
	}

	final protected function getBeforeID() {
	return $this->beforeID;
	}


	/**
	* Get the viewer for making cursor paging queries.
	*
	* NOTE: You should ONLY use this viewer to load cursor objects while
	* building paging queries.
	*
	* Cursor paging can happen in two ways. First, the user can request a page
	* like `/stuff/?after=33`, which explicitly causes paging. Otherwise, we
	* can fall back to implicit paging if we filter some results out of a
	* result list because the user can't see them and need to go fetch some more
	* results to generate a large enough result list.
	*
	* In the first case, want to use the viewer's policies to load the object.
	* This prevents an attacker from figuring out information about an object
	* they can't see by executing queries like `/stuff/?after=33&order=name`,
	* which would otherwise give them a hint about the name of the object.
	* Generally, if a user can't see an object, they can't use it to page.
	*
	* In the second case, we need to load the object whether the user can see
	* it or not, because we need to examine new results. For example, if a user
	* loads `/stuff/` and we run a query for the first 100 items that they can
	* see, but the first 100 rows in the database aren't visible, we need to
	* be able to issue a query for the next 100 results. If we can't load the
	* cursor object, we'll fail or issue the same query over and over again.
	* So, generally, internal paging must bypass policy controls.
	*
	* This method returns the appropriate viewer, based on the context in which
	* the paging is occuring.
	*
	* @return PhabricatorUser Viewer for executing paging queries.
	*/
	final protected function getPagingViewer() {
	if ($this->internalPaging) {
	return PhabricatorUser::getOmnipotentUser();
	} else {
	return $this->getViewer();
	}
	}

	final protected function buildLimitClause(AphrontDatabaseConnection $conn_r) {
	if ($this->getRawResultLimit()) {
	return qsprintf($conn_r, 'LIMIT %d', $this->getRawResultLimit());
	} else {
	return '';
	}
	}

	final protected function didLoadResults(array $results) {
	if ($this->beforeID) {
	$results = array_reverse($results, $preserve_keys = true);
	}
	return $results;
	}

	final public function executeWithCursorPager(AphrontCursorPagerView $pager) {
	$this->setLimit($pager->getPageSize() + 1);

	if ($pager->getAfterID()) {
	$this->setAfterID($pager->getAfterID());
	} else if ($pager->getBeforeID()) {
	$this->setBeforeID($pager->getBeforeID());
	}

	$results = $this->execute();

	$sliced_results = $pager->sliceResults($results);

	if ($sliced_results) {
	if ($pager->getBeforeID() \|\| (count($results) > $pager->getPageSize())) {
	$pager->setNextPageID($this->getPagingValue(last($sliced_results)));
	}

	if ($pager->getAfterID() \|\|
	($pager->getBeforeID() && (count($results) > $pager->getPageSize()))) {
	$pager->setPrevPageID($this->getPagingValue(head($sliced_results)));
	}
	}

	return $sliced_results;
	}


	/**
	* Return the alias this query uses to identify the primary table.
	*
	* Some automatic query constructions may need to be qualified with a table
	* alias if the query performs joins which make column names ambiguous. If
	* this is the case, return the alias for the primary table the query
	* uses; generally the object table which has `id` and `phid` columns.
	*
	* @return string Alias for the primary table.
	*/
	protected function getPrimaryTableAlias() {
	return null;
	}

	protected function newResultObject() {
	return null;
	}


	/* -( Paging )------------------------------------------------------------- */


	protected function buildPagingClause(AphrontDatabaseConnection $conn) {
	$orderable = $this->getOrderableColumns();
	$vector = $this->getOrderVector();

	if ($this->beforeID !== null) {
	$cursor = $this->beforeID;
	$reversed = true;
	} else if ($this->afterID !== null) {
	$cursor = $this->afterID;
	$reversed = false;
	} else {
	// No paging is being applied to this query so we do not need to
	// construct a paging clause.
	return '';
	}

	$keys = array();
	foreach ($vector as $order) {
	$keys[] = $order->getOrderKey();
	}

	$value_map = $this->getPagingValueMap($cursor, $keys);

	$columns = array();
	foreach ($vector as $order) {
	$key = $order->getOrderKey();

	if (!array_key_exists($key, $value_map)) {
	throw new Exception(
	pht(
	'Query "%s" failed to return a value from getPagingValueMap() '.
	'for column "%s".',
	get_class($this),
	$key));
	}

	$column = $orderable[$key];
	$column['value'] = $value_map[$key];

	$columns[] = $column;
	}

	return $this->buildPagingClauseFromMultipleColumns(
	$conn,
	$columns,
	array(
	'reversed' => $reversed,
	));
	}

	protected function getPagingValueMap($cursor, array $keys) {
	// TODO: This is a hack to make this work with existing classes for now.
	return array(
	'id' => $cursor,
	);
	}

	protected function loadCursorObject($cursor) {
	$query = newv(get_class($this), array())
	->setViewer($this->getPagingViewer())
	->withIDs(array((int)$cursor));

	$this->willExecuteCursorQuery($query);

	$object = $query->executeOne();
	if (!$object) {
	throw new Exception(
	pht(
	'Cursor "%s" does not identify a valid object.',
	$cursor));
	}

	return $object;
	}

	protected function willExecuteCursorQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query) {
	return;
	}


	/**
	* Simplifies the task of constructing a paging clause across multiple
	* columns. In the general case, this looks like:
	*
	* A > a OR (A = a AND B > b) OR (A = a AND B = b AND C > c)
	*
	* To build a clause, specify the name, type, and value of each column
	* to include:
	*
	* $this->buildPagingClauseFromMultipleColumns(
	* $conn_r,
	* array(
	* array(
	* 'table' => 't',
	* 'column' => 'title',
	* 'type' => 'string',
	* 'value' => $cursor->getTitle(),
	* 'reverse' => true,
	* ),
	* array(
	* 'table' => 't',
	* 'column' => 'id',
	* 'type' => 'int',
	* 'value' => $cursor->getID(),
	* ),
	* ),
	* array(
	* 'reversed' => $is_reversed,
	* ));
	*
	* This method will then return a composable clause for inclusion in WHERE.
	*
	* @param AphrontDatabaseConnection Connection query will execute on.
	* @param list<map> Column description dictionaries.
	* @param map Additional constuction options.
	* @return string Query clause.
	*/
	final protected function buildPagingClauseFromMultipleColumns(
	AphrontDatabaseConnection $conn,
	array $columns,
	array $options) {

	foreach ($columns as $column) {
	PhutilTypeSpec::checkMap(
	$column,
	array(
	'table' => 'optional string\|null',
	'column' => 'string',
	'value' => 'wild',
	'type' => 'string',
	'reverse' => 'optional bool',
	'unique' => 'optional bool',
	'null' => 'optional string\|null',
	));
	}

	PhutilTypeSpec::checkMap(
	$options,
	array(
	'reversed' => 'optional bool',
	));

	$is_query_reversed = idx($options, 'reversed', false);

	$clauses = array();
	$accumulated = array();
	$last_key = last_key($columns);
	foreach ($columns as $key => $column) {
	$type = $column['type'];

	$null = idx($column, 'null');
	if ($column['value'] === null) {
	if ($null) {
	$value = null;
	} else {
	throw new Exception(
	pht(
	'Column "%s" has null value, but does not specify a null '.
	'behavior.',
	$key));
	}
	} else {
	switch ($type) {
	case 'int':
	$value = qsprintf($conn, '%d', $column['value']);
	break;
	case 'float':
	$value = qsprintf($conn, '%f', $column['value']);
	break;
	case 'string':
	$value = qsprintf($conn, '%s', $column['value']);
	break;
	default:
	throw new Exception(
	pht(
	'Column "%s" has unknown column type "%s".',
	$column['column'],
	$type));
	}
	}

	$is_column_reversed = idx($column, 'reverse', false);
	$reverse = ($is_query_reversed xor $is_column_reversed);

	$clause = $accumulated;

	$table_name = idx($column, 'table');
	$column_name = $column['column'];
	if ($table_name !== null) {
	$field = qsprintf($conn, '%T.%T', $table_name, $column_name);
	} else {
	$field = qsprintf($conn, '%T', $column_name);
	}

	$parts = array();
	if ($null) {
	$can_page_if_null = ($null === 'head');
	$can_page_if_nonnull = ($null === 'tail');

	if ($reverse) {
	$can_page_if_null = !$can_page_if_null;
	$can_page_if_nonnull = !$can_page_if_nonnull;
	}

	$subclause = null;
	if ($can_page_if_null && $value === null) {
	$parts[] = qsprintf(
	$conn,
	'(%Q IS NOT NULL)',
	$field);
	} else if ($can_page_if_nonnull && $value !== null) {
	$parts[] = qsprintf(
	$conn,
	'(%Q IS NULL)',
	$field);
	}
	}

	if ($value !== null) {
	$parts[] = qsprintf(
	$conn,
	'%Q %Q %Q',
	$field,
	$reverse ? '>' : '<',
	$value);
	}

	if ($parts) {
	if (count($parts) > 1) {
	$clause[] = '('.implode(') OR (', $parts).')';
	} else {
	$clause[] = head($parts);
	}
	}

	if ($clause) {
	if (count($clause) > 1) {
	$clauses[] = '('.implode(') AND (', $clause).')';
	} else {
	$clauses[] = head($clause);
	}
	}

	if ($value === null) {
	$accumulated[] = qsprintf(
	$conn,
	'%Q IS NULL',
	$field);
	} else {
	$accumulated[] = qsprintf(
	$conn,
	'%Q = %Q',
	$field,
	$value);
	}
	}

	return '('.implode(') OR (', $clauses).')';
	}


	/* -( Result Ordering )---------------------------------------------------- */


	/**
	+ * Select a result ordering.
	+ *
	+ * This is a high-level method which selects an ordering from a predefined
	+ * list of builtin orders, as provided by @{method:getBuiltinOrders}. These
	+ * options are user-facing and not exhaustive, but are generally convenient
	+ * and meaningful.
	+ *
	+ * You can also use @{method:setOrderVector} to specify a low-level ordering
	+ * across individual orderable columns. This offers greater control but is
	+ * also more involved.
	+ *
	+ * @param string Key of a builtin order supported by this query.
	+ * @return this
	+ * @task order
	+ */
	+ public function setOrder($order) {
	+ $orders = $this->getBuiltinOrders();
	+
	+ if (empty($orders[$order])) {
	+ throw new Exception(
	+ pht(
	+ 'Query "%s" does not support a builtin order "%s". Supported orders '.
	+ 'are: %s.',
	+ get_class($this),
	+ $order,
	+ implode(', ', array_keys($orders))));
	+ }
	+
	+ $this->builtinOrder = $order;
	+ $this->orderVector = null;
	+
	+ return $this;
	+ }
	+
	+
	+ /**
	+ * Select the default builtin result ordering.
	+ *
	+ * This sets the result order to the default order among the builtin result
	+ * orders (see @{method:getBuiltinOrders}). This is often the same as the
	+ * query's builtin default order vector, but some objects have different
	+ * default vectors (which are internally-facing) and builtin orders (which
	+ * are user-facing).
	+ *
	+ * For example, repositories sort by ID internally (which is efficient and
	+ * consistent), but sort by most recent commit as a default builtin (which
	+ * better aligns with user expectations).
	+ *
	+ * @return this
	+ */
	+ public function setDefaultBuiltinOrder() {
	+ return $this->setOrder(head_key($this->getBuiltinOrders()));
	+ }
	+
	+
	+ /**
	+ * Get builtin orders for this class.
	+ *
	+ * In application UIs, we want to be able to present users with a small
	+ * selection of meaningful order options (like "Order by Title") rather than
	+ * an exhaustive set of column ordering options.
	+ *
	+ * Meaningful user-facing orders are often really orders across multiple
	+ * columns: for example, a "title" ordering is usually implemented as a
	+ * "title, id" ordering under the hood.
	+ *
	+ * Builtin orders provide a mapping from convenient, understandable
	+ * user-facing orders to implementations.
	+ *
	+ * A builtin order should provide these keys:
	+ *
	+ * - `vector` (`list<string>`): The actual order vector to use.
	+ * - `name` (`string`): Human-readable order name.
	+ *
	+ * @return map<string, wild> Map from builtin order keys to specification.
	+ * @task order
	+ */
	+ public function getBuiltinOrders() {
	+ $orders = array(
	+ 'newest' => array(
	+ 'vector' => array('id'),
	+ 'name' => pht('Creation (Newest First)'),
	+ 'aliases' => array('created'),
	+ ),
	+ 'oldest' => array(
	+ 'vector' => array('-id'),
	+ 'name' => pht('Creation (Oldest First)'),
	+ ),
	+ );
	+
	+ $object = $this->newResultObject();
	+ if ($object instanceof PhabricatorCustomFieldInterface) {
	+ $list = PhabricatorCustomField::getObjectFields(
	+ $object,
	+ PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	+ foreach ($list->getFields() as $field) {
	+ $index = $field->buildOrderIndex();
	+ if (!$index) {
	+ continue;
	+ }
	+
	+ $key = $field->getFieldKey();
	+ $digest = $field->getFieldIndex();
	+
	+ $full_key = 'custom:'.$key;
	+ $orders[$full_key] = array(
	+ 'vector' => array($full_key, 'id'),
	+ 'name' => $field->getFieldName(),
	+ );
	+ }
	+ }
	+
	+ return $orders;
	+ }
	+
	+
	+ /**
	+ * Set a low-level column ordering.
	+ *
	+ * This is a low-level method which offers granular control over column
	+ * ordering. In most cases, applications can more easily use
	+ * @{method:setOrder} to choose a high-level builtin order.
	+ *
	+ * To set an order vector, specify a list of order keys as provided by
	+ * @{method:getOrderableColumns}.
	+ *
	+ * @param PhabricatorQueryOrderVector\|list<string> List of order keys.
	+ * @return this
	* @task order
	*/
	public function setOrderVector($vector) {
	$vector = PhabricatorQueryOrderVector::newFromVector($vector);

	$orderable = $this->getOrderableColumns();

	// Make sure that all the components identify valid columns.
	$unique = array();
	foreach ($vector as $order) {
	$key = $order->getOrderKey();
	if (empty($orderable[$key])) {
	$valid = implode(', ', array_keys($orderable));
	throw new Exception(
	pht(
	'This query ("%s") does not support sorting by order key "%s". '.
	'Supported orders are: %s.',
	get_class($this),
	$key,
	$valid));
	}

	$unique[$key] = idx($orderable[$key], 'unique', false);
	}

	// Make sure that the last column is unique so that this is a strong
	// ordering which can be used for paging.
	$last = last($unique);
	if ($last !== true) {
	throw new Exception(
	pht(
	'Order vector "%s" is invalid: the last column in an order must '.
	'be a column with unique values, but "%s" is not unique.',
	$vector->getAsString(),
	last_key($unique)));
	}

	// Make sure that other columns are not unique; an ordering like "id, name"
	// does not make sense because only "id" can ever have an effect.
	array_pop($unique);
	foreach ($unique as $key => $is_unique) {
	if ($is_unique) {
	throw new Exception(
	pht(
	'Order vector "%s" is invalid: only the last column in an order '.
	'may be unique, but "%s" is a unique column and not the last '.
	'column in the order.',
	$vector->getAsString(),
	$key));
	}
	}

	$this->orderVector = $vector;
	return $this;
	}


	/**
	+ * Get the effective order vector.
	+ *
	+ * @return PhabricatorQueryOrderVector Effective vector.
	* @task order
	*/
	protected function getOrderVector() {
	if (!$this->orderVector) {
	- $vector = $this->getDefaultOrderVector();
	+ if ($this->builtinOrder !== null) {
	+ $builtin_order = idx($this->getBuiltinOrders(), $this->builtinOrder);
	+ $vector = $builtin_order['vector'];
	+ } else {
	+ $vector = $this->getDefaultOrderVector();
	+ }
	$vector = PhabricatorQueryOrderVector::newFromVector($vector);

	// We call setOrderVector() here to apply checks to the default vector.
	// This catches any errors in the implementation.
	$this->setOrderVector($vector);
	}

	return $this->orderVector;
	}


	/**
	* @task order
	*/
	protected function getDefaultOrderVector() {
	return array('id');
	}


	/**
	* @task order
	*/
	public function getOrderableColumns() {
	$columns = array(
	'id' => array(
	'table' => $this->getPrimaryTableAlias(),
	'column' => 'id',
	'reverse' => false,
	'type' => 'int',
	'unique' => true,
	),
	);

	$object = $this->newResultObject();
	if ($object instanceof PhabricatorCustomFieldInterface) {
	$list = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	foreach ($list->getFields() as $field) {
	$index = $field->buildOrderIndex();
	if (!$index) {
	continue;
	}

	$key = $field->getFieldKey();
	$digest = $field->getFieldIndex();

	$full_key = 'custom:'.$key;
	$columns[$full_key] = array(
	'table' => 'appsearch_order_'.$digest,
	'column' => 'indexValue',
	'type' => $index->getIndexValueType(),
	'null' => 'tail',
	);
	}
	}

	return $columns;
	}


	/**
	* @task order
	*/
	final protected function buildOrderClause(AphrontDatabaseConnection $conn) {
	$orderable = $this->getOrderableColumns();
	$vector = $this->getOrderVector();

	$parts = array();
	foreach ($vector as $order) {
	$part = $orderable[$order->getOrderKey()];
	if ($order->getIsReversed()) {
	$part['reverse'] = !idx($part, 'reverse', false);
	}
	$parts[] = $part;
	}

	return $this->formatOrderClause($conn, $parts);
	}


	/**
	* @task order
	*/
	protected function formatOrderClause(
	AphrontDatabaseConnection $conn,
	array $parts) {

	$is_query_reversed = false;
	if ($this->getBeforeID()) {
	$is_query_reversed = !$is_query_reversed;
	}

	$sql = array();
	foreach ($parts as $key => $part) {
	$is_column_reversed = !empty($part['reverse']);

	$descending = true;
	if ($is_query_reversed) {
	$descending = !$descending;
	}

	if ($is_column_reversed) {
	$descending = !$descending;
	}

	$table = idx($part, 'table');
	$column = $part['column'];

	if ($table !== null) {
	$field = qsprintf($conn, '%T.%T', $table, $column);
	} else {
	$field = qsprintf($conn, '%T', $column);
	}

	$null = idx($part, 'null');
	if ($null) {
	switch ($null) {
	case 'head':
	$null_field = qsprintf($conn, '(%Q IS NULL)', $field);
	break;
	case 'tail':
	$null_field = qsprintf($conn, '(%Q IS NOT NULL)', $field);
	break;
	default:
	throw new Exception(
	pht(
	'NULL value "%s" is invalid. Valid values are "head" and '.
	'"tail".',
	$null));
	}

	if ($descending) {
	$sql[] = qsprintf($conn, '%Q DESC', $null_field);
	} else {
	$sql[] = qsprintf($conn, '%Q ASC', $null_field);
	}
	}

	if ($descending) {
	$sql[] = qsprintf($conn, '%Q DESC', $field);
	} else {
	$sql[] = qsprintf($conn, '%Q ASC', $field);
	}
	}

	return qsprintf($conn, 'ORDER BY %Q', implode(', ', $sql));
	}


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


	/**
	* Constrain the query with an ApplicationSearch index, requiring field values
	* contain at least one of the values in a set.
	*
	* This constraint can build the most common types of queries, like:
	*
	* - Find users with shirt sizes "X" or "XL".
	* - Find shoes with size "13".
	*
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param string\|list<string> One or more values to filter by.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchContainsConstraint(
	PhabricatorCustomFieldIndexStorage $index,
	$value) {

	$this->applicationSearchConstraints[] = array(
	'type' => $index->getIndexValueType(),
	'cond' => '=',
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'value' => $value,
	);

	return $this;
	}


	/**
	* Constrain the query with an ApplicationSearch index, requiring values
	* exist in a given range.
	*
	* This constraint is useful for expressing date ranges:
	*
	* - Find events between July 1st and July 7th.
	*
	* The ends of the range are inclusive, so a `$min` of `3` and a `$max` of
	* `5` will match fields with values `3`, `4`, or `5`. Providing `null` for
	* either end of the range will leave that end of the constraint open.
	*
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param int\|null Minimum permissible value, inclusive.
	* @param int\|null Maximum permissible value, inclusive.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchRangeConstraint(
	PhabricatorCustomFieldIndexStorage $index,
	$min,
	$max) {

	$index_type = $index->getIndexValueType();
	if ($index_type != 'int') {
	throw new Exception(
	pht(
	'Attempting to apply a range constraint to a field with index type '.
	'"%s", expected type "%s".',
	$index_type,
	'int'));
	}

	$this->applicationSearchConstraints[] = array(
	'type' => $index->getIndexValueType(),
	'cond' => 'range',
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'value' => array($min, $max),
	);

	return $this;
	}


	/**
	* Order the results by an ApplicationSearch index.
	*
	* @param PhabricatorCustomField Field to which the index belongs.
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param bool True to sort ascending.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchOrder(
	PhabricatorCustomField $field,
	PhabricatorCustomFieldIndexStorage $index,
	$ascending) {

	$this->applicationSearchOrders[] = array(
	'key' => $field->getFieldKey(),
	'type' => $index->getIndexValueType(),
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'ascending' => $ascending,
	);

	return $this;
	}


	/**
	* Get the name of the query's primary object PHID column, for constructing
	* JOIN clauses. Normally (and by default) this is just `"phid"`, but it may
	* be something more exotic.
	*
	* See @{method:getPrimaryTableAlias} if the column needs to be qualified with
	* a table alias.
	*
	* @return string Column name.
	* @task appsearch
	*/
	protected function getApplicationSearchObjectPHIDColumn() {
	if ($this->getPrimaryTableAlias()) {
	$prefix = $this->getPrimaryTableAlias().'.';
	} else {
	$prefix = '';
	}

	return $prefix.'phid';
	}


	/**
	* Determine if the JOINs built by ApplicationSearch might cause each primary
	* object to return multiple result rows. Generally, this means the query
	* needs an extra GROUP BY clause.
	*
	* @return bool True if the query may return multiple rows for each object.
	* @task appsearch
	*/
	protected function getApplicationSearchMayJoinMultipleRows() {
	foreach ($this->applicationSearchConstraints as $constraint) {
	$type = $constraint['type'];
	$value = $constraint['value'];
	$cond = $constraint['cond'];

	switch ($cond) {
	case '=':
	switch ($type) {
	case 'string':
	case 'int':
	if (count((array)$value) > 1) {
	return true;
	}
	break;
	default:
	throw new Exception(pht('Unknown index type "%s"!', $type));
	}
	break;
	case 'range':
	// NOTE: It's possible to write a custom field where multiple rows
	// match a range constraint, but we don't currently ship any in the
	// upstream and I can't immediately come up with cases where this
	// would make sense.
	break;
	default:
	throw new Exception(pht('Unknown constraint condition "%s"!', $cond));
	}
	}

	return false;
	}


	/**
	* Construct a GROUP BY clause appropriate for ApplicationSearch constraints.
	*
	* @param AphrontDatabaseConnection Connection executing the query.
	* @return string Group clause.
	* @task appsearch
	*/
	protected function buildApplicationSearchGroupClause(
	AphrontDatabaseConnection $conn_r) {

	if ($this->getApplicationSearchMayJoinMultipleRows()) {
	return qsprintf(
	$conn_r,
	'GROUP BY %Q',
	$this->getApplicationSearchObjectPHIDColumn());
	} else {
	return '';
	}
	}


	/**
	* Construct a JOIN clause appropriate for applying ApplicationSearch
	* constraints.
	*
	* @param AphrontDatabaseConnection Connection executing the query.
	* @return string Join clause.
	* @task appsearch
	*/
	protected function buildApplicationSearchJoinClause(
	AphrontDatabaseConnection $conn_r) {

	$joins = array();
	foreach ($this->applicationSearchConstraints as $key => $constraint) {
	$table = $constraint['table'];
	$alias = 'appsearch_'.$key;
	$index = $constraint['index'];
	$cond = $constraint['cond'];
	$phid_column = $this->getApplicationSearchObjectPHIDColumn();
	switch ($cond) {
	case '=':
	$type = $constraint['type'];
	switch ($type) {
	case 'string':
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue IN (%Ls)',
	$alias,
	(array)$constraint['value']);
	break;
	case 'int':
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue IN (%Ld)',
	$alias,
	(array)$constraint['value']);
	break;
	default:
	throw new Exception(pht('Unknown index type "%s"!', $type));
	}

	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s
	AND (%Q)',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index,
	$constraint_clause);
	break;
	case 'range':
	list($min, $max) = $constraint['value'];
	if (($min === null) && ($max === null)) {
	// If there's no actual range constraint, just move on.
	break;
	}

	if ($min === null) {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue <= %d',
	$alias,
	$max);
	} else if ($max === null) {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue >= %d',
	$alias,
	$min);
	} else {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue BETWEEN %d AND %d',
	$alias,
	$min,
	$max);
	}

	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s
	AND (%Q)',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index,
	$constraint_clause);
	break;
	default:
	throw new Exception(pht('Unknown constraint condition "%s"!', $cond));
	}
	}

	foreach ($this->applicationSearchOrders as $key => $order) {
	$table = $order['table'];
	$index = $order['index'];
	$alias = 'appsearch_order_'.$index;
	$phid_column = $this->getApplicationSearchObjectPHIDColumn();

	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index);
	}

	return implode(' ', $joins);
	}

	protected function getPagingValueMapForCustomFields(
	PhabricatorCustomFieldInterface $object) {

	// We have to get the current field values on the cursor object.
	$fields = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	$fields->setViewer($this->getViewer());
	$fields->readFieldsFromStorage($object);

	$map = array();
	foreach ($fields->getFields() as $field) {
	$map['custom:'.$field->getFieldKey()] = $field->getValueForStorage();
	}

	return $map;
	}

	protected function isCustomFieldOrderKey($key) {
	$prefix = 'custom:';
	return !strncmp($key, $prefix, strlen($prefix));
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Apr 30, 5:38 AM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 108569
Default Alt Text: (96 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions