ManiphestTaskQuery.php
b2d63d009cd2stable

ManiphestTaskQuery.php
View Options

			<?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;
			private $taskPHIDs;
			private $authorPHIDs;
			private $ownerPHIDs;
			private $noOwner;
			private $anyOwner;
			private $subscriberPHIDs;
			private $dateCreatedAfter;
			private $dateCreatedBefore;
			private $dateModifiedAfter;
			private $dateModifiedBefore;
			private $bridgedObjectPHIDs;
			private $hasOpenParents;
			private $hasOpenSubtasks;
			private $parentTaskIDs;
			private $subtaskIDs;
			private $subtypes;
			private $closedEpochMin;
			private $closedEpochMax;
			private $closerPHIDs;
			private $columnPHIDs;
			private $specificGroupByProjectPHID;

			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 $subpriorities;

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

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

			private $needSubscriberPHIDs;
			private $needProjectPHIDs;

			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) {
			if ($owners === array()) {
			throw new Exception(pht('Empty withOwners() constraint is not valid.'));
			}

			$no_owner = PhabricatorPeopleNoOwnerDatasource::FUNCTION_TOKEN;
			$any_owner = PhabricatorPeopleAnyOwnerDatasource::FUNCTION_TOKEN;

			foreach ($owners as $k => $phid) {
			if ($phid === $no_owner \|\| $phid === null) {
			$this->noOwner = true;
			unset($owners[$k]);
			break;
			}
			if ($phid === $any_owner) {
			$this->anyOwner = true;
			unset($owners[$k]);
			break;
			}
			}

			if ($owners) {
			$this->ownerPHIDs = $owners;
			}

			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 withSubpriorities(array $subpriorities) {
			$this->subpriorities = $subpriorities;
			return $this;
			}

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

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

			switch ($this->groupBy) {
			case self::GROUP_NONE:
			$vector = array();
			break;
			case self::GROUP_PRIORITY:
			$vector = array('priority');
			break;
			case self::GROUP_OWNER:
			$vector = array('owner');
			break;
			case self::GROUP_STATUS:
			$vector = array('status');
			break;
			case self::GROUP_PROJECT:
			$vector = array('project');
			break;
			}

			$this->setGroupVector($vector);

			return $this;
			}

			public function withOpenSubtasks($value) {
			$this->hasOpenSubtasks = $value;
			return $this;
			}

			public function withOpenParents($value) {
			$this->hasOpenParents = $value;
			return $this;
			}

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

			public function withSubtaskIDs(array $ids) {
			$this->subtaskIDs = $ids;
			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 withClosedEpochBetween($min, $max) {
			$this->closedEpochMin = $min;
			$this->closedEpochMax = $max;
			return $this;
			}

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

			public function needSubscriberPHIDs($bool) {
			$this->needSubscriberPHIDs = $bool;
			return $this;
			}

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

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

			public function withSubtypes(array $subtypes) {
			$this->subtypes = $subtypes;
			return $this;
			}

			public function withColumnPHIDs(array $column_phids) {
			$this->columnPHIDs = $column_phids;
			return $this;
			}

			public function withSpecificGroupByProjectPHID($project_phid) {
			$this->specificGroupByProjectPHID = $project_phid;
			return $this;
			}

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

			protected function loadPage() {
			$task_dao = new ManiphestTask();
			$conn = $task_dao->establishConnection('r');

			$where = $this->buildWhereClause($conn);

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

			$rows = queryfx_all(
			$conn,
			'%Q %Q FROM %T task %Q %Q %Q %Q %Q %Q',
			$this->buildSelectClause($conn),
			$group_column,
			$task_dao->getTableName(),
			$this->buildJoinClause($conn),
			$where,
			$this->buildGroupClause($conn),
			$this->buildHavingClause($conn),
			$this->buildOrderClause($conn),
			$this->buildLimitClause($conn));

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

			$data = $this->didLoadRawRows($data);
			$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 tagged with any projects, or only tagged
			// with 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) {
			$phids = mpull($tasks, 'getPHID');

			if ($this->needProjectPHIDs) {
			$edge_query = id(new PhabricatorEdgeQuery())
			->withSourcePHIDs($phids)
			->withEdgeTypes(
			array(
			PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
			));
			$edge_query->execute();

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

			if ($this->needSubscriberPHIDs) {
			$subscriber_sets = id(new PhabricatorSubscribersQuery())
			->withObjectPHIDs($phids)
			->execute();
			foreach ($tasks as $task) {
			$subscribers = idx($subscriber_sets, $task->getPHID(), array());
			$task->attachSubscriberPHIDs($subscribers);
			}
			}

			return $tasks;
			}

			protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
			$where = parent::buildWhereClauseParts($conn);

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

			if ($this->taskIDs !== null) {
			$where[] = qsprintf(
			$conn,
			'task.id in (%Ld)',
			$this->taskIDs);
			}

			if ($this->taskPHIDs !== null) {
			$where[] = qsprintf(
			$conn,
			'task.phid in (%Ls)',
			$this->taskPHIDs);
			}

			if ($this->statuses !== null) {
			$where[] = qsprintf(
			$conn,
			'task.status IN (%Ls)',
			$this->statuses);
			}

			if ($this->authorPHIDs !== null) {
			$where[] = qsprintf(
			$conn,
			'task.authorPHID in (%Ls)',
			$this->authorPHIDs);
			}

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

			if ($this->closedEpochMin !== null) {
			$where[] = qsprintf(
			$conn,
			'task.closedEpoch >= %d',
			$this->closedEpochMin);
			}

			if ($this->closedEpochMax !== null) {
			$where[] = qsprintf(
			$conn,
			'task.closedEpoch <= %d',
			$this->closedEpochMax);
			}

			if ($this->closerPHIDs !== null) {
			$where[] = qsprintf(
			$conn,
			'task.closerPHID IN (%Ls)',
			$this->closerPHIDs);
			}

			if ($this->priorities !== null) {
			$where[] = qsprintf(
			$conn,
			'task.priority IN (%Ld)',
			$this->priorities);
			}

			if ($this->bridgedObjectPHIDs !== null) {
			$where[] = qsprintf(
			$conn,
			'task.bridgedObjectPHID IN (%Ls)',
			$this->bridgedObjectPHIDs);
			}

			if ($this->subtypes !== null) {
			$where[] = qsprintf(
			$conn,
			'task.subtype IN (%Ls)',
			$this->subtypes);
			}


			if ($this->columnPHIDs !== null) {
			$viewer = $this->getViewer();

			$columns = id(new PhabricatorProjectColumnQuery())
			->setParentQuery($this)
			->setViewer($viewer)
			->withPHIDs($this->columnPHIDs)
			->execute();
			if (!$columns) {
			throw new PhabricatorEmptyQueryException();
			}

			// We must do board layout before we move forward because the column
			// positions may not yet exist otherwise. An example is that newly
			// created tasks may not yet be positioned in the backlog column.

			$projects = mpull($columns, 'getProject');
			$projects = mpull($projects, null, 'getPHID');

			// The board layout engine needs to know about every object that it's
			// going to be asked to do layout for. For now, we're just doing layout
			// on every object on the boards. In the future, we could do layout on a
			// smaller set of objects by using the constraints on this Query. For
			// example, if the caller is only asking for open tasks, we only need
			// to do layout on open tasks.

			// This fetches too many objects (every type of object tagged with the
			// project, not just tasks). We could narrow it by querying the edge
			// table on the Maniphest side, but there's currently no way to build
			// that query with EdgeQuery.
			$edge_query = id(new PhabricatorEdgeQuery())
			->withSourcePHIDs(array_keys($projects))
			->withEdgeTypes(
			array(
			PhabricatorProjectProjectHasObjectEdgeType::EDGECONST,
			));

			$edge_query->execute();
			$all_phids = $edge_query->getDestinationPHIDs();

			// Since we overfetched PHIDs, filter out any non-tasks we got back.
			foreach ($all_phids as $key => $phid) {
			if (phid_get_type($phid) !== ManiphestTaskPHIDType::TYPECONST) {
			unset($all_phids[$key]);
			}
			}

			// If there are no tasks on the relevant boards, this query can't
			// possibly hit anything so we're all done.
			$task_phids = array_fuse($all_phids);
			if (!$task_phids) {
			throw new PhabricatorEmptyQueryException();
			}

			// We know everything we need to know, so perform board layout.
			$engine = id(new PhabricatorBoardLayoutEngine())
			->setViewer($viewer)
			->setFetchAllBoards(true)
			->setBoardPHIDs(array_keys($projects))
			->setObjectPHIDs($task_phids)
			->executeLayout();

			// Find the tasks that are in the constraint columns after board layout
			// completes.
			$select_phids = array();
			foreach ($columns as $column) {
			$in_column = $engine->getColumnObjectPHIDs(
			$column->getProjectPHID(),
			$column->getPHID());
			foreach ($in_column as $phid) {
			$select_phids[$phid] = $phid;
			}
			}

			if (!$select_phids) {
			throw new PhabricatorEmptyQueryException();
			}

			$where[] = qsprintf(
			$conn,
			'task.phid IN (%Ls)',
			$select_phids);
			}

			if ($this->specificGroupByProjectPHID !== null) {
			$where[] = qsprintf(
			$conn,
			'projectGroupName.indexedObjectPHID = %s',
			$this->specificGroupByProjectPHID);
			}

			return $where;
			}

			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,
			'task.status IN (%Ls)',
			ManiphestTaskStatus::getOpenStatusConstants());
			case self::STATUS_CLOSED:
			return qsprintf(
			$conn,
			'task.status IN (%Ls)',
			ManiphestTaskStatus::getClosedStatusConstants());
			default:
			$constant = idx($map, $this->status);
			if (!$constant) {
			throw new Exception(pht("Unknown status query '%s'!", $this->status));
			}
			return qsprintf(
			$conn,
			'task.status = %s',
			$constant);
			}
			}

			private function buildOwnerWhereClause(AphrontDatabaseConnection $conn) {
			$subclause = array();

			if ($this->noOwner) {
			$subclause[] = qsprintf(
			$conn,
			'task.ownerPHID IS NULL');
			}

			if ($this->anyOwner) {
			$subclause[] = qsprintf(
			$conn,
			'task.ownerPHID IS NOT NULL');
			}

			if ($this->ownerPHIDs !== null) {
			$subclause[] = qsprintf(
			$conn,
			'task.ownerPHID IN (%Ls)',
			$this->ownerPHIDs);
			}

			if (!$subclause) {
			return qsprintf($conn, '');
			}

			return qsprintf($conn, '%LO', $subclause);
			}

			protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
			$open_statuses = ManiphestTaskStatus::getOpenStatusConstants();
			$edge_table = PhabricatorEdgeConfig::TABLE_NAME_EDGE;
			$task_table = $this->newResultObject()->getTableName();

			$parent_type = ManiphestTaskDependedOnByTaskEdgeType::EDGECONST;
			$subtask_type = ManiphestTaskDependsOnTaskEdgeType::EDGECONST;

			$joins = array();
			if ($this->hasOpenParents !== null) {
			if ($this->hasOpenParents) {
			$join_type = qsprintf($conn, 'JOIN');
			} else {
			$join_type = qsprintf($conn, 'LEFT JOIN');
			}

			$joins[] = qsprintf(
			$conn,
			'%Q %T e_parent
			ON e_parent.src = task.phid
			AND e_parent.type = %d
			%Q %T parent
			ON e_parent.dst = parent.phid
			AND parent.status IN (%Ls)',
			$join_type,
			$edge_table,
			$parent_type,
			$join_type,
			$task_table,
			$open_statuses);
			}

			if ($this->hasOpenSubtasks !== null) {
			if ($this->hasOpenSubtasks) {
			$join_type = qsprintf($conn, 'JOIN');
			} else {
			$join_type = qsprintf($conn, 'LEFT JOIN');
			}

			$joins[] = qsprintf(
			$conn,
			'%Q %T e_subtask
			ON e_subtask.src = task.phid
			AND e_subtask.type = %d
			%Q %T subtask
			ON e_subtask.dst = subtask.phid
			AND subtask.status IN (%Ls)',
			$join_type,
			$edge_table,
			$subtask_type,
			$join_type,
			$task_table,
			$open_statuses);
			}

			if ($this->subscriberPHIDs !== null) {
			$joins[] = qsprintf(
			$conn,
			'JOIN %T e_ccs ON e_ccs.src = task.phid '.
			'AND e_ccs.type = %s '.
			'AND e_ccs.dst in (%Ls)',
			PhabricatorEdgeConfig::TABLE_NAME_EDGE,
			PhabricatorObjectHasSubscriberEdgeType::EDGECONST,
			$this->subscriberPHIDs);
			}

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

			if ($this->parentTaskIDs !== null) {
			$joins[] = qsprintf(
			$conn,
			'JOIN %T e_has_parent
			ON e_has_parent.src = task.phid
			AND e_has_parent.type = %d
			JOIN %T has_parent
			ON e_has_parent.dst = has_parent.phid
			AND has_parent.id IN (%Ld)',
			$edge_table,
			$parent_type,
			$task_table,
			$this->parentTaskIDs);
			}

			if ($this->subtaskIDs !== null) {
			$joins[] = qsprintf(
			$conn,
			'JOIN %T e_has_subtask
			ON e_has_subtask.src = task.phid
			AND e_has_subtask.type = %d
			JOIN %T has_subtask
			ON e_has_subtask.dst = has_subtask.phid
			AND has_subtask.id IN (%Ld)',
			$edge_table,
			$subtask_type,
			$task_table,
			$this->subtaskIDs);
			}

			$joins[] = parent::buildJoinClauseParts($conn);

			return $joins;
			}

			protected function buildGroupClause(AphrontDatabaseConnection $conn) {
			$joined_multiple_rows =
			($this->hasOpenParents !== null) \|\|
			($this->hasOpenSubtasks !== null) \|\|
			($this->parentTaskIDs !== null) \|\|
			($this->subtaskIDs !== null) \|\|
			$this->shouldGroupQueryResultRows();

			$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 qsprintf($conn, 'GROUP BY task.phid, projectGroup.dst');
			} else {
			return qsprintf($conn, 'GROUP BY task.phid');
			}
			}

			return qsprintf($conn, '');
			}


			protected function buildHavingClauseParts(AphrontDatabaseConnection $conn) {
			$having = parent::buildHavingClauseParts($conn);

			if ($this->hasOpenParents !== null) {
			if (!$this->hasOpenParents) {
			$having[] = qsprintf(
			$conn,
			'COUNT(parent.phid) = 0');
			}
			}

			if ($this->hasOpenSubtasks !== null) {
			if (!$this->hasOpenSubtasks) {
			$having[] = qsprintf(
			$conn,
			'COUNT(subtask.phid) = 0');
			}
			}

			return $having;
			}


			/**
			* Return project PHIDs which we should ignore when grouping tasks by
			* project. For example, if a user issues a query like:
			*
			* Tasks tagged with 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 tagged with 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() {
			// Maybe we should also exclude the "OPERATOR_NOT" PHIDs? 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.

			$edge_types = array(
			PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
			);

			$phids = array();

			$phids[] = $this->getEdgeLogicValues(
			$edge_types,
			array(
			PhabricatorQueryConstraint::OPERATOR_AND,
			));

			$any = $this->getEdgeLogicValues(
			$edge_types,
			array(
			PhabricatorQueryConstraint::OPERATOR_OR,
			));
			if (count($any) == 1) {
			$phids[] = $any;
			}

			return array_mergev($phids);
			}

			public function getBuiltinOrders() {
			$orders = array(
			'priority' => array(
			'vector' => array('priority', 'id'),
			'name' => pht('Priority'),
			'aliases' => array(self::ORDER_PRIORITY),
			),
			'updated' => array(
			'vector' => array('updated', 'id'),
			'name' => pht('Date Updated (Latest First)'),
			'aliases' => array(self::ORDER_MODIFIED),
			),
			'outdated' => array(
			'vector' => array('-updated', '-id'),
			'name' => pht('Date Updated (Oldest First)'),
			),
			'closed' => array(
			'vector' => array('closed', 'id'),
			'name' => pht('Date Closed (Latest First)'),
			),
			'title' => array(
			'vector' => array('title', 'id'),
			'name' => pht('Title'),
			'aliases' => array(self::ORDER_TITLE),
			),
			) + parent::getBuiltinOrders();

			// Alias the "newest" builtin to the historical key for it.
			$orders['newest']['aliases'][] = self::ORDER_CREATED;

			$orders = array_select_keys(
			$orders,
			array(
			'priority',
			'updated',
			'outdated',
			'newest',
			'oldest',
			'closed',
			'title',
			)) + $orders;

			return $orders;
			}

			public function getOrderableColumns() {
			return parent::getOrderableColumns() + array(
			'priority' => array(
			'table' => 'task',
			'column' => 'priority',
			'type' => 'int',
			),
			'owner' => array(
			'table' => 'task',
			'column' => 'ownerOrdering',
			'null' => 'head',
			'reverse' => true,
			'type' => 'string',
			),
			'status' => array(
			'table' => 'task',
			'column' => 'status',
			'type' => 'string',
			'reverse' => true,
			),
			'project' => array(
			'table' => 'projectGroupName',
			'column' => 'indexedObjectName',
			'type' => 'string',
			'null' => 'head',
			'reverse' => true,
			),
			'title' => array(
			'table' => 'task',
			'column' => 'title',
			'type' => 'string',
			'reverse' => true,
			),
			'updated' => array(
			'table' => 'task',
			'column' => 'dateModified',
			'type' => 'int',
			),
			'closed' => array(
			'table' => 'task',
			'column' => 'closedEpoch',
			'type' => 'int',
			'null' => 'tail',
			),
			);
			}

			protected function newPagingMapFromCursorObject(
			PhabricatorQueryCursor $cursor,
			array $keys) {

			$task = $cursor->getObject();

			$map = array(
			'id' => (int)$task->getID(),
			'priority' => (int)$task->getPriority(),
			'owner' => $task->getOwnerOrdering(),
			'status' => $task->getStatus(),
			'title' => $task->getTitle(),
			'updated' => (int)$task->getDateModified(),
			'closed' => $task->getClosedEpoch(),
			);

			if (isset($keys['project'])) {
			$value = null;

			$group_phid = $task->getGroupByProjectPHID();
			if ($group_phid) {
			$paging_projects = id(new PhabricatorProjectQuery())
			->setViewer($this->getViewer())
			->withPHIDs(array($group_phid))
			->execute();
			if ($paging_projects) {
			$value = head($paging_projects)->getName();
			}
			}

			$map['project'] = $value;
			}

			foreach ($keys as $key) {
			if ($this->isCustomFieldOrderKey($key)) {
			$map += $this->getPagingValueMapForCustomFields($task);
			break;
			}
			}

			return $map;
			}

			protected function newExternalCursorStringForResult($object) {
			$id = $object->getID();

			if ($this->groupBy == self::GROUP_PROJECT) {
			return rtrim($id.'.'.$object->getGroupByProjectPHID(), '.');
			}

			return $id;
			}

			protected function newInternalCursorFromExternalCursor($cursor) {
			list($task_id, $group_phid) = $this->parseCursor($cursor);

			$cursor_object = parent::newInternalCursorFromExternalCursor($cursor);

			if ($group_phid !== null) {
			$project = id(new PhabricatorProjectQuery())
			->setViewer($this->getViewer())
			->withPHIDs(array($group_phid))
			->execute();

			if (!$project) {
			$this->throwCursorException(
			pht(
			'Group PHID ("%s") component of cursor ("%s") is not valid.',
			$group_phid,
			$cursor));
			}

			$cursor_object->getObject()->attachGroupByProjectPHID($group_phid);
			}

			return $cursor_object;
			}

			protected function applyExternalCursorConstraintsToQuery(
			PhabricatorCursorPagedPolicyAwareQuery $subquery,
			$cursor) {
			list($task_id, $group_phid) = $this->parseCursor($cursor);

			$subquery->withIDs(array($task_id));

			if ($group_phid) {
			$subquery->setGroupBy(self::GROUP_PROJECT);

			// The subquery needs to return exactly one result. If a task is in
			// several projects, the query may naturally return several results.
			// Specify that we want only the particular instance of the task in
			// the specified project.
			$subquery->withSpecificGroupByProjectPHID($group_phid);
			}
			}


			private function parseCursor($cursor) {
			// Split a "123.PHID-PROJ-abcd" cursor into a "Task ID" part and a
			// "Project PHID" part.

			$parts = explode('.', $cursor, 2);

			if (count($parts) < 2) {
			$parts[] = null;
			}

			if (!strlen($parts[1])) {
			$parts[1] = null;
			}

			return $parts;
			}

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

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

			}

phab/src/applications/maniphest/query/ManiphestTaskQuery.phpb2d63d009cd2stable

ManiphestTaskQuery.phpView Options

phab/src/applications/maniphest/query/ManiphestTaskQuery.php
b2d63d009cd2stable

ManiphestTaskQuery.php
View Options