No OneTemporary
Actions

Size

150 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/query/ManiphestTaskQuery.php b/src/applications/maniphest/query/ManiphestTaskQuery.php
	index 7afbd4e0fb..c3528f219c 100644
	--- a/src/applications/maniphest/query/ManiphestTaskQuery.php
	+++ b/src/applications/maniphest/query/ManiphestTaskQuery.php
	@@ -1,973 +1,999 @@
	<?php

	/**
	* Query tasks by specific criteria. This class uses the higher-performance
	* but less-general Maniphest indexes to satisfy queries.
	*/
	final class ManiphestTaskQuery extends PhabricatorCursorPagedPolicyAwareQuery {

	private $taskIDs = array();
	private $taskPHIDs = array();
	private $authorPHIDs = array();
	private $ownerPHIDs = array();
	private $includeUnowned = null;
	private $projectPHIDs = array();
	private $xprojectPHIDs = array();
	private $subscriberPHIDs = array();
	private $anyProjectPHIDs = array();
	private $anyUserProjectPHIDs = array();
	private $includeNoProject = null;
	private $dateCreatedAfter;
	private $dateCreatedBefore;
	private $dateModifiedAfter;
	private $dateModifiedBefore;

	private $fullTextSearch = '';

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_RESOLVED = 'status-resolved';
	const STATUS_WONTFIX = 'status-wontfix';
	const STATUS_INVALID = 'status-invalid';
	const STATUS_SPITE = 'status-spite';
	const STATUS_DUPLICATE = 'status-duplicate';

	private $statuses;
	private $priorities;

	private $groupBy = 'group-none';
	const GROUP_NONE = 'group-none';
	const GROUP_PRIORITY = 'group-priority';
	const GROUP_OWNER = 'group-owner';
	const GROUP_STATUS = 'group-status';
	const GROUP_PROJECT = 'group-project';

	private $orderBy = 'order-modified';
	const ORDER_PRIORITY = 'order-priority';
	const ORDER_CREATED = 'order-created';
	const ORDER_MODIFIED = 'order-modified';
	const ORDER_TITLE = 'order-title';

	const DEFAULT_PAGE_SIZE = 1000;

	public function withAuthors(array $authors) {
	$this->authorPHIDs = $authors;
	return $this;
	}

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

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

	public function withOwners(array $owners) {
	$this->includeUnowned = false;
	foreach ($owners as $k => $phid) {
	if ($phid == ManiphestTaskOwner::OWNER_UP_FOR_GRABS \|\| $phid === null) {
	$this->includeUnowned = true;
	unset($owners[$k]);
	break;
	}
	}
	$this->ownerPHIDs = $owners;
	return $this;
	}

	public function withAllProjects(array $projects) {
	$this->includeNoProject = false;
	foreach ($projects as $k => $phid) {
	if ($phid == ManiphestTaskOwner::PROJECT_NO_PROJECT) {
	$this->includeNoProject = true;
	unset($projects[$k]);
	}
	}
	$this->projectPHIDs = $projects;
	return $this;
	}

	/**
	* Add an additional "all projects" constraint to existing filters.
	*
	* This is used by boards to supplement queries.
	*
	* @param list<phid> List of project PHIDs to add to any existing constraint.
	* @return this
	*/
	public function addWithAllProjects(array $projects) {
	if ($this->projectPHIDs === null) {
	$this->projectPHIDs = array();
	}

	return $this->withAllProjects(array_merge($this->projectPHIDs, $projects));
	}

	public function withoutProjects(array $projects) {
	$this->xprojectPHIDs = $projects;
	return $this;
	}

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

	public function withStatuses(array $statuses) {
	$this->statuses = $statuses;
	return $this;
	}

	public function withPriorities(array $priorities) {
	$this->priorities = $priorities;
	return $this;
	}

	public function withSubscribers(array $subscribers) {
	$this->subscriberPHIDs = $subscribers;
	return $this;
	}

	public function withFullTextSearch($fulltext_search) {
	$this->fullTextSearch = $fulltext_search;
	return $this;
	}

	public function setGroupBy($group) {
	$this->groupBy = $group;
	return $this;
	}

	public function setOrderBy($order) {
	$this->orderBy = $order;
	return $this;
	}

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

	public function withAnyUserProjects(array $users) {
	$this->anyUserProjectPHIDs = $users;
	return $this;
	}

	public function withDateCreatedBefore($date_created_before) {
	$this->dateCreatedBefore = $date_created_before;
	return $this;
	}

	public function withDateCreatedAfter($date_created_after) {
	$this->dateCreatedAfter = $date_created_after;
	return $this;
	}

	public function withDateModifiedBefore($date_modified_before) {
	$this->dateModifiedBefore = $date_modified_before;
	return $this;
	}

	public function withDateModifiedAfter($date_modified_after) {
	$this->dateModifiedAfter = $date_modified_after;
	return $this;
	}

	public function loadPage() {
	// TODO: (T603) It is possible for a user to find the PHID of a project
	// they can't see, then query for tasks in that project and deduce the
	// identity of unknown/invisible projects. Before we allow the user to
	// execute a project-based PHID query, we should verify that they
	// can see the project.

	$task_dao = new ManiphestTask();
	$conn = $task_dao->establishConnection('r');

	$where = array();
	$where[] = $this->buildTaskIDsWhereClause($conn);
	$where[] = $this->buildTaskPHIDsWhereClause($conn);
	$where[] = $this->buildStatusWhereClause($conn);
	$where[] = $this->buildStatusesWhereClause($conn);
	$where[] = $this->buildPrioritiesWhereClause($conn);
	$where[] = $this->buildAuthorWhereClause($conn);
	$where[] = $this->buildOwnerWhereClause($conn);
	$where[] = $this->buildSubscriberWhereClause($conn);
	$where[] = $this->buildProjectWhereClause($conn);
	$where[] = $this->buildAnyProjectWhereClause($conn);
	$where[] = $this->buildAnyUserProjectWhereClause($conn);
	$where[] = $this->buildXProjectWhereClause($conn);
	$where[] = $this->buildFullTextWhereClause($conn);

	if ($this->dateCreatedAfter) {
	$where[] = qsprintf(
	$conn,
	'task.dateCreated >= %d',
	$this->dateCreatedAfter);
	}

	if ($this->dateCreatedBefore) {
	$where[] = qsprintf(
	$conn,
	'task.dateCreated <= %d',
	$this->dateCreatedBefore);
	}

	if ($this->dateModifiedAfter) {
	$where[] = qsprintf(
	$conn,
	'task.dateModified >= %d',
	$this->dateModifiedAfter);
	}

	if ($this->dateModifiedBefore) {
	$where[] = qsprintf(
	$conn,
	'task.dateModified <= %d',
	$this->dateModifiedBefore);
	}

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

	$where = $this->formatWhereClause($where);

	$having = '';
	$count = '';

	if (count($this->projectPHIDs) > 1) {
	// We want to treat the query as an intersection query, not a union
	// query. We sum the project count and require it be the same as the
	// number of projects we're searching for.

	$count = ', COUNT(project.dst) projectCount';
	$having = qsprintf(
	$conn,
	'HAVING projectCount = %d',
	count($this->projectPHIDs));
	}

	$order = $this->buildCustomOrderClause($conn);

	// TODO: Clean up this nonstandardness.
	if (!$this->getLimit()) {
	$this->setLimit(self::DEFAULT_PAGE_SIZE);
	}

	$group_column = '';
	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$group_column = qsprintf(
	$conn,
	', projectGroupName.indexedObjectPHID projectGroupPHID');
	break;
	}

	$rows = queryfx_all(
	$conn,
	'SELECT task.* %Q %Q FROM %T task %Q %Q %Q %Q %Q %Q',
	$count,
	$group_column,
	$task_dao->getTableName(),
	$this->buildJoinsClause($conn),
	$where,
	$this->buildGroupClause($conn),
	$having,
	$order,
	$this->buildLimitClause($conn));

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$data = ipull($rows, null, 'id');
	break;
	default:
	$data = $rows;
	break;
	}

	$tasks = $task_dao->loadAllFromArray($data);

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$results = array();
	foreach ($rows as $row) {
	$task = clone $tasks[$row['id']];
	$task->attachGroupByProjectPHID($row['projectGroupPHID']);
	$results[] = $task;
	}
	$tasks = $results;
	break;
	}

	return $tasks;
	}

	protected function willFilterPage(array $tasks) {
	if ($this->groupBy == self::GROUP_PROJECT) {
	// We should only return project groups which the user can actually see.
	$project_phids = mpull($tasks, 'getGroupByProjectPHID');
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($project_phids)
	->execute();
	$projects = mpull($projects, null, 'getPHID');

	foreach ($tasks as $key => $task) {
	if (!$task->getGroupByProjectPHID()) {
	// This task is either not in any projects, or only in projects
	// which we're ignoring because they're being queried for explicitly.
	continue;
	}

	if (empty($projects[$task->getGroupByProjectPHID()])) {
	unset($tasks[$key]);
	}
	}
	}

	return $tasks;
	}

	protected function didFilterPage(array $tasks) {
	// TODO: Eventually, we should make this optional and introduce a
	// needProjectPHIDs() method, but for now there's a lot of code which
	// assumes the data is always populated.

	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(mpull($tasks, 'getPHID'))
	->withEdgeTypes(
	array(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	));
	$edge_query->execute();

	foreach ($tasks as $task) {
	$phids = $edge_query->getDestinationPHIDs(array($task->getPHID()));
	$task->attachProjectPHIDs($phids);
	}

	return $tasks;
	}

	private function buildTaskIDsWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->taskIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'id in (%Ld)',
	$this->taskIDs);
	}

	private function buildTaskPHIDsWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->taskPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'phid in (%Ls)',
	$this->taskPHIDs);
	}

	private function buildStatusWhereClause(AphrontDatabaseConnection $conn) {
	static $map = array(
	self::STATUS_RESOLVED => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
	self::STATUS_WONTFIX => ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
	self::STATUS_INVALID => ManiphestTaskStatus::STATUS_CLOSED_INVALID,
	self::STATUS_SPITE => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
	self::STATUS_DUPLICATE => ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE,
	);

	switch ($this->status) {
	case self::STATUS_ANY:
	return null;
	case self::STATUS_OPEN:
	return qsprintf(
	$conn,
	'status IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	case self::STATUS_CLOSED:
	return qsprintf(
	$conn,
	'status IN (%Ls)',
	ManiphestTaskStatus::getClosedStatusConstants());
	default:
	$constant = idx($map, $this->status);
	if (!$constant) {
	throw new Exception("Unknown status query '{$this->status}'!");
	}
	return qsprintf(
	$conn,
	'status = %s',
	$constant);
	}
	}

	private function buildStatusesWhereClause(AphrontDatabaseConnection $conn) {
	if ($this->statuses) {
	return qsprintf(
	$conn,
	'status IN (%Ls)',
	$this->statuses);
	}
	return null;
	}

	private function buildPrioritiesWhereClause(AphrontDatabaseConnection $conn) {
	if ($this->priorities) {
	return qsprintf(
	$conn,
	'priority IN (%Ld)',
	$this->priorities);
	}

	return null;
	}

	private function buildAuthorWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->authorPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'authorPHID in (%Ls)',
	$this->authorPHIDs);
	}

	private function buildOwnerWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->ownerPHIDs) {
	if ($this->includeUnowned === null) {
	return null;
	} else if ($this->includeUnowned) {
	return qsprintf(
	$conn,
	'ownerPHID IS NULL');
	} else {
	return qsprintf(
	$conn,
	'ownerPHID IS NOT NULL');
	}
	}

	if ($this->includeUnowned) {
	return qsprintf(
	$conn,
	'ownerPHID IN (%Ls) OR ownerPHID IS NULL',
	$this->ownerPHIDs);
	} else {
	return qsprintf(
	$conn,
	'ownerPHID IN (%Ls)',
	$this->ownerPHIDs);
	}
	}

	private function buildFullTextWhereClause(AphrontDatabaseConnection $conn) {
	if (!strlen($this->fullTextSearch)) {
	return null;
	}

	// In doing a fulltext search, we first find all the PHIDs that match the
	// fulltext search, and then use that to limit the rest of the search
	$fulltext_query = id(new PhabricatorSavedQuery())
	->setEngineClassName('PhabricatorSearchApplicationSearchEngine')
	->setParameter('query', $this->fullTextSearch);

	// NOTE: Setting this to something larger than 2^53 will raise errors in
	// ElasticSearch, and billions of results won't fit in memory anyway.
	$fulltext_query->setParameter('limit', 100000);
	$fulltext_query->setParameter('type', ManiphestTaskPHIDType::TYPECONST);

	$engine = PhabricatorSearchEngineSelector::newSelector()->newEngine();
	$fulltext_results = $engine->executeSearch($fulltext_query);

	if (empty($fulltext_results)) {
	$fulltext_results = array(null);
	}

	return qsprintf(
	$conn,
	'phid IN (%Ls)',
	$fulltext_results);
	}

	private function buildSubscriberWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->subscriberPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'subscriber.subscriberPHID IN (%Ls)',
	$this->subscriberPHIDs);
	}

	private function buildProjectWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->projectPHIDs && !$this->includeNoProject) {
	return null;
	}

	$parts = array();
	if ($this->projectPHIDs) {
	$parts[] = qsprintf(
	$conn,
	'project.dst in (%Ls)',
	$this->projectPHIDs);
	}
	if ($this->includeNoProject) {
	$parts[] = qsprintf(
	$conn,
	'project.dst IS NULL');
	}

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

	private function buildAnyProjectWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->anyProjectPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'anyproject.dst IN (%Ls)',
	$this->anyProjectPHIDs);
	}

	private function buildAnyUserProjectWhereClause(
	AphrontDatabaseConnection $conn) {
	if (!$this->anyUserProjectPHIDs) {
	return null;
	}

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withMemberPHIDs($this->anyUserProjectPHIDs)
	->execute();
	$any_user_project_phids = mpull($projects, 'getPHID');
	if (!$any_user_project_phids) {
	throw new PhabricatorEmptyQueryException();
	}

	return qsprintf(
	$conn,
	'anyproject.dst IN (%Ls)',
	$any_user_project_phids);
	}

	private function buildXProjectWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->xprojectPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'xproject.dst IS NULL');
	}

	private function buildCustomOrderClause(AphrontDatabaseConnection $conn) {
	+ $reverse = ($this->getBeforeID() xor $this->getReversePaging());
	+
	$order = array();

	switch ($this->groupBy) {
	case self::GROUP_NONE:
	break;
	case self::GROUP_PRIORITY:
	$order[] = 'priority';
	break;
	case self::GROUP_OWNER:
	$order[] = 'ownerOrdering';
	break;
	case self::GROUP_STATUS:
	$order[] = 'status';
	break;
	case self::GROUP_PROJECT:
	$order[] = '<group.project>';
	break;
	default:
	throw new Exception("Unknown group query '{$this->groupBy}'!");
	}

	- switch ($this->orderBy) {
	- case self::ORDER_PRIORITY:
	- $order[] = 'priority';
	- $order[] = 'subpriority';
	- $order[] = 'dateModified';
	- break;
	- case self::ORDER_CREATED:
	- $order[] = 'id';
	- break;
	- case self::ORDER_MODIFIED:
	- $order[] = 'dateModified';
	- break;
	- case self::ORDER_TITLE:
	- $order[] = 'title';
	- break;
	- default:
	- throw new Exception("Unknown order query '{$this->orderBy}'!");
	+ $app_order = $this->buildApplicationSearchOrders($conn, $reverse);
	+
	+ if (!$app_order) {
	+ switch ($this->orderBy) {
	+ case self::ORDER_PRIORITY:
	+ $order[] = 'priority';
	+ $order[] = 'subpriority';
	+ $order[] = 'dateModified';
	+ break;
	+ case self::ORDER_CREATED:
	+ $order[] = 'id';
	+ break;
	+ case self::ORDER_MODIFIED:
	+ $order[] = 'dateModified';
	+ break;
	+ case self::ORDER_TITLE:
	+ $order[] = 'title';
	+ break;
	+ default:
	+ throw new Exception("Unknown order query '{$this->orderBy}'!");
	+ }
	}

	$order = array_unique($order);

	- if (empty($order)) {
	+ if (empty($order) && empty($app_order)) {
	return null;
	}

	- $reverse = ($this->getBeforeID() xor $this->getReversePaging());
	-
	foreach ($order as $k => $column) {
	switch ($column) {
	case 'subpriority':
	case 'ownerOrdering':
	case 'title':
	if ($reverse) {
	$order[$k] = "task.{$column} DESC";
	} else {
	$order[$k] = "task.{$column} ASC";
	}
	break;
	case '<group.project>':
	// Put "No Project" at the end of the list.
	if ($reverse) {
	$order[$k] =
	'projectGroupName.indexedObjectName IS NULL DESC, '.
	'projectGroupName.indexedObjectName DESC';
	} else {
	$order[$k] =
	'projectGroupName.indexedObjectName IS NULL ASC, '.
	'projectGroupName.indexedObjectName ASC';
	}
	break;
	default:
	if ($reverse) {
	$order[$k] = "task.{$column} ASC";
	} else {
	$order[$k] = "task.{$column} DESC";
	}
	break;
	}
	}

	+ if ($app_order) {
	+ foreach ($app_order as $order_by) {
	+ $order[] = $order_by;
	+ }
	+
	+ if ($reverse) {
	+ $order[] = 'task.id ASC';
	+ } else {
	+ $order[] = 'task.id DESC';
	+ }
	+ }
	+
	return 'ORDER BY '.implode(', ', $order);
	}

	private function buildJoinsClause(AphrontDatabaseConnection $conn_r) {
	$edge_table = PhabricatorEdgeConfig::TABLE_NAME_EDGE;

	$joins = array();

	if ($this->projectPHIDs \|\| $this->includeNoProject) {
	$joins[] = qsprintf(
	$conn_r,
	'%Q JOIN %T project ON project.src = task.phid
	AND project.type = %d',
	($this->includeNoProject ? 'LEFT' : ''),
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	}

	if ($this->anyProjectPHIDs \|\| $this->anyUserProjectPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T anyproject ON anyproject.src = task.phid
	AND anyproject.type = %d',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	}

	if ($this->xprojectPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T xproject ON xproject.src = task.phid
	AND xproject.type = %d
	AND xproject.dst IN (%Ls)',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	$this->xprojectPHIDs);
	}

	if ($this->subscriberPHIDs) {
	$subscriber_dao = new ManiphestTaskSubscriber();
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T subscriber ON subscriber.taskPHID = task.phid',
	$subscriber_dao->getTableName());
	}

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$ignore_group_phids = $this->getIgnoreGroupedProjectPHIDs();
	if ($ignore_group_phids) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroup ON task.phid = projectGroup.src
	AND projectGroup.type = %d
	AND projectGroup.dst NOT IN (%Ls)',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	$ignore_group_phids);
	} else {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroup ON task.phid = projectGroup.src
	AND projectGroup.type = %d',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	}
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroupName
	ON projectGroup.dst = projectGroupName.indexedObjectPHID',
	id(new ManiphestNameIndex())->getTableName());
	break;
	}

	$joins[] = $this->buildApplicationSearchJoinClause($conn_r);

	return implode(' ', $joins);
	}

	private function buildGroupClause(AphrontDatabaseConnection $conn_r) {
	$joined_multiple_rows = (count($this->projectPHIDs) > 1) \|\|
	(count($this->anyProjectPHIDs) > 1) \|\|
	($this->getApplicationSearchMayJoinMultipleRows());

	$joined_project_name = ($this->groupBy == self::GROUP_PROJECT);

	// If we're joining multiple rows, we need to group the results by the
	// task IDs.
	if ($joined_multiple_rows) {
	if ($joined_project_name) {
	return 'GROUP BY task.phid, projectGroup.dst';
	} else {
	return 'GROUP BY task.phid';
	}
	} else {
	return '';
	}
	}

	/**
	* Return project PHIDs which we should ignore when grouping tasks by
	* project. For example, if a user issues a query like:
	*
	* Tasks in all projects: Frontend, Bugs
	*
	* ...then we don't show "Frontend" or "Bugs" groups in the result set, since
	* they're meaningless as all results are in both groups.
	*
	* Similarly, for queries like:
	*
	* Tasks in any projects: Public Relations
	*
	* ...we ignore the single project, as every result is in that project. (In
	* the case that there are several "any" projects, we do not ignore them.)
	*
	* @return list<phid> Project PHIDs which should be ignored in query
	* construction.
	*/
	private function getIgnoreGroupedProjectPHIDs() {
	$phids = array();

	if ($this->projectPHIDs) {
	$phids[] = $this->projectPHIDs;
	}

	if (count($this->anyProjectPHIDs) == 1) {
	$phids[] = $this->anyProjectPHIDs;
	}

	// Maybe we should also exclude the "excludeProjectPHIDs"? It won't
	// impact the results, but we might end up with a better query plan.
	// Investigate this on real data? This is likely very rare.

	return array_mergev($phids);
	}

	private function loadCursorObject($id) {
	$results = id(new ManiphestTaskQuery())
	->setViewer($this->getPagingViewer())
	->withIDs(array((int)$id))
	->execute();
	return head($results);
	}

	protected function getPagingValue($result) {
	$id = $result->getID();

	switch ($this->groupBy) {
	case self::GROUP_NONE:
	return $id;
	case self::GROUP_PRIORITY:
	return $id.'.'.$result->getPriority();
	case self::GROUP_OWNER:
	return rtrim($id.'.'.$result->getOwnerPHID(), '.');
	case self::GROUP_STATUS:
	return $id.'.'.$result->getStatus();
	case self::GROUP_PROJECT:
	return rtrim($id.'.'.$result->getGroupByProjectPHID(), '.');
	default:
	throw new Exception("Unknown group query '{$this->groupBy}'!");
	}
	}

	protected function buildPagingClause(AphrontDatabaseConnection $conn_r) {
	$default = parent::buildPagingClause($conn_r);

	$before_id = $this->getBeforeID();
	$after_id = $this->getAfterID();

	if (!$before_id && !$after_id) {
	return $default;
	}

	$cursor_id = nonempty($before_id, $after_id);
	$cursor_parts = explode('.', $cursor_id, 2);
	$task_id = $cursor_parts[0];
	$group_id = idx($cursor_parts, 1);

	$cursor = $this->loadCursorObject($task_id);
	if (!$cursor) {
	return null;
	}

	$columns = array();

	switch ($this->groupBy) {
	case self::GROUP_NONE:
	break;
	case self::GROUP_PRIORITY:
	$columns[] = array(
	'name' => 'task.priority',
	'value' => (int)$group_id,
	'type' => 'int',
	);
	break;
	case self::GROUP_OWNER:
	$columns[] = array(
	'name' => '(task.ownerOrdering IS NULL)',
	'value' => (int)(strlen($group_id) ? 0 : 1),
	'type' => 'int',
	);
	if ($group_id) {
	$paging_users = id(new PhabricatorPeopleQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($group_id))
	->execute();
	if (!$paging_users) {
	return null;
	}
	$columns[] = array(
	'name' => 'task.ownerOrdering',
	'value' => head($paging_users)->getUsername(),
	'type' => 'string',
	'reverse' => true,
	);
	}
	break;
	case self::GROUP_STATUS:
	$columns[] = array(
	'name' => 'task.status',
	'value' => $group_id,
	'type' => 'string',
	);
	break;
	case self::GROUP_PROJECT:
	$columns[] = array(
	'name' => '(projectGroupName.indexedObjectName IS NULL)',
	'value' => (int)(strlen($group_id) ? 0 : 1),
	'type' => 'int',
	);
	if ($group_id) {
	$paging_projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($group_id))
	->execute();
	if (!$paging_projects) {
	return null;
	}
	$columns[] = array(
	'name' => 'projectGroupName.indexedObjectName',
	'value' => head($paging_projects)->getName(),
	'type' => 'string',
	'reverse' => true,
	);
	}
	break;
	default:
	throw new Exception("Unknown group query '{$this->groupBy}'!");
	}

	- switch ($this->orderBy) {
	- case self::ORDER_PRIORITY:
	- if ($this->groupBy != self::GROUP_PRIORITY) {
	+ $app_columns = $this->buildApplicationSearchPagination($conn_r, $cursor);
	+ if ($app_columns) {
	+ $columns = array_merge($columns, $app_columns);
	+ $columns[] = array(
	+ 'name' => 'task.id',
	+ 'value' => (int)$cursor->getID(),
	+ 'type' => 'int',
	+ );
	+ } else {
	+ switch ($this->orderBy) {
	+ case self::ORDER_PRIORITY:
	+ if ($this->groupBy != self::GROUP_PRIORITY) {
	+ $columns[] = array(
	+ 'name' => 'task.priority',
	+ 'value' => (int)$cursor->getPriority(),
	+ 'type' => 'int',
	+ );
	+ }
	$columns[] = array(
	- 'name' => 'task.priority',
	- 'value' => (int)$cursor->getPriority(),
	+ 'name' => 'task.subpriority',
	+ 'value' => (int)$cursor->getSubpriority(),
	'type' => 'int',
	+ 'reverse' => true,
	);
	- }
	- $columns[] = array(
	- 'name' => 'task.subpriority',
	- 'value' => (int)$cursor->getSubpriority(),
	- 'type' => 'int',
	- 'reverse' => true,
	- );
	- $columns[] = array(
	- 'name' => 'task.dateModified',
	- 'value' => (int)$cursor->getDateModified(),
	- 'type' => 'int',
	- );
	- break;
	- case self::ORDER_CREATED:
	- $columns[] = array(
	- 'name' => 'task.id',
	- 'value' => (int)$cursor->getID(),
	- 'type' => 'int',
	- );
	- break;
	- case self::ORDER_MODIFIED:
	- $columns[] = array(
	- 'name' => 'task.dateModified',
	- 'value' => (int)$cursor->getDateModified(),
	- 'type' => 'int',
	- );
	- break;
	- case self::ORDER_TITLE:
	- $columns[] = array(
	- 'name' => 'task.title',
	- 'value' => $cursor->getTitle(),
	- 'type' => 'string',
	- );
	- $columns[] = array(
	- 'name' => 'task.id',
	- 'value' => $cursor->getID(),
	- 'type' => 'int',
	- );
	- break;
	- default:
	- throw new Exception("Unknown order query '{$this->orderBy}'!");
	+ $columns[] = array(
	+ 'name' => 'task.dateModified',
	+ 'value' => (int)$cursor->getDateModified(),
	+ 'type' => 'int',
	+ );
	+ break;
	+ case self::ORDER_CREATED:
	+ $columns[] = array(
	+ 'name' => 'task.id',
	+ 'value' => (int)$cursor->getID(),
	+ 'type' => 'int',
	+ );
	+ break;
	+ case self::ORDER_MODIFIED:
	+ $columns[] = array(
	+ 'name' => 'task.dateModified',
	+ 'value' => (int)$cursor->getDateModified(),
	+ 'type' => 'int',
	+ );
	+ break;
	+ case self::ORDER_TITLE:
	+ $columns[] = array(
	+ 'name' => 'task.title',
	+ 'value' => $cursor->getTitle(),
	+ 'type' => 'string',
	+ );
	+ $columns[] = array(
	+ 'name' => 'task.id',
	+ 'value' => $cursor->getID(),
	+ 'type' => 'int',
	+ );
	+ break;
	+ default:
	+ throw new Exception("Unknown order query '{$this->orderBy}'!");
	+ }
	}

	return $this->buildPagingClauseFromMultipleColumns(
	$conn_r,
	$columns,
	array(
	'reversed' => (bool)($before_id xor $this->getReversePaging()),
	));
	}

	protected function getApplicationSearchObjectPHIDColumn() {
	return 'task.phid';
	}

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

	}
	diff --git a/src/applications/maniphest/query/ManiphestTaskSearchEngine.php b/src/applications/maniphest/query/ManiphestTaskSearchEngine.php
	index ff72c1203e..2ac9cfcf81 100644
	--- a/src/applications/maniphest/query/ManiphestTaskSearchEngine.php
	+++ b/src/applications/maniphest/query/ManiphestTaskSearchEngine.php
	@@ -1,559 +1,560 @@
	<?php

	final class ManiphestTaskSearchEngine
	extends PhabricatorApplicationSearchEngine {

	private $showBatchControls;
	private $baseURI;
	private $isBoardView;

	public function setIsBoardView($is_board_view) {
	$this->isBoardView = $is_board_view;
	return $this;
	}

	public function getIsBoardView() {
	return $this->isBoardView;
	}

	public function setBaseURI($base_uri) {
	$this->baseURI = $base_uri;
	return $this;
	}

	public function getBaseURI() {
	return $this->baseURI;
	}

	public function setShowBatchControls($show_batch_controls) {
	$this->showBatchControls = $show_batch_controls;
	return $this;
	}

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

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

	public function getCustomFieldObject() {
	return new ManiphestTask();
	}

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

	$saved->setParameter(
	'assignedPHIDs',
	$this->readUsersFromRequest($request, 'assigned'));

	$saved->setParameter('withUnassigned', $request->getBool('withUnassigned'));

	$saved->setParameter(
	'authorPHIDs',
	$this->readUsersFromRequest($request, 'authors'));

	$saved->setParameter(
	'subscriberPHIDs',
	$this->readPHIDsFromRequest($request, 'subscribers'));

	$saved->setParameter(
	'statuses',
	$this->readListFromRequest($request, 'statuses'));

	$saved->setParameter(
	'priorities',
	$this->readListFromRequest($request, 'priorities'));

	$saved->setParameter('group', $request->getStr('group'));
	$saved->setParameter('order', $request->getStr('order'));

	$ids = $request->getStrList('ids');
	foreach ($ids as $key => $id) {
	$id = trim($id, ' Tt');
	if (!$id \|\| !is_numeric($id)) {
	unset($ids[$key]);
	} else {
	$ids[$key] = $id;
	}
	}
	$saved->setParameter('ids', $ids);

	$saved->setParameter('fulltext', $request->getStr('fulltext'));

	$saved->setParameter(
	'allProjectPHIDs',
	$this->readPHIDsFromRequest($request, 'allProjects'));

	$saved->setParameter(
	'withNoProject',
	$request->getBool('withNoProject'));

	$saved->setParameter(
	'anyProjectPHIDs',
	$this->readPHIDsFromRequest($request, 'anyProjects'));

	$saved->setParameter(
	'excludeProjectPHIDs',
	$this->readPHIDsFromRequest($request, 'excludeProjects'));

	$saved->setParameter(
	'userProjectPHIDs',
	$this->readUsersFromRequest($request, 'userProjects'));

	$saved->setParameter('createdStart', $request->getStr('createdStart'));
	$saved->setParameter('createdEnd', $request->getStr('createdEnd'));
	$saved->setParameter('modifiedStart', $request->getStr('modifiedStart'));
	$saved->setParameter('modifiedEnd', $request->getStr('modifiedEnd'));

	$limit = $request->getInt('limit');
	if ($limit > 0) {
	$saved->setParameter('limit', $limit);
	}

	$this->readCustomFieldsFromRequest($request, $saved);

	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new ManiphestTaskQuery());

	$author_phids = $saved->getParameter('authorPHIDs');
	if ($author_phids) {
	$query->withAuthors($author_phids);
	}

	$subscriber_phids = $saved->getParameter('subscriberPHIDs');
	if ($subscriber_phids) {
	$query->withSubscribers($subscriber_phids);
	}

	$with_unassigned = $saved->getParameter('withUnassigned');
	if ($with_unassigned) {
	$query->withOwners(array(null));
	} else {
	$assigned_phids = $saved->getParameter('assignedPHIDs', array());
	if ($assigned_phids) {
	$query->withOwners($assigned_phids);
	}
	}

	$statuses = $saved->getParameter('statuses');
	if ($statuses) {
	$query->withStatuses($statuses);
	}

	$priorities = $saved->getParameter('priorities');
	if ($priorities) {
	$query->withPriorities($priorities);
	}

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

	$group = $saved->getParameter('group');
	$group = idx($this->getGroupValues(), $group);
	if ($group) {
	$query->setGroupBy($group);
	} else {
	$query->setGroupBy(head($this->getGroupValues()));
	}

	$ids = $saved->getParameter('ids');
	if ($ids) {
	$query->withIDs($ids);
	}

	$fulltext = $saved->getParameter('fulltext');
	if (strlen($fulltext)) {
	$query->withFullTextSearch($fulltext);
	}

	$with_no_project = $saved->getParameter('withNoProject');
	if ($with_no_project) {
	$query->withAllProjects(array(ManiphestTaskOwner::PROJECT_NO_PROJECT));
	} else {
	$project_phids = $saved->getParameter('allProjectPHIDs');
	if ($project_phids) {
	$query->withAllProjects($project_phids);
	}
	}

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

	$exclude_project_phids = $saved->getParameter('excludeProjectPHIDs');
	if ($exclude_project_phids) {
	$query->withoutProjects($exclude_project_phids);
	}

	$user_project_phids = $saved->getParameter('userProjectPHIDs');
	if ($user_project_phids) {
	$query->withAnyUserProjects($user_project_phids);
	}

	$start = $this->parseDateTime($saved->getParameter('createdStart'));
	$end = $this->parseDateTime($saved->getParameter('createdEnd'));

	if ($start) {
	$query->withDateCreatedAfter($start);
	}

	if ($end) {
	$query->withDateCreatedBefore($end);
	}

	$mod_start = $this->parseDateTime($saved->getParameter('modifiedStart'));
	$mod_end = $this->parseDateTime($saved->getParameter('modifiedEnd'));

	if ($mod_start) {
	$query->withDateModifiedAfter($mod_start);
	}

	if ($mod_end) {
	$query->withDateModifiedBefore($mod_end);
	}

	$this->applyCustomFieldsToQuery($query, $saved);

	return $query;
	}

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

	$assigned_phids = $saved->getParameter('assignedPHIDs', array());
	$author_phids = $saved->getParameter('authorPHIDs', array());
	$all_project_phids = $saved->getParameter(
	'allProjectPHIDs',
	array());
	$any_project_phids = $saved->getParameter(
	'anyProjectPHIDs',
	array());
	$exclude_project_phids = $saved->getParameter(
	'excludeProjectPHIDs',
	array());
	$user_project_phids = $saved->getParameter(
	'userProjectPHIDs',
	array());
	$subscriber_phids = $saved->getParameter('subscriberPHIDs', array());

	$all_phids = array_merge(
	$assigned_phids,
	$author_phids,
	$all_project_phids,
	$any_project_phids,
	$exclude_project_phids,
	$user_project_phids,
	$subscriber_phids);

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

	$assigned_handles = array_select_keys($handles, $assigned_phids);
	$author_handles = array_select_keys($handles, $author_phids);
	$all_project_handles = array_select_keys($handles, $all_project_phids);
	$any_project_handles = array_select_keys($handles, $any_project_phids);
	$exclude_project_handles = array_select_keys(
	$handles,
	$exclude_project_phids);
	$user_project_handles = array_select_keys($handles, $user_project_phids);
	$subscriber_handles = array_select_keys($handles, $subscriber_phids);

	$with_unassigned = $saved->getParameter('withUnassigned');
	$with_no_projects = $saved->getParameter('withNoProject');

	$statuses = $saved->getParameter('statuses', array());
	$statuses = array_fuse($statuses);
	$status_control = id(new AphrontFormCheckboxControl())
	->setLabel(pht('Status'));
	foreach (ManiphestTaskStatus::getTaskStatusMap() as $status => $name) {
	$status_control->addCheckbox(
	'statuses[]',
	$status,
	$name,
	isset($statuses[$status]));
	}

	$priorities = $saved->getParameter('priorities', array());
	$priorities = array_fuse($priorities);
	$priority_control = id(new AphrontFormCheckboxControl())
	->setLabel(pht('Priority'));
	foreach (ManiphestTaskPriority::getTaskPriorityMap() as $pri => $name) {
	$priority_control->addCheckbox(
	'priorities[]',
	$pri,
	$name,
	isset($priorities[$pri]));
	}

	$ids = $saved->getParameter('ids', array());

	+ $builtin_orders = $this->getOrderOptions();
	+ $custom_orders = $this->getCustomFieldOrderOptions();
	+ $all_orders = $builtin_orders + $custom_orders;
	+
	$form
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorPeopleDatasource())
	->setName('assigned')
	->setLabel(pht('Assigned To'))
	->setValue($assigned_handles))
	->appendChild(
	id(new AphrontFormCheckboxControl())
	->addCheckbox(
	'withUnassigned',
	1,
	pht('Show only unassigned tasks.'),
	$with_unassigned))
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorProjectDatasource())
	->setName('allProjects')
	->setLabel(pht('In All Projects'))
	->setValue($all_project_handles));

	if (!$this->getIsBoardView()) {
	$form
	->appendChild(
	id(new AphrontFormCheckboxControl())
	->addCheckbox(
	'withNoProject',
	1,
	pht('Show only tasks with no projects.'),
	$with_no_projects));
	}

	$form
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorProjectDatasource())
	->setName('anyProjects')
	->setLabel(pht('In Any Project'))
	->setValue($any_project_handles))
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorProjectDatasource())
	->setName('excludeProjects')
	->setLabel(pht('Not In Projects'))
	->setValue($exclude_project_handles))
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorPeopleDatasource())
	->setName('userProjects')
	->setLabel(pht('In Users\' Projects'))
	->setValue($user_project_handles))
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorPeopleDatasource())
	->setName('authors')
	->setLabel(pht('Authors'))
	->setValue($author_handles))
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorMetaMTAMailableDatasource())
	->setName('subscribers')
	->setLabel(pht('Subscribers'))
	->setValue($subscriber_handles))
	->appendChild($status_control)
	->appendChild($priority_control);

	if (!$this->getIsBoardView()) {
	$form
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('group')
	->setLabel(pht('Group By'))
	->setValue($saved->getParameter('group'))
	->setOptions($this->getGroupOptions()))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('order')
	->setLabel(pht('Order By'))
	->setValue($saved->getParameter('order'))
	- ->setOptions($this->getOrderOptions()));
	+ ->setOptions($all_orders));
	}

	$form
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('fulltext')
	->setLabel(pht('Contains Words'))
	->setValue($saved->getParameter('fulltext')))
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('ids')
	->setLabel(pht('Task IDs'))
	->setValue(implode(', ', $ids)));

	$this->appendCustomFieldsToForm($form, $saved);

	$this->buildDateRange(
	$form,
	$saved,
	'createdStart',
	pht('Created After'),
	'createdEnd',
	pht('Created Before'));

	$this->buildDateRange(
	$form,
	$saved,
	'modifiedStart',
	pht('Updated After'),
	'modifiedEnd',
	pht('Updated Before'));

	if (!$this->getIsBoardView()) {
	$form
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('limit')
	->setLabel(pht('Page Size'))
	->setValue($saved->getParameter('limit', 100)));
	}
	}

	protected function getURI($path) {
	if ($this->baseURI) {
	return $this->baseURI.$path;
	}
	return '/maniphest/'.$path;
	}

	public function getBuiltinQueryNames() {
	$names = array();

	if ($this->requireViewer()->isLoggedIn()) {
	$names['assigned'] = pht('Assigned');
	$names['authored'] = pht('Authored');
	$names['subscribed'] = pht('Subscribed');
	}

	$names['open'] = pht('Open Tasks');
	$names['all'] = pht('All Tasks');

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {

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

	$viewer_phid = $this->requireViewer()->getPHID();

	switch ($query_key) {
	case 'all':
	return $query;
	case 'assigned':
	return $query
	->setParameter('assignedPHIDs', array($viewer_phid))
	->setParameter(
	'statuses',
	ManiphestTaskStatus::getOpenStatusConstants());
	case 'subscribed':
	return $query
	->setParameter('subscriberPHIDs', array($viewer_phid))
	->setParameter(
	'statuses',
	ManiphestTaskStatus::getOpenStatusConstants());
	case 'open':
	return $query
	->setParameter(
	'statuses',
	ManiphestTaskStatus::getOpenStatusConstants());
	case 'authored':
	return $query
	->setParameter('authorPHIDs', array($viewer_phid))
	->setParameter('order', 'created')
	->setParameter('group', 'none');
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	private function getOrderOptions() {
	return array(
	'priority' => pht('Priority'),
	'updated' => pht('Date Updated'),
	'created' => pht('Date Created'),
	'title' => pht('Title'),
	);
	}

	private function getOrderValues() {
	return array(
	'priority' => ManiphestTaskQuery::ORDER_PRIORITY,
	'updated' => ManiphestTaskQuery::ORDER_MODIFIED,
	'created' => ManiphestTaskQuery::ORDER_CREATED,
	'title' => ManiphestTaskQuery::ORDER_TITLE,
	);
	}

	private function getGroupOptions() {
	return array(
	'priority' => pht('Priority'),
	'assigned' => pht('Assigned'),
	'status' => pht('Status'),
	'project' => pht('Project'),
	'none' => pht('None'),
	);
	}

	private function getGroupValues() {
	return array(
	'priority' => ManiphestTaskQuery::GROUP_PRIORITY,
	'assigned' => ManiphestTaskQuery::GROUP_OWNER,
	'status' => ManiphestTaskQuery::GROUP_STATUS,
	'project' => ManiphestTaskQuery::GROUP_PROJECT,
	'none' => ManiphestTaskQuery::GROUP_NONE,
	);
	}

	protected function renderResultList(
	array $tasks,
	PhabricatorSavedQuery $saved,
	array $handles) {

	$viewer = $this->requireViewer();

	if ($this->isPanelContext()) {
	$can_edit_priority = false;
	$can_bulk_edit = false;
	} else {
	$can_edit_priority = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$this->getApplication(),
	ManiphestEditPriorityCapability::CAPABILITY);

	$can_bulk_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$this->getApplication(),
	ManiphestBulkEditCapability::CAPABILITY);
	}

	return id(new ManiphestTaskResultListView())
	->setUser($viewer)
	->setTasks($tasks)
	->setSavedQuery($saved)
	->setCanEditPriority($can_edit_priority)
	->setCanBatchEdit($can_bulk_edit)
	->setShowBatchControls($this->showBatchControls);
	}

	}
	diff --git a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	index 531f88e70d..d7327c67d7 100644
	--- a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	+++ b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	@@ -1,823 +1,882 @@
	<?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 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 saveQuery(PhabricatorSavedQuery $query) {
	$query->setEngineClassName(get_class($this));

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	try {
	$query->save();
	} catch (AphrontQueryDuplicateKeyException $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;
	}

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


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


	/* -( 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/customfield/field/PhabricatorCustomField.php b/src/infrastructure/customfield/field/PhabricatorCustomField.php
	index 2741cf6b25..f0da81932f 100644
	--- a/src/infrastructure/customfield/field/PhabricatorCustomField.php
	+++ b/src/infrastructure/customfield/field/PhabricatorCustomField.php
	@@ -1,1361 +1,1383 @@
	<?php

	/**
	* @task apps Building Applications with Custom Fields
	* @task core Core Properties and Field Identity
	* @task proxy Field Proxies
	* @task context Contextual Data
	* @task render Rendering Utilities
	* @task storage Field Storage
	* @task edit Integration with Edit Views
	* @task view Integration with Property Views
	* @task list Integration with List views
	* @task appsearch Integration with ApplicationSearch
	* @task appxaction Integration with ApplicationTransactions
	* @task xactionmail Integration with Transaction Mail
	* @task globalsearch Integration with Global Search
	* @task herald Integration with Herald
	*/
	abstract class PhabricatorCustomField {

	private $viewer;
	private $object;
	private $proxy;

	const ROLE_APPLICATIONTRANSACTIONS = 'ApplicationTransactions';
	const ROLE_TRANSACTIONMAIL = 'ApplicationTransactions.mail';
	const ROLE_APPLICATIONSEARCH = 'ApplicationSearch';
	const ROLE_STORAGE = 'storage';
	const ROLE_DEFAULT = 'default';
	const ROLE_EDIT = 'edit';
	const ROLE_VIEW = 'view';
	const ROLE_LIST = 'list';
	const ROLE_GLOBALSEARCH = 'GlobalSearch';
	const ROLE_CONDUIT = 'conduit';
	const ROLE_HERALD = 'herald';


	/* -( Building Applications with Custom Fields )--------------------------- */


	/**
	* @task apps
	*/
	public static function getObjectFields(
	PhabricatorCustomFieldInterface $object,
	$role) {

	try {
	$attachment = $object->getCustomFields();
	} catch (PhabricatorDataNotAttachedException $ex) {
	$attachment = new PhabricatorCustomFieldAttachment();
	$object->attachCustomFields($attachment);
	}

	try {
	$field_list = $attachment->getCustomFieldList($role);
	} catch (PhabricatorCustomFieldNotAttachedException $ex) {
	$base_class = $object->getCustomFieldBaseClass();

	$spec = $object->getCustomFieldSpecificationForRole($role);
	if (!is_array($spec)) {
	$obj_class = get_class($object);
	throw new Exception(
	"Expected an array from getCustomFieldSpecificationForRole() for ".
	"object of class '{$obj_class}'.");
	}

	$fields = PhabricatorCustomField::buildFieldList(
	$base_class,
	$spec,
	$object);

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

	foreach ($fields as $field) {
	$field->setObject($object);
	}

	$field_list = new PhabricatorCustomFieldList($fields);
	$attachment->addCustomFieldList($role, $field_list);
	}

	return $field_list;
	}


	/**
	* @task apps
	*/
	public static function getObjectField(
	PhabricatorCustomFieldInterface $object,
	$role,
	$field_key) {

	$fields = self::getObjectFields($object, $role)->getFields();

	return idx($fields, $field_key);
	}


	/**
	* @task apps
	*/
	public static function buildFieldList($base_class, array $spec, $object) {
	$field_objects = id(new PhutilSymbolLoader())
	->setAncestorClass($base_class)
	->loadObjects();

	$fields = array();
	$from_map = array();
	foreach ($field_objects as $field_object) {
	$current_class = get_class($field_object);
	foreach ($field_object->createFields($object) as $field) {
	$key = $field->getFieldKey();
	if (isset($fields[$key])) {
	$original_class = $from_map[$key];
	throw new Exception(
	"Both '{$original_class}' and '{$current_class}' define a custom ".
	"field with field key '{$key}'. Field keys must be unique.");
	}
	$from_map[$key] = $current_class;
	$fields[$key] = $field;
	}
	}

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

	$fields = array_select_keys($fields, array_keys($spec)) + $fields;

	foreach ($spec as $key => $config) {
	if (empty($fields[$key])) {
	continue;
	}
	if (!empty($config['disabled'])) {
	if ($fields[$key]->canDisableField()) {
	unset($fields[$key]);
	}
	}
	}

	return $fields;
	}


	/* -( Core Properties and Field Identity )--------------------------------- */


	/**
	* Return a key which uniquely identifies this field, like
	* "mycompany:dinosaur:count". Normally you should provide some level of
	* namespacing to prevent collisions.
	*
	* @return string String which uniquely identifies this field.
	* @task core
	*/
	public function getFieldKey() {
	if ($this->proxy) {
	return $this->proxy->getFieldKey();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException(
	$this,
	$field_key_is_incomplete = true);
	}


	/**
	* Return a human-readable field name.
	*
	* @return string Human readable field name.
	* @task core
	*/
	public function getFieldName() {
	if ($this->proxy) {
	return $this->proxy->getFieldName();
	}
	return $this->getFieldKey();
	}


	/**
	* Return a short, human-readable description of the field's behavior. This
	* provides more context to administrators when they are customizing fields.
	*
	* @return string\|null Optional human-readable description.
	* @task core
	*/
	public function getFieldDescription() {
	if ($this->proxy) {
	return $this->proxy->getFieldDescription();
	}
	return null;
	}


	/**
	* Most field implementations are unique, in that one class corresponds to
	* one field. However, some field implementations are general and a single
	* implementation may drive several fields.
	*
	* For general implementations, the general field implementation can return
	* multiple field instances here.
	*
	* @param object The object to create fields for.
	* @return list<PhabricatorCustomField> List of fields.
	* @task core
	*/
	public function createFields($object) {
	return array($this);
	}


	/**
	* You can return `false` here if the field should not be enabled for any
	* role. For example, it might depend on something (like an application or
	* library) which isn't installed, or might have some global configuration
	* which allows it to be disabled.
	*
	* @return bool False to completely disable this field for all roles.
	* @task core
	*/
	public function isFieldEnabled() {
	if ($this->proxy) {
	return $this->proxy->isFieldEnabled();
	}
	return true;
	}


	/**
	* Low level selector for field availability. Fields can appear in different
	* roles (like an edit view, a list view, etc.), but not every field needs
	* to appear everywhere. Fields that are disabled in a role won't appear in
	* that context within applications.
	*
	* Normally, you do not need to override this method. Instead, override the
	* methods specific to roles you want to enable. For example, implement
	* @{method:shouldUseStorage()} to activate the `'storage'` role.
	*
	* @return bool True to enable the field for the given role.
	* @task core
	*/
	public function shouldEnableForRole($role) {

	// NOTE: All of these calls proxy individually, so we don't need to
	// proxy this call as a whole.

	switch ($role) {
	case self::ROLE_APPLICATIONTRANSACTIONS:
	return $this->shouldAppearInApplicationTransactions();
	case self::ROLE_APPLICATIONSEARCH:
	return $this->shouldAppearInApplicationSearch();
	case self::ROLE_STORAGE:
	return $this->shouldUseStorage();
	case self::ROLE_EDIT:
	return $this->shouldAppearInEditView();
	case self::ROLE_VIEW:
	return $this->shouldAppearInPropertyView();
	case self::ROLE_LIST:
	return $this->shouldAppearInListView();
	case self::ROLE_GLOBALSEARCH:
	return $this->shouldAppearInGlobalSearch();
	case self::ROLE_CONDUIT:
	return $this->shouldAppearInConduitDictionary();
	case self::ROLE_TRANSACTIONMAIL:
	return $this->shouldAppearInTransactionMail();
	case self::ROLE_HERALD:
	return $this->shouldAppearInHerald();
	case self::ROLE_DEFAULT:
	return true;
	default:
	throw new Exception("Unknown field role '{$role}'!");
	}
	}


	/**
	* Allow administrators to disable this field. Most fields should allow this,
	* but some are fundamental to the behavior of the application and can be
	* locked down to avoid chaos, disorder, and the decline of civilization.
	*
	* @return bool False to prevent this field from being disabled through
	* configuration.
	* @task core
	*/
	public function canDisableField() {
	return true;
	}

	public function shouldDisableByDefault() {
	return false;
	}


	/**
	* Return an index string which uniquely identifies this field.
	*
	* @return string Index string which uniquely identifies this field.
	* @task core
	*/
	final public function getFieldIndex() {
	return PhabricatorHash::digestForIndex($this->getFieldKey());
	}


	/* -( Field Proxies )------------------------------------------------------ */


	/**
	* Proxies allow a field to use some other field's implementation for most
	* of their behavior while still subclassing an application field. When a
	* proxy is set for a field with @{method:setProxy}, all of its methods will
	* call through to the proxy by default.
	*
	* This is most commonly used to implement configuration-driven custom fields
	* using @{class:PhabricatorStandardCustomField}.
	*
	* This method must be overridden to return `true` before a field can accept
	* proxies.
	*
	* @return bool True if you can @{method:setProxy} this field.
	* @task proxy
	*/
	public function canSetProxy() {
	if ($this instanceof PhabricatorStandardCustomFieldInterface) {
	return true;
	}
	return false;
	}


	/**
	* Set the proxy implementation for this field. See @{method:canSetProxy} for
	* discussion of field proxies.
	*
	* @param PhabricatorCustomField Field implementation.
	* @return this
	*/
	final public function setProxy(PhabricatorCustomField $proxy) {
	if (!$this->canSetProxy()) {
	throw new PhabricatorCustomFieldNotProxyException($this);
	}

	$this->proxy = $proxy;
	return $this;
	}


	/**
	* Get the field's proxy implementation, if any. For discussion, see
	* @{method:canSetProxy}.
	*
	* @return PhabricatorCustomField\|null Proxy field, if one is set.
	*/
	final public function getProxy() {
	return $this->proxy;
	}


	/* -( Contextual Data )---------------------------------------------------- */


	/**
	* Sets the object this field belongs to.
	*
	* @param PhabricatorCustomFieldInterface The object this field belongs to.
	* @return this
	* @task context
	*/
	final public function setObject(PhabricatorCustomFieldInterface $object) {
	if ($this->proxy) {
	$this->proxy->setObject($object);
	return $this;
	}

	$this->object = $object;
	$this->didSetObject($object);
	return $this;
	}


	/**
	* Read object data into local field storage, if applicable.
	*
	* @param PhabricatorCustomFieldInterface The object this field belongs to.
	* @return this
	* @task context
	*/
	public function readValueFromObject(PhabricatorCustomFieldInterface $object) {
	if ($this->proxy) {
	$this->proxy->readValueFromObject($object);
	}
	return $this;
	}


	/**
	* Get the object this field belongs to.
	*
	* @return PhabricatorCustomFieldInterface The object this field belongs to.
	* @task context
	*/
	final public function getObject() {
	if ($this->proxy) {
	return $this->proxy->getObject();
	}

	return $this->object;
	}


	/**
	* This is a hook, primarily for subclasses to load object data.
	*
	* @return PhabricatorCustomFieldInterface The object this field belongs to.
	* @return void
	*/
	protected function didSetObject(PhabricatorCustomFieldInterface $object) {
	return;
	}


	/**
	* @task context
	*/
	final public function setViewer(PhabricatorUser $viewer) {
	if ($this->proxy) {
	$this->proxy->setViewer($viewer);
	return $this;
	}

	$this->viewer = $viewer;
	return $this;
	}


	/**
	* @task context
	*/
	final public function getViewer() {
	if ($this->proxy) {
	return $this->proxy->getViewer();
	}

	return $this->viewer;
	}


	/**
	* @task context
	*/
	final protected function requireViewer() {
	if ($this->proxy) {
	return $this->proxy->requireViewer();
	}

	if (!$this->viewer) {
	throw new PhabricatorCustomFieldDataNotAvailableException($this);
	}
	return $this->viewer;
	}


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


	/**
	* @task render
	*/
	protected function renderHandleList(array $handles) {
	if (!$handles) {
	return null;
	}

	$out = array();
	foreach ($handles as $handle) {
	$out[] = $handle->renderLink();
	}

	return phutil_implode_html(phutil_tag('br'), $out);
	}


	/* -( Storage )------------------------------------------------------------ */


	/**
	* Return true to use field storage.
	*
	* Fields which can be edited by the user will most commonly use storage,
	* while some other types of fields (for instance, those which just display
	* information in some stylized way) may not. Many builtin fields do not use
	* storage because their data is available on the object itself.
	*
	* If you implement this, you must also implement @{method:getValueForStorage}
	* and @{method:setValueFromStorage}.
	*
	* @return bool True to use storage.
	* @task storage
	*/
	public function shouldUseStorage() {
	if ($this->proxy) {
	return $this->proxy->shouldUseStorage();
	}
	return false;
	}


	/**
	* Return a new, empty storage object. This should be a subclass of
	* @{class:PhabricatorCustomFieldStorage} which is bound to the application's
	* database.
	*
	* @return PhabricatorCustomFieldStorage New empty storage object.
	* @task storage
	*/
	public function newStorageObject() {
	if ($this->proxy) {
	return $this->proxy->newStorageObject();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Return a serialized representation of the field value, appropriate for
	* storing in auxiliary field storage. You must implement this method if
	* you implement @{method:shouldUseStorage}.
	*
	* If the field value is a scalar, it can be returned unmodiifed. If not,
	* it should be serialized (for example, using JSON).
	*
	* @return string Serialized field value.
	* @task storage
	*/
	public function getValueForStorage() {
	if ($this->proxy) {
	return $this->proxy->getValueForStorage();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Set the field's value given a serialized storage value. This is called
	* when the field is loaded; if no data is available, the value will be
	* null. You must implement this method if you implement
	* @{method:shouldUseStorage}.
	*
	* Usually, the value can be loaded directly. If it isn't a scalar, you'll
	* need to undo whatever serialization you applied in
	* @{method:getValueForStorage}.
	*
	* @param string\|null Serialized field representation (from
	* @{method:getValueForStorage}) or null if no value has
	* ever been stored.
	* @return this
	* @task storage
	*/
	public function setValueFromStorage($value) {
	if ($this->proxy) {
	return $this->proxy->setValueFromStorage($value);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( ApplicationSearch )-------------------------------------------------- */


	/**
	* Appearing in ApplicationSearch allows a field to be indexed and searched
	* for.
	*
	* @return bool True to appear in ApplicationSearch.
	* @task appsearch
	*/
	public function shouldAppearInApplicationSearch() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInApplicationSearch();
	}
	return false;
	}


	/**
	* Return one or more indexes which this field can meaningfully query against
	* to implement ApplicationSearch.
	*
	* Normally, you should build these using @{method:newStringIndex} and
	* @{method:newNumericIndex}. For example, if a field holds a numeric value
	* it might return a single numeric index:
	*
	* return array($this->newNumericIndex($this->getValue()));
	*
	* If a field holds a more complex value (like a list of users), it might
	* return several string indexes:
	*
	* $indexes = array();
	* foreach ($this->getValue() as $phid) {
	* $indexes[] = $this->newStringIndex($phid);
	* }
	* return $indexes;
	*
	* @return list<PhabricatorCustomFieldIndexStorage> List of indexes.
	* @task appsearch
	*/
	public function buildFieldIndexes() {
	if ($this->proxy) {
	return $this->proxy->buildFieldIndexes();
	}
	return array();
	}


	+ /**
	+ * Return an index against which this field can be meaningfully ordered
	+ * against to implement ApplicationSearch.
	+ *
	+ * This should be a single index, normally built using
	+ * @{method:newStringIndex} and @{method:newNumericIndex}.
	+ *
	+ * The value of the index is not used.
	+ *
	+ * Return null from this method if the field can not be ordered.
	+ *
	+ * @return PhabricatorCustomFieldIndexStorage A single index to order by.
	+ * @task appsearch
	+ */
	+ public function buildOrderIndex() {
	+ if ($this->proxy) {
	+ return $this->proxy->buildOrderIndex();
	+ }
	+ return null;
	+ }
	+
	+
	/**
	* Build a new empty storage object for storing string indexes. Normally,
	* this should be a concrete subclass of
	* @{class:PhabricatorCustomFieldStringIndexStorage}.
	*
	* @return PhabricatorCustomFieldStringIndexStorage Storage object.
	* @task appsearch
	*/
	protected function newStringIndexStorage() {
	// NOTE: This intentionally isn't proxied, to avoid call cycles.
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Build a new empty storage object for storing string indexes. Normally,
	* this should be a concrete subclass of
	* @{class:PhabricatorCustomFieldStringIndexStorage}.
	*
	* @return PhabricatorCustomFieldStringIndexStorage Storage object.
	* @task appsearch
	*/
	protected function newNumericIndexStorage() {
	// NOTE: This intentionally isn't proxied, to avoid call cycles.
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Build and populate storage for a string index.
	*
	* @param string String to index.
	* @return PhabricatorCustomFieldStringIndexStorage Populated storage.
	* @task appsearch
	*/
	protected function newStringIndex($value) {
	if ($this->proxy) {
	return $this->proxy->newStringIndex();
	}

	$key = $this->getFieldIndex();
	return $this->newStringIndexStorage()
	->setIndexKey($key)
	->setIndexValue($value);
	}


	/**
	* Build and populate storage for a numeric index.
	*
	* @param string Numeric value to index.
	* @return PhabricatorCustomFieldNumericIndexStorage Populated storage.
	* @task appsearch
	*/
	protected function newNumericIndex($value) {
	if ($this->proxy) {
	return $this->proxy->newNumericIndex();
	}
	$key = $this->getFieldIndex();
	return $this->newNumericIndexStorage()
	->setIndexKey($key)
	->setIndexValue($value);
	}


	/**
	* Read a query value from a request, for storage in a saved query. Normally,
	* this method should, e.g., read a string out of the request.
	*
	* @param PhabricatorApplicationSearchEngine Engine building the query.
	* @param AphrontRequest Request to read from.
	* @return wild
	* @task appsearch
	*/
	public function readApplicationSearchValueFromRequest(
	PhabricatorApplicationSearchEngine $engine,
	AphrontRequest $request) {
	if ($this->proxy) {
	return $this->proxy->readApplicationSearchValueFromRequest(
	$engine,
	$request);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Constrain a query, given a field value. Generally, this method should
	* use `with...()` methods to apply filters or other constraints to the
	* query.
	*
	* @param PhabricatorApplicationSearchEngine Engine executing the query.
	* @param PhabricatorCursorPagedPolicyAwareQuery Query to constrain.
	* @param wild Constraint provided by the user.
	* @return void
	* @task appsearch
	*/
	public function applyApplicationSearchConstraintToQuery(
	PhabricatorApplicationSearchEngine $engine,
	PhabricatorCursorPagedPolicyAwareQuery $query,
	$value) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationSearchConstraintToQuery(
	$engine,
	$query,
	$value);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Append search controls to the interface. If you need handles, use
	* @{method:getRequiredHandlePHIDsForApplicationSearch} to get them.
	*
	* @param PhabricatorApplicationSearchEngine Engine constructing the form.
	* @param AphrontFormView The form to update.
	* @param wild Value from the saved query.
	* @param list<PhabricatorObjectHandle> List of handles.
	* @return void
	* @task appsearch
	*/
	public function appendToApplicationSearchForm(
	PhabricatorApplicationSearchEngine $engine,
	AphrontFormView $form,
	$value,
	array $handles) {
	if ($this->proxy) {
	return $this->proxy->appendToApplicationSearchForm(
	$engine,
	$form,
	$value,
	$handles);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Return a list of PHIDs which @{method:appendToApplicationSearchForm} needs
	* handles for. This is primarily useful if the field stores PHIDs and you
	* need to (for example) render a tokenizer control.
	*
	* @param wild Value from the saved query.
	* @return list<phid> List of PHIDs.
	* @task appsearch
	*/
	public function getRequiredHandlePHIDsForApplicationSearch($value) {
	if ($this->proxy) {
	return $this->proxy->getRequiredHandlePHIDsForApplicationSearch($value);
	}
	return array();
	}


	/* -( ApplicationTransactions )-------------------------------------------- */


	/**
	* Appearing in ApplicationTrasactions allows a field to be edited using
	* standard workflows.
	*
	* @return bool True to appear in ApplicationTransactions.
	* @task appxaction
	*/
	public function shouldAppearInApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInApplicationTransactions();
	}
	return false;
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionType() {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionType();
	}
	return PhabricatorTransactions::TYPE_CUSTOMFIELD;
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionMetadata() {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionMetadata();
	}
	return array();
	}


	/**
	* @task appxaction
	*/
	public function getOldValueForApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->getOldValueForApplicationTransactions();
	}
	return $this->getValueForStorage();
	}


	/**
	* @task appxaction
	*/
	public function getNewValueForApplicationTransactions() {
	if ($this->proxy) {
	return $this->proxy->getNewValueForApplicationTransactions();
	}
	return $this->getValueForStorage();
	}


	/**
	* @task appxaction
	*/
	public function setValueFromApplicationTransactions($value) {
	if ($this->proxy) {
	return $this->proxy->setValueFromApplicationTransactions($value);
	}
	return $this->setValueFromStorage($value);
	}


	/**
	* @task appxaction
	*/
	public function getNewValueFromApplicationTransactions(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getNewValueFromApplicationTransactions($xaction);
	}
	return $xaction->getNewValue();
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionHasEffect(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionHasEffect($xaction);
	}
	return ($xaction->getOldValue() !== $xaction->getNewValue());
	}


	/**
	* @task appxaction
	*/
	public function applyApplicationTransactionInternalEffects(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationTransactionInternalEffects($xaction);
	}
	return;
	}


	/**
	* @task appxaction
	*/
	public function getApplicationTransactionRemarkupBlocks(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionRemarkupBlocks($xaction);
	}
	return array();
	}


	/**
	* @task appxaction
	*/
	public function applyApplicationTransactionExternalEffects(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->applyApplicationTransactionExternalEffects($xaction);
	}

	if (!$this->shouldEnableForRole(self::ROLE_STORAGE)) {
	return;
	}

	$this->setValueFromApplicationTransactions($xaction->getNewValue());
	$value = $this->getValueForStorage();

	$table = $this->newStorageObject();
	$conn_w = $table->establishConnection('w');

	if ($value === null) {
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE objectPHID = %s AND fieldIndex = %s',
	$table->getTableName(),
	$this->getObject()->getPHID(),
	$this->getFieldIndex());
	} else {
	queryfx(
	$conn_w,
	'INSERT INTO %T (objectPHID, fieldIndex, fieldValue)
	VALUES (%s, %s, %s)
	ON DUPLICATE KEY UPDATE fieldValue = VALUES(fieldValue)',
	$table->getTableName(),
	$this->getObject()->getPHID(),
	$this->getFieldIndex(),
	$value);
	}

	return;
	}


	/**
	* Validate transactions for an object. This allows you to raise an error
	* when a transaction would set a field to an invalid value, or when a field
	* is required but no transactions provide value.
	*
	* @param PhabricatorLiskDAO Editor applying the transactions.
	* @param string Transaction type. This type is always
	* `PhabricatorTransactions::TYPE_CUSTOMFIELD`, it is provided for
	* convenience when constructing exceptions.
	* @param list<PhabricatorApplicationTransaction> Transactions being applied,
	* which may be empty if this field is not being edited.
	* @return list<PhabricatorApplicationTransactionValidationError> Validation
	* errors.
	*
	* @task appxaction
	*/
	public function validateApplicationTransactions(
	PhabricatorApplicationTransactionEditor $editor,
	$type,
	array $xactions) {
	if ($this->proxy) {
	return $this->proxy->validateApplicationTransactions(
	$editor,
	$type,
	$xactions);
	}
	return array();
	}

	public function getApplicationTransactionTitle(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionTitle(
	$xaction);
	}

	$author_phid = $xaction->getAuthorPHID();
	return pht(
	'%s updated this object.',
	$xaction->renderHandleLink($author_phid));
	}

	public function getApplicationTransactionTitleForFeed(
	PhabricatorApplicationTransaction $xaction,
	PhabricatorFeedStory $story) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionTitleForFeed(
	$xaction,
	$story);
	}

	$author_phid = $xaction->getAuthorPHID();
	$object_phid = $xaction->getObjectPHID();
	return pht(
	'%s updated %s.',
	$xaction->renderHandleLink($author_phid),
	$xaction->renderHandleLink($object_phid));
	}


	public function getApplicationTransactionHasChangeDetails(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionHasChangeDetails(
	$xaction);
	}
	return false;
	}

	public function getApplicationTransactionChangeDetails(
	PhabricatorApplicationTransaction $xaction,
	PhabricatorUser $viewer) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionChangeDetails(
	$xaction,
	$viewer);
	}
	return null;
	}

	public function getApplicationTransactionRequiredHandlePHIDs(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->getApplicationTransactionRequiredHandlePHIDs(
	$xaction);
	}
	return array();
	}

	public function shouldHideInApplicationTransactions(
	PhabricatorApplicationTransaction $xaction) {
	if ($this->proxy) {
	return $this->proxy->shouldHideInApplicationTransactions($xaction);
	}
	return false;
	}

	/**
	* TODO: this is only used by Diffusion right now and everything is completely
	* faked since Diffusion doesn't use ApplicationTransactions yet. This should
	* get fleshed out as we have more use cases.
	*
	* @task appxaction
	*/
	public function buildApplicationTransactionMailBody(
	PhabricatorApplicationTransaction $xaction,
	PhabricatorMetaMTAMailBody $body) {
	if ($this->proxy) {
	return $this->proxy->buildApplicationTransactionMailBody($xaction, $body);
	}
	return;
	}


	/* -( Transaction Mail )--------------------------------------------------- */


	/**
	* @task xactionmail
	*/
	public function shouldAppearInTransactionMail() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInTransactionMail();
	}
	return false;
	}


	/**
	* @task xactionmail
	*/
	public function updateTransactionMailBody(
	PhabricatorMetaMTAMailBody $body,
	PhabricatorApplicationTransactionEditor $editor,
	array $xactions) {
	if ($this->proxy) {
	return $this->proxy->updateTransactionMailBody($body, $editor, $xactions);
	}
	return;
	}


	/* -( Edit View )---------------------------------------------------------- */


	/**
	* @task edit
	*/
	public function shouldAppearInEditView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInEditView();
	}
	return false;
	}


	/**
	* @task edit
	*/
	public function readValueFromRequest(AphrontRequest $request) {
	if ($this->proxy) {
	return $this->proxy->readValueFromRequest($request);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* @task edit
	*/
	public function getRequiredHandlePHIDsForEdit() {
	if ($this->proxy) {
	return $this->proxy->getRequiredHandlePHIDsForEdit();
	}
	return array();
	}


	/**
	* @task edit
	*/
	public function getInstructionsForEdit() {
	if ($this->proxy) {
	return $this->proxy->getInstructionsForEdit();
	}
	return null;
	}


	/**
	* @task edit
	*/
	public function renderEditControl(array $handles) {
	if ($this->proxy) {
	return $this->proxy->renderEditControl($handles);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( Property View )------------------------------------------------------ */


	/**
	* @task view
	*/
	public function shouldAppearInPropertyView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInPropertyView();
	}
	return false;
	}


	/**
	* @task view
	*/
	public function renderPropertyViewLabel() {
	if ($this->proxy) {
	return $this->proxy->renderPropertyViewLabel();
	}
	return $this->getFieldName();
	}


	/**
	* @task view
	*/
	public function renderPropertyViewValue(array $handles) {
	if ($this->proxy) {
	return $this->proxy->renderPropertyViewValue($handles);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* @task view
	*/
	public function getStyleForPropertyView() {
	if ($this->proxy) {
	return $this->proxy->getStyleForPropertyView();
	}
	return 'property';
	}


	/**
	* @task view
	*/
	public function getIconForPropertyView() {
	if ($this->proxy) {
	return $this->proxy->getIconForPropertyView();
	}
	return null;
	}


	/**
	* @task view
	*/
	public function getRequiredHandlePHIDsForPropertyView() {
	if ($this->proxy) {
	return $this->proxy->getRequiredHandlePHIDsForPropertyView();
	}
	return array();
	}


	/* -( List View )---------------------------------------------------------- */


	/**
	* @task list
	*/
	public function shouldAppearInListView() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInListView();
	}
	return false;
	}


	/**
	* @task list
	*/
	public function renderOnListItem(PHUIObjectItemView $view) {
	if ($this->proxy) {
	return $this->proxy->renderOnListItem($view);
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( Global Search )------------------------------------------------------ */


	/**
	* @task globalsearch
	*/
	public function shouldAppearInGlobalSearch() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInGlobalSearch();
	}
	return false;
	}


	/**
	* @task globalsearch
	*/
	public function updateAbstractDocument(
	PhabricatorSearchAbstractDocument $document) {
	if ($this->proxy) {
	return $this->proxy->updateAbstractDocument($document);
	}
	return $document;
	}


	/* -( Conduit )------------------------------------------------------------ */


	/**
	* @task conduit
	*/
	public function shouldAppearInConduitDictionary() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInConduitDictionary();
	}
	return false;
	}


	/**
	* @task conduit
	*/
	public function getConduitDictionaryValue() {
	if ($this->proxy) {
	return $this->proxy->getConduitDictionaryValue();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/* -( Herald )------------------------------------------------------------- */


	/**
	* Return `true` to make this field available in Herald.
	*
	* @return bool True to expose the field in Herald.
	* @task herald
	*/
	public function shouldAppearInHerald() {
	if ($this->proxy) {
	return $this->proxy->shouldAppearInHerald();
	}
	return false;
	}


	/**
	* Get the name of the field in Herald. By default, this uses the
	* normal field name.
	*
	* @return string Herald field name.
	* @task herald
	*/
	public function getHeraldFieldName() {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldName();
	}
	return $this->getFieldName();
	}


	/**
	* Get the field value for evaluation by Herald.
	*
	* @return wild Field value.
	* @task herald
	*/
	public function getHeraldFieldValue() {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldValue();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Get the available conditions for this field in Herald.
	*
	* @return list<const> List of Herald condition constants.
	* @task herald
	*/
	public function getHeraldFieldConditions() {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldConditions();
	}
	throw new PhabricatorCustomFieldImplementationIncompleteException($this);
	}


	/**
	* Get the Herald value type for the given condition.
	*
	* @param const Herald condition constant.
	* @return const\|null Herald value type, or null to use the default.
	* @task herald
	*/
	public function getHeraldFieldValueType($condition) {
	if ($this->proxy) {
	return $this->proxy->getHeraldFieldValueType($condition);
	}
	return null;
	}


	}
	diff --git a/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php b/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
	index 4eafe7c264..f7acb02a94 100644
	--- a/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
	+++ b/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
	@@ -1,399 +1,403 @@
	<?php

	abstract class PhabricatorStandardCustomField
	extends PhabricatorCustomField {

	private $rawKey;
	private $fieldKey;
	private $fieldName;
	private $fieldValue;
	private $fieldDescription;
	private $fieldConfig;
	private $applicationField;
	private $strings = array();
	private $caption;
	private $fieldError;
	private $required;
	private $default;

	abstract public function getFieldType();

	public static function buildStandardFields(
	PhabricatorCustomField $template,
	array $config) {

	$types = id(new PhutilSymbolLoader())
	->setAncestorClass(__CLASS__)
	->loadObjects();
	$types = mpull($types, null, 'getFieldType');

	$fields = array();
	foreach ($config as $key => $value) {
	$type = idx($value, 'type', 'text');
	if (empty($types[$type])) {
	// TODO: We should have better typechecking somewhere, and then make
	// this more serious.
	continue;
	}

	$namespace = $template->getStandardCustomFieldNamespace();
	$full_key = "std:{$namespace}:{$key}";

	$template = clone $template;
	$standard = id(clone $types[$type])
	->setRawStandardFieldKey($key)
	->setFieldKey($full_key)
	->setFieldConfig($value)
	->setApplicationField($template);

	$field = $template->setProxy($standard);
	$fields[] = $field;
	}

	return $fields;
	}

	public function setApplicationField(
	PhabricatorStandardCustomFieldInterface $application_field) {
	$this->applicationField = $application_field;
	return $this;
	}

	public function getApplicationField() {
	return $this->applicationField;
	}

	public function setFieldName($name) {
	$this->fieldName = $name;
	return $this;
	}

	public function getFieldValue() {
	return $this->fieldValue;
	}

	public function setFieldValue($value) {
	$this->fieldValue = $value;
	return $this;
	}

	public function setCaption($caption) {
	$this->caption = $caption;
	return $this;
	}

	public function getCaption() {
	return $this->caption;
	}

	public function setFieldDescription($description) {
	$this->fieldDescription = $description;
	return $this;
	}

	public function setFieldConfig(array $config) {
	foreach ($config as $key => $value) {
	switch ($key) {
	case 'name':
	$this->setFieldName($value);
	break;
	case 'description':
	$this->setFieldDescription($value);
	break;
	case 'strings':
	$this->setStrings($value);
	break;
	case 'caption':
	$this->setCaption($value);
	break;
	case 'required':
	$this->setRequired($value);
	$this->setFieldError(true);
	break;
	case 'default':
	$this->setFieldValue($value);
	break;
	case 'type':
	// We set this earlier on.
	break;
	}
	}
	$this->fieldConfig = $config;
	return $this;
	}

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

	public function setFieldError($field_error) {
	$this->fieldError = $field_error;
	return $this;
	}

	public function getFieldError() {
	return $this->fieldError;
	}

	public function setRequired($required) {
	$this->required = $required;
	return $this;
	}

	public function getRequired() {
	return $this->required;
	}

	public function setRawStandardFieldKey($raw_key) {
	$this->rawKey = $raw_key;
	return $this;
	}

	public function getRawStandardFieldKey() {
	return $this->rawKey;
	}


	/* -( PhabricatorCustomField )--------------------------------------------- */


	public function setFieldKey($field_key) {
	$this->fieldKey = $field_key;
	return $this;
	}

	public function getFieldKey() {
	return $this->fieldKey;
	}

	public function getFieldName() {
	return coalesce($this->fieldName, parent::getFieldName());
	}

	public function getFieldDescription() {
	return coalesce($this->fieldDescription, parent::getFieldDescription());
	}

	public function setStrings(array $strings) {
	$this->strings = $strings;
	return;
	}

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

	public function shouldUseStorage() {
	return true;
	}

	public function getValueForStorage() {
	return $this->getFieldValue();
	}

	public function setValueFromStorage($value) {
	return $this->setFieldValue($value);
	}

	public function shouldAppearInApplicationTransactions() {
	return true;
	}

	public function shouldAppearInEditView() {
	return $this->getFieldConfigValue('edit', true);
	}

	public function readValueFromRequest(AphrontRequest $request) {
	$value = $request->getStr($this->getFieldKey());
	if (!strlen($value)) {
	$value = null;
	}
	$this->setFieldValue($value);
	}

	public function getInstructionsForEdit() {
	return $this->getFieldConfigValue('instructions');
	}

	public function getPlaceholder() {
	return $this->getFieldConfigValue('placeholder', null);
	}

	public function renderEditControl(array $handles) {
	return id(new AphrontFormTextControl())
	->setName($this->getFieldKey())
	->setCaption($this->getCaption())
	->setValue($this->getFieldValue())
	->setError($this->getFieldError())
	->setLabel($this->getFieldName())
	->setPlaceholder($this->getPlaceholder());
	}

	public function newStorageObject() {
	return $this->getApplicationField()->newStorageObject();
	}

	public function shouldAppearInPropertyView() {
	return $this->getFieldConfigValue('view', true);
	}

	public function renderPropertyViewValue(array $handles) {
	if (!strlen($this->getFieldValue())) {
	return null;
	}
	return $this->getFieldValue();
	}

	public function shouldAppearInApplicationSearch() {
	return $this->getFieldConfigValue('search', false);
	}

	protected function newStringIndexStorage() {
	return $this->getApplicationField()->newStringIndexStorage();
	}

	protected function newNumericIndexStorage() {
	return $this->getApplicationField()->newNumericIndexStorage();
	}

	public function buildFieldIndexes() {
	return array();
	}

	+ public function buildOrderIndex() {
	+ return null;
	+ }
	+
	public function readApplicationSearchValueFromRequest(
	PhabricatorApplicationSearchEngine $engine,
	AphrontRequest $request) {
	return;
	}

	public function applyApplicationSearchConstraintToQuery(
	PhabricatorApplicationSearchEngine $engine,
	PhabricatorCursorPagedPolicyAwareQuery $query,
	$value) {
	return;
	}

	public function appendToApplicationSearchForm(
	PhabricatorApplicationSearchEngine $engine,
	AphrontFormView $form,
	$value,
	array $handles) {
	return;
	}

	public function validateApplicationTransactions(
	PhabricatorApplicationTransactionEditor $editor,
	$type,
	array $xactions) {

	$this->setFieldError(null);

	$errors = parent::validateApplicationTransactions(
	$editor,
	$type,
	$xactions);

	if ($this->getRequired()) {
	$value = $this->getOldValueForApplicationTransactions();

	$transaction = null;
	foreach ($xactions as $xaction) {
	$value = $xaction->getNewValue();
	if (!$this->isValueEmpty($value)) {
	$transaction = $xaction;
	break;
	}
	}
	if ($this->isValueEmpty($value)) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Required'),
	pht('%s is required.', $this->getFieldName()),
	$transaction);
	$error->setIsMissingFieldError(true);
	$errors[] = $error;
	$this->setFieldError(pht('Required'));
	}
	}

	return $errors;
	}

	protected function isValueEmpty($value) {
	if (is_array($value)) {
	return empty($value);
	}
	return !strlen($value);
	}

	public function getApplicationTransactionTitle(
	PhabricatorApplicationTransaction $xaction) {
	$author_phid = $xaction->getAuthorPHID();
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	if (!$old) {
	return pht(
	'%s set %s to %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$new);
	} else if (!$new) {
	return pht(
	'%s removed %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName());
	} else {
	return pht(
	'%s changed %s from %s to %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$old,
	$new);
	}
	}

	public function getApplicationTransactionTitleForFeed(
	PhabricatorApplicationTransaction $xaction,
	PhabricatorFeedStory $story) {

	$author_phid = $xaction->getAuthorPHID();
	$object_phid = $xaction->getObjectPHID();

	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	if (!$old) {
	return pht(
	'%s set %s to %s on %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$new,
	$xaction->renderHandleLink($object_phid));
	} else if (!$new) {
	return pht(
	'%s removed %s on %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$xaction->renderHandleLink($object_phid));
	} else {
	return pht(
	'%s changed %s from %s to %s on %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$old,
	$new,
	$xaction->renderHandleLink($object_phid));
	}
	}

	public function getHeraldFieldValue() {
	return $this->getFieldValue();
	}

	public function getFieldControlID($key = null) {
	$key = coalesce($key, $this->getRawStandardFieldKey());
	return 'std:control:'.$key;
	}

	}
	diff --git a/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldBool.php b/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldBool.php
	index cde3beb5d9..a066dcfe34 100644
	--- a/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldBool.php
	+++ b/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldBool.php
	@@ -1,125 +1,129 @@
	<?php

	final class PhabricatorStandardCustomFieldBool
	extends PhabricatorStandardCustomField {

	public function getFieldType() {
	return 'bool';
	}

	public function buildFieldIndexes() {
	$indexes = array();

	$value = $this->getFieldValue();
	if (strlen($value)) {
	$indexes[] = $this->newNumericIndex((int)$value);
	}

	return $indexes;
	}

	+ public function buildOrderIndex() {
	+ return $this->newNumericIndex(0);
	+ }
	+
	public function getValueForStorage() {
	$value = $this->getFieldValue();
	if (strlen($value)) {
	return (int)$value;
	} else {
	return null;
	}
	}

	public function setValueFromStorage($value) {
	if (strlen($value)) {
	$value = (bool)$value;
	} else {
	$value = null;
	}
	return $this->setFieldValue($value);
	}

	public function readApplicationSearchValueFromRequest(
	PhabricatorApplicationSearchEngine $engine,
	AphrontRequest $request) {

	return $request->getStr($this->getFieldKey());
	}

	public function applyApplicationSearchConstraintToQuery(
	PhabricatorApplicationSearchEngine $engine,
	PhabricatorCursorPagedPolicyAwareQuery $query,
	$value) {
	if ($value == 'require') {
	$query->withApplicationSearchContainsConstraint(
	$this->newNumericIndex(null),
	1);
	}
	}

	public function appendToApplicationSearchForm(
	PhabricatorApplicationSearchEngine $engine,
	AphrontFormView $form,
	$value,
	array $handles) {

	$form->appendChild(
	id(new AphrontFormSelectControl())
	->setLabel($this->getFieldName())
	->setName($this->getFieldKey())
	->setValue($value)
	->setOptions(
	array(
	'' => $this->getString('search.default', pht('(Any)')),
	'require' => $this->getString('search.require', pht('Require')),
	)));
	}

	public function renderEditControl(array $handles) {
	return id(new AphrontFormCheckboxControl())
	->setLabel($this->getFieldName())
	->setCaption($this->getCaption())
	->addCheckbox(
	$this->getFieldKey(),
	1,
	$this->getString('edit.checkbox'),
	(bool)$this->getFieldValue());
	}

	public function renderPropertyViewValue(array $handles) {
	$value = $this->getFieldValue();
	if ($value) {
	return $this->getString('view.yes', pht('Yes'));
	} else {
	return null;
	}
	}

	public function getApplicationTransactionTitle(
	PhabricatorApplicationTransaction $xaction) {
	$author_phid = $xaction->getAuthorPHID();
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	if ($new) {
	return pht(
	'%s checked %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName());
	} else {
	return pht(
	'%s unchecked %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName());
	}
	}

	public function shouldAppearInHerald() {
	return true;
	}

	public function getHeraldFieldConditions() {
	return array(
	HeraldAdapter::CONDITION_IS_TRUE,
	HeraldAdapter::CONDITION_IS_FALSE,
	);
	}

	}
	diff --git a/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldDate.php b/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldDate.php
	index 8c2e1e4ad1..f8222d9559 100644
	--- a/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldDate.php
	+++ b/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldDate.php
	@@ -1,191 +1,195 @@
	<?php

	final class PhabricatorStandardCustomFieldDate
	extends PhabricatorStandardCustomField {

	public function getFieldType() {
	return 'date';
	}

	public function buildFieldIndexes() {
	$indexes = array();

	$value = $this->getFieldValue();
	if (strlen($value)) {
	$indexes[] = $this->newNumericIndex((int)$value);
	}

	return $indexes;
	}

	+ public function buildOrderIndex() {
	+ return $this->newNumericIndex(0);
	+ }
	+
	public function getValueForStorage() {
	$value = $this->getFieldValue();
	if (strlen($value)) {
	return (int)$value;
	} else {
	return null;
	}
	}

	public function setValueFromStorage($value) {
	if (strlen($value)) {
	$value = (int)$value;
	} else {
	$value = null;
	}
	return $this->setFieldValue($value);
	}

	public function renderEditControl(array $handles) {
	return $this->newDateControl();
	}

	public function readValueFromRequest(AphrontRequest $request) {
	$control = $this->newDateControl();
	$control->setUser($request->getUser());
	$value = $control->readValueFromRequest($request);

	$this->setFieldValue($value);
	}

	public function renderPropertyViewValue(array $handles) {
	$value = $this->getFieldValue();
	if (!$value) {
	return null;
	}

	return phabricator_datetime($value, $this->getViewer());
	}

	private function newDateControl() {
	$control = id(new AphrontFormDateControl())
	->setLabel($this->getFieldName())
	->setName($this->getFieldKey())
	->setUser($this->getViewer())
	->setCaption($this->getCaption())
	->setAllowNull(!$this->getRequired());

	// If the value is already numeric, treat it as an epoch timestamp and set
	// it directly. Otherwise, it's likely a field default, which we let users
	// specify as a string. Parse the string into an epoch.

	$value = $this->getFieldValue();
	if (!ctype_digit($value)) {
	$value = PhabricatorTime::parseLocalTime($value, $this->getViewer());
	}

	// If we don't have anything valid, make sure we pass `null`, since the
	// control special-cases that.
	$control->setValue(nonempty($value, null));

	return $control;
	}

	public function readApplicationSearchValueFromRequest(
	PhabricatorApplicationSearchEngine $engine,
	AphrontRequest $request) {

	$key = $this->getFieldKey();

	return array(
	'min' => $request->getStr($key.'.min'),
	'max' => $request->getStr($key.'.max'),
	);
	}

	public function applyApplicationSearchConstraintToQuery(
	PhabricatorApplicationSearchEngine $engine,
	PhabricatorCursorPagedPolicyAwareQuery $query,
	$value) {

	$viewer = $this->getViewer();

	if (!is_array($value)) {
	$value = array();
	}

	$min_str = idx($value, 'min', '');
	if (strlen($min_str)) {
	$min = PhabricatorTime::parseLocalTime($min_str, $viewer);
	} else {
	$min = null;
	}

	$max_str = idx($value, 'max', '');
	if (strlen($max_str)) {
	$max = PhabricatorTime::parseLocalTime($max_str, $viewer);
	} else {
	$max = null;
	}

	if (($min !== null) \|\| ($max !== null)) {
	$query->withApplicationSearchRangeConstraint(
	$this->newNumericIndex(null),
	$min,
	$max);
	}
	}

	public function appendToApplicationSearchForm(
	PhabricatorApplicationSearchEngine $engine,
	AphrontFormView $form,
	$value,
	array $handles) {

	if (!is_array($value)) {
	$value = array();
	}

	$form
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('%s After', $this->getFieldName()))
	->setName($this->getFieldKey().'.min')
	->setValue(idx($value, 'min', '')))
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('%s Before', $this->getFieldName()))
	->setName($this->getFieldKey().'.max')
	->setValue(idx($value, 'max', '')));
	}

	public function getApplicationTransactionTitle(
	PhabricatorApplicationTransaction $xaction) {
	$author_phid = $xaction->getAuthorPHID();
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	$viewer = $this->getViewer();

	$old_date = null;
	if ($old) {
	$old_date = phabricator_datetime($old, $viewer);
	}

	$new_date = null;
	if ($new) {
	$new_date = phabricator_datetime($new, $viewer);
	}

	if (!$old) {
	return pht(
	'%s set %s to %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$new_date);
	} else if (!$new) {
	return pht(
	'%s removed %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName());
	} else {
	return pht(
	'%s changed %s from %s to %s.',
	$xaction->renderHandleLink($author_phid),
	$this->getFieldName(),
	$old_date,
	$new_date);
	}
	}

	}
	diff --git a/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldInt.php b/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldInt.php
	index aafa30ea99..94a24d01b0 100644
	--- a/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldInt.php
	+++ b/src/infrastructure/customfield/standard/PhabricatorStandardCustomFieldInt.php
	@@ -1,113 +1,117 @@
	<?php

	final class PhabricatorStandardCustomFieldInt
	extends PhabricatorStandardCustomField {

	public function getFieldType() {
	return 'int';
	}

	public function buildFieldIndexes() {
	$indexes = array();

	$value = $this->getFieldValue();
	if (strlen($value)) {
	$indexes[] = $this->newNumericIndex((int)$value);
	}

	return $indexes;
	}

	+ public function buildOrderIndex() {
	+ return $this->newNumericIndex(0);
	+ }
	+
	public function getValueForStorage() {
	$value = $this->getFieldValue();
	if (strlen($value)) {
	return $value;
	} else {
	return null;
	}
	}

	public function setValueFromStorage($value) {
	if (strlen($value)) {
	$value = (int)$value;
	} else {
	$value = null;
	}
	return $this->setFieldValue($value);
	}

	public function readApplicationSearchValueFromRequest(
	PhabricatorApplicationSearchEngine $engine,
	AphrontRequest $request) {

	return $request->getStr($this->getFieldKey());
	}

	public function applyApplicationSearchConstraintToQuery(
	PhabricatorApplicationSearchEngine $engine,
	PhabricatorCursorPagedPolicyAwareQuery $query,
	$value) {

	if (strlen($value)) {
	$query->withApplicationSearchContainsConstraint(
	$this->newNumericIndex(null),
	$value);
	}
	}

	public function appendToApplicationSearchForm(
	PhabricatorApplicationSearchEngine $engine,
	AphrontFormView $form,
	$value,
	array $handles) {

	$form->appendChild(
	id(new AphrontFormTextControl())
	->setLabel($this->getFieldName())
	->setName($this->getFieldKey())
	->setValue($value));
	}

	public function validateApplicationTransactions(
	PhabricatorApplicationTransactionEditor $editor,
	$type,
	array $xactions) {

	$errors = parent::validateApplicationTransactions(
	$editor,
	$type,
	$xactions);

	foreach ($xactions as $xaction) {
	$value = $xaction->getNewValue();
	if (strlen($value)) {
	if (!preg_match('/^-?\d+/', $value)) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('%s must be an integer.', $this->getFieldName()),
	$xaction);
	$this->setFieldError(pht('Invalid'));
	}
	}
	}

	return $errors;
	}

	public function getApplicationTransactionHasEffect(
	PhabricatorApplicationTransaction $xaction) {

	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();
	if (!strlen($old) && strlen($new)) {
	return true;
	} else if (strlen($old) && !strlen($new)) {
	return true;
	} else {
	return ((int)$old !== (int)$new);
	}
	}


	}
	diff --git a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	index ef5ab3839e..e4be99cbd4 100644
	--- a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	+++ b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	@@ -1,541 +1,633 @@
	<?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
	*/
	abstract class PhabricatorCursorPagedPolicyAwareQuery
	extends PhabricatorPolicyAwareQuery {

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

	protected function getPagingColumn() {
	return 'id';
	}

	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 getReversePaging() {
	return false;
	}

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

	protected function buildPagingClause(
	AphrontDatabaseConnection $conn_r) {

	if ($this->beforeID) {
	return qsprintf(
	$conn_r,
	'%Q %Q %s',
	$this->getPagingColumn(),
	$this->getReversePaging() ? '<' : '>',
	$this->beforeID);
	} else if ($this->afterID) {
	return qsprintf(
	$conn_r,
	'%Q %Q %s',
	$this->getPagingColumn(),
	$this->getReversePaging() ? '>' : '<',
	$this->afterID);
	}

	return null;
	}

	final protected function buildOrderClause(AphrontDatabaseConnection $conn_r) {
	if ($this->beforeID) {
	return qsprintf(
	$conn_r,
	'ORDER BY %Q %Q',
	$this->getPagingColumn(),
	$this->getReversePaging() ? 'DESC' : 'ASC');
	} else {
	return qsprintf(
	$conn_r,
	'ORDER BY %Q %Q',
	$this->getPagingColumn(),
	$this->getReversePaging() ? 'ASC' : 'DESC');
	}
	}

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


	/**
	* 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(
	* 'name' => 'title',
	* 'type' => 'string',
	* 'value' => $cursor->getTitle(),
	* 'reverse' => true,
	* ),
	* array(
	* 'name' => '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(
	'name' => 'string',
	'value' => 'wild',
	'type' => 'string',
	'reverse' => 'optional bool',
	));
	}

	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) {
	$name = $column['name'];

	$type = $column['type'];
	switch ($type) {
	case 'int':
	$value = qsprintf($conn, '%d', $column['value']);
	break;
	case 'string':
	$value = qsprintf($conn, '%s', $column['value']);
	break;
	default:
	throw new Exception("Unknown column type '{$type}'!");
	}

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

	$clause = $accumulated;
	$clause[] = qsprintf(
	$conn,
	'%Q %Q %Q',
	$name,
	$reverse ? '>' : '<',
	$value);
	$clauses[] = '('.implode(') AND (', $clause).')';

	$accumulated[] = qsprintf(
	$conn,
	'%Q = %Q',
	$name,
	$value);
	}

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


	/* -( 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 if the
	* query construction requires a table alias it may be something like
	* `"task.phid"`.
	*
	* @return string Column name.
	* @task appsearch
	*/
	protected function getApplicationSearchObjectPHIDColumn() {
	return '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'];
	+ $alias = 'appsearch_order_'.$key;
	+ $index = $order['index'];
	+ $phid_column = $this->getApplicationSearchObjectPHIDColumn();
	+
	+ $joins[] = qsprintf(
	+ $conn_r,
	+ 'JOIN %T %T ON %T.objectPHID = %Q
	+ AND %T.indexKey = %s',
	+ $table,
	+ $alias,
	+ $alias,
	+ $phid_column,
	+ $alias,
	+ $index);
	+ }
	+
	return implode(' ', $joins);
	}

	+ protected function buildApplicationSearchOrders(
	+ AphrontDatabaseConnection $conn_r,
	+ $reverse) {
	+
	+ $orders = array();
	+ foreach ($this->applicationSearchOrders as $key => $order) {
	+ $alias = 'appsearch_order_'.$key;
	+
	+ if ($order['ascending'] xor $reverse) {
	+ $orders[] = qsprintf($conn_r, '%T.indexValue ASC', $alias);
	+ } else {
	+ $orders[] = qsprintf($conn_r, '%T.indexValue DESC', $alias);
	+ }
	+ }
	+
	+ return $orders;
	+ }
	+
	+ protected function buildApplicationSearchPagination(
	+ AphrontDatabaseConnection $conn_r,
	+ $cursor) {
	+
	+ // We have to get the current field values on the cursor object.
	+ $fields = PhabricatorCustomField::getObjectFields(
	+ $cursor,
	+ PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	+ $fields->setViewer($this->getViewer());
	+ $fields->readFieldsFromStorage($cursor);
	+
	+ $fields = mpull($fields->getFields(), null, 'getFieldKey');
	+
	+ $columns = array();
	+ foreach ($this->applicationSearchOrders as $key => $order) {
	+ $alias = 'appsearch_order_'.$key;
	+
	+ $field = idx($fields, $order['key']);
	+
	+ $columns[] = array(
	+ 'name' => $alias.'.indexValue',
	+ 'value' => $field->getValueForStorage(),
	+ 'type' => $order['type'],
	+ );
	+ }
	+
	+ return $columns;
	+ }
	+
	}

File Metadata

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

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions