No OneTemporary
Actions

Size

54 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	index 0b733baf27..abc83369bf 100644
	--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	@@ -1,731 +1,742 @@
	<?php

	final class ManiphestTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

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

	public function getEditorObjectsDescription() {
	return pht('Maniphest Tasks');
	}

	public function getTransactionTypes() {
	$types = parent::getTransactionTypes();

	$types[] = PhabricatorTransactions::TYPE_COMMENT;
	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = ManiphestTransaction::TYPE_PRIORITY;
	$types[] = ManiphestTransaction::TYPE_STATUS;
	$types[] = ManiphestTransaction::TYPE_TITLE;
	$types[] = ManiphestTransaction::TYPE_DESCRIPTION;
	$types[] = ManiphestTransaction::TYPE_OWNER;
	$types[] = ManiphestTransaction::TYPE_SUBPRIORITY;
	$types[] = ManiphestTransaction::TYPE_PROJECT_COLUMN;
	$types[] = ManiphestTransaction::TYPE_MERGED_INTO;
	$types[] = ManiphestTransaction::TYPE_MERGED_FROM;
	$types[] = ManiphestTransaction::TYPE_UNBLOCK;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;

	return $types;
	}

	protected function getCustomTransactionOldValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PRIORITY:
	if ($this->getIsNewObject()) {
	return null;
	}
	return (int)$object->getPriority();
	case ManiphestTransaction::TYPE_STATUS:
	if ($this->getIsNewObject()) {
	return null;
	}
	return $object->getStatus();
	case ManiphestTransaction::TYPE_TITLE:
	if ($this->getIsNewObject()) {
	return null;
	}
	return $object->getTitle();
	case ManiphestTransaction::TYPE_DESCRIPTION:
	if ($this->getIsNewObject()) {
	return null;
	}
	return $object->getDescription();
	case ManiphestTransaction::TYPE_OWNER:
	return nonempty($object->getOwnerPHID(), null);
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	// These are pre-populated.
	return $xaction->getOldValue();
	case ManiphestTransaction::TYPE_SUBPRIORITY:
	return $object->getSubpriority();
	case ManiphestTransaction::TYPE_MERGED_INTO:
	case ManiphestTransaction::TYPE_MERGED_FROM:
	return null;
	}
	}

	protected function getCustomTransactionNewValue(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PRIORITY:
	return (int)$xaction->getNewValue();
	case ManiphestTransaction::TYPE_OWNER:
	return nonempty($xaction->getNewValue(), null);
	case ManiphestTransaction::TYPE_STATUS:
	case ManiphestTransaction::TYPE_TITLE:
	case ManiphestTransaction::TYPE_DESCRIPTION:
	case ManiphestTransaction::TYPE_SUBPRIORITY:
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	case ManiphestTransaction::TYPE_MERGED_INTO:
	case ManiphestTransaction::TYPE_MERGED_FROM:
	case ManiphestTransaction::TYPE_UNBLOCK:
	return $xaction->getNewValue();
	}
	}

	protected function transactionHasEffect(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

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

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	$new_column_phids = $new['columnPHIDs'];
	$old_column_phids = $old['columnPHIDs'];
	sort($new_column_phids);
	sort($old_column_phids);
	return ($old !== $new);
	}

	return parent::transactionHasEffect($object, $xaction);
	}

	protected function applyCustomInternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PRIORITY:
	return $object->setPriority($xaction->getNewValue());
	case ManiphestTransaction::TYPE_STATUS:
	return $object->setStatus($xaction->getNewValue());
	case ManiphestTransaction::TYPE_TITLE:
	return $object->setTitle($xaction->getNewValue());
	case ManiphestTransaction::TYPE_DESCRIPTION:
	return $object->setDescription($xaction->getNewValue());
	case ManiphestTransaction::TYPE_OWNER:
	$phid = $xaction->getNewValue();

	// Update the "ownerOrdering" column to contain the full name of the
	// owner, if the task is assigned.

	$handle = null;
	if ($phid) {
	$handle = id(new PhabricatorHandleQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($phid))
	->executeOne();
	}

	if ($handle) {
	$object->setOwnerOrdering($handle->getName());
	} else {
	$object->setOwnerOrdering(null);
	}

	return $object->setOwnerPHID($phid);
	case ManiphestTransaction::TYPE_SUBPRIORITY:
	$object->setSubpriority($xaction->getNewValue());
	return;
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	// these do external (edge) updates
	return;
	case ManiphestTransaction::TYPE_MERGED_INTO:
	$object->setStatus(ManiphestTaskStatus::getDuplicateStatus());
	return;
	case ManiphestTransaction::TYPE_MERGED_FROM:
	return;
	}
	}

	protected function applyCustomExternalTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	$board_phid = idx($xaction->getNewValue(), 'projectPHID');
	if (!$board_phid) {
	throw new Exception(
	pht("Expected 'projectPHID' in column transaction."));
	}

	$old_phids = idx($xaction->getOldValue(), 'columnPHIDs', array());
	$new_phids = idx($xaction->getNewValue(), 'columnPHIDs', array());
	if (count($new_phids) !== 1) {
	throw new Exception(
	pht("Expected exactly one 'columnPHIDs' in column transaction."));
	}

	$columns = id(new PhabricatorProjectColumnQuery())
	->setViewer($this->requireActor())
	->withPHIDs($new_phids)
	->execute();
	$columns = mpull($columns, null, 'getPHID');

	$positions = id(new PhabricatorProjectColumnPositionQuery())
	->setViewer($this->requireActor())
	->withObjectPHIDs(array($object->getPHID()))
	->withBoardPHIDs(array($board_phid))
	->execute();

	$before_phid = idx($xaction->getNewValue(), 'beforePHID');
	$after_phid = idx($xaction->getNewValue(), 'afterPHID');

	if (!$before_phid && !$after_phid && ($old_phids == $new_phids)) {
	// If we are not moving the object between columns and also not
	// reordering the position, this is a move on some other order
	// (like priority). We can leave the positions untouched and just
	// bail, there's no work to be done.
	return;
	}

	// Otherwise, we're either moving between columns or adjusting the
	// object's position in the "natural" ordering, so we do need to update
	// some rows.

	// Remove all existing column positions on the board.

	foreach ($positions as $position) {
	$position->delete();
	}

	// Add the new column positions.

	foreach ($new_phids as $phid) {
	$column = idx($columns, $phid);
	if (!$column) {
	throw new Exception(
	pht('No such column "%s" exists!', $phid));
	}

	// Load the other object positions in the column. Note that we must
	// skip implicit column creation to avoid generating a new position
	// if the target column is a backlog column.

	$other_positions = id(new PhabricatorProjectColumnPositionQuery())
	->setViewer($this->requireActor())
	->withColumns(array($column))
	->withBoardPHIDs(array($board_phid))
	->setSkipImplicitCreate(true)
	->execute();
	$other_positions = msort($other_positions, 'getOrderingKey');

	// Set up the new position object. We're going to figure out the
	// right sequence number and then persist this object with that
	// sequence number.
	$new_position = id(new PhabricatorProjectColumnPosition())
	->setBoardPHID($board_phid)
	->setColumnPHID($column->getPHID())
	->setObjectPHID($object->getPHID());

	$updates = array();
	$sequence = 0;

	// If we're just dropping this into the column without any specific
	// position information, put it at the top.
	if (!$before_phid && !$after_phid) {
	$new_position->setSequence($sequence)->save();
	$sequence++;
	}

	foreach ($other_positions as $position) {
	$object_phid = $position->getObjectPHID();

	// If this is the object we're moving before and we haven't
	// saved yet, insert here.
	if (($before_phid == $object_phid) && !$new_position->getID()) {
	$new_position->setSequence($sequence)->save();
	$sequence++;
	}

	// This object goes here in the sequence; we might need to update
	// the row.
	if ($sequence != $position->getSequence()) {
	$updates[$position->getID()] = $sequence;
	}
	$sequence++;

	// If this is the object we're moving after and we haven't saved
	// yet, insert here.
	if (($after_phid == $object_phid) && !$new_position->getID()) {
	$new_position->setSequence($sequence)->save();
	$sequence++;
	}
	}

	// We should have found a place to put it.
	if (!$new_position->getID()) {
	throw new Exception(
	pht('Unable to find a place to insert object on column!'));
	}

	// If we changed other objects' column positions, bulk reorder them.

	if ($updates) {
	$position = new PhabricatorProjectColumnPosition();
	$conn_w = $position->establishConnection('w');

	$pairs = array();
	foreach ($updates as $id => $sequence) {
	// This is ugly because MySQL gets upset with us if it is
	// configured strictly and we attempt inserts which can't work.
	// We'll never actually do these inserts since they'll always
	// collide (triggering the ON DUPLICATE KEY logic), so we just
	// provide dummy values in order to get there.

	$pairs[] = qsprintf(
	$conn_w,
	'(%d, %d, "", "", "")',
	$id,
	$sequence);
	}

	queryfx(
	$conn_w,
	'INSERT INTO %T (id, sequence, boardPHID, columnPHID, objectPHID)
	VALUES %Q ON DUPLICATE KEY UPDATE sequence = VALUES(sequence)',
	$position->getTableName(),
	implode(', ', $pairs));
	}
	}
	break;
	default:
	break;
	}
	}

	protected function applyFinalEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {

	// When we change the status of a task, update tasks this tasks blocks
	// with a message to the effect of "alincoln resolved blocking task Txxx."
	$unblock_xaction = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_STATUS:
	$unblock_xaction = $xaction;
	break;
	}
	}

	if ($unblock_xaction !== null) {
	$blocked_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object->getPHID(),
	ManiphestTaskDependedOnByTaskEdgeType::EDGECONST);
	if ($blocked_phids) {
	// In theory we could apply these through policies, but that seems a
	// little bit surprising. For now, use the actor's vision.
	$blocked_tasks = id(new ManiphestTaskQuery())
	->setViewer($this->getActor())
	->withPHIDs($blocked_phids)
	->needSubscriberPHIDs(true)
	->needProjectPHIDs(true)
	->execute();

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

	foreach ($blocked_tasks as $blocked_task) {
	$unblock_xactions = array();

	$unblock_xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_UNBLOCK)
	->setOldValue(array($object->getPHID() => $old))
	->setNewValue(array($object->getPHID() => $new));

	id(new ManiphestTransactionEditor())
	->setActor($this->getActor())
	->setActingAsPHID($this->getActingAsPHID())
	->setContentSource($this->getContentSource())
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->applyTransactions($blocked_task, $unblock_xactions);
	}
	}
	}

	return $xactions;
	}

	protected function shouldSendMail(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$xactions = mfilter($xactions, 'shouldHide', true);
	return $xactions;
	}

	protected function getMailSubjectPrefix() {
	return PhabricatorEnv::getEnvConfig('metamta.maniphest.subject-prefix');
	}

	protected function getMailThreadID(PhabricatorLiskDAO $object) {
	return 'maniphest-task-'.$object->getPHID();
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	$phids = array();

	if ($object->getOwnerPHID()) {
	$phids[] = $object->getOwnerPHID();
	}
	$phids[] = $this->getActingAsPHID();

	return $phids;
	}

	public function getMailTagsMap() {
	return array(
	ManiphestTransaction::MAILTAG_STATUS =>
	pht("A task's status changes."),
	ManiphestTransaction::MAILTAG_OWNER =>
	pht("A task's owner changes."),
	ManiphestTransaction::MAILTAG_PRIORITY =>
	pht("A task's priority changes."),
	ManiphestTransaction::MAILTAG_CC =>
	pht("A task's subscribers change."),
	ManiphestTransaction::MAILTAG_PROJECTS =>
	pht("A task's associated projects change."),
	ManiphestTransaction::MAILTAG_UNBLOCK =>
	pht('One of the tasks a task is blocked by changes status.'),
	ManiphestTransaction::MAILTAG_COLUMN =>
	pht('A task is moved between columns on a workboard.'),
	ManiphestTransaction::MAILTAG_COMMENT =>
	pht('Someone comments on a task.'),
	ManiphestTransaction::MAILTAG_OTHER =>
	pht('Other task activity not listed above occurs.'),
	);
	}

	protected function buildReplyHandler(PhabricatorLiskDAO $object) {
	return id(new ManiphestReplyHandler())
	->setMailReceiver($object);
	}

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$title = $object->getTitle();

	return id(new PhabricatorMetaMTAMail())
	->setSubject("T{$id}: {$title}")
	->addHeader('Thread-Topic', "T{$id}: ".$object->getOriginalTitle());
	}

	protected function buildMailBody(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$body = parent::buildMailBody($object, $xactions);

	if ($this->getIsNewObject()) {
	$body->addTextSection(
	pht('TASK DESCRIPTION'),
	$object->getDescription());
	}

	$body->addLinkSection(
	pht('TASK DETAIL'),
	PhabricatorEnv::getProductionURI('/T'.$object->getID()));


	$board_phids = array();
	$type_column = ManiphestTransaction::TYPE_PROJECT_COLUMN;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_column) {
	$new = $xaction->getNewValue();
	$project_phid = idx($new, 'projectPHID');
	if ($project_phid) {
	$board_phids[] = $project_phid;
	}
	}
	}

	if ($board_phids) {
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->requireActor())
	->withPHIDs($board_phids)
	->execute();

	foreach ($projects as $project) {
	$body->addLinkSection(
	pht('WORKBOARD'),
	PhabricatorEnv::getProductionURI(
	'/project/board/'.$project->getID().'/'));
	}
	}


	return $body;
	}

	protected function shouldPublishFeedStory(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return $this->shouldSendMail($object, $xactions);
	}

	protected function supportsSearch() {
	return true;
	}

	protected function shouldApplyHeraldRules(
	PhabricatorLiskDAO $object,
	array $xactions) {
	return true;
	}

	protected function buildHeraldAdapter(
	PhabricatorLiskDAO $object,
	array $xactions) {

	return id(new HeraldManiphestTaskAdapter())
	->setTask($object);
	}

	protected function didApplyHeraldRules(
	PhabricatorLiskDAO $object,
	HeraldAdapter $adapter,
	HeraldTranscript $transcript) {

	$xactions = array();

	$cc_phids = $adapter->getCcPHIDs();
	if ($cc_phids) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(array('+' => $cc_phids));
	}

	$assign_phid = $adapter->getAssignPHID();
	if ($assign_phid) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_OWNER)
	->setNewValue($assign_phid);
	}

	return $xactions;
	}

	protected function requireCapabilities(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	parent::requireCapabilities($object, $xaction);

	$app_capability_map = array(
	ManiphestTransaction::TYPE_PRIORITY =>
	ManiphestEditPriorityCapability::CAPABILITY,
	ManiphestTransaction::TYPE_STATUS =>
	ManiphestEditStatusCapability::CAPABILITY,
	ManiphestTransaction::TYPE_OWNER =>
	ManiphestEditAssignCapability::CAPABILITY,
	PhabricatorTransactions::TYPE_EDIT_POLICY =>
	ManiphestEditPoliciesCapability::CAPABILITY,
	PhabricatorTransactions::TYPE_VIEW_POLICY =>
	ManiphestEditPoliciesCapability::CAPABILITY,
	);


	$transaction_type = $xaction->getTransactionType();

	$app_capability = null;
	if ($transaction_type == PhabricatorTransactions::TYPE_EDGE) {
	switch ($xaction->getMetadataValue('edge:type')) {
	case PhabricatorProjectObjectHasProjectEdgeType::EDGECONST:
	$app_capability = ManiphestEditProjectsCapability::CAPABILITY;
	break;
	}
	} else {
	$app_capability = idx($app_capability_map, $transaction_type);
	}

	if ($app_capability) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($this->getActor())
	->withClasses(array('PhabricatorManiphestApplication'))
	->executeOne();
	PhabricatorPolicyFilter::requireCapability(
	$this->getActor(),
	$app,
	$app_capability);
	}
	}

	protected function adjustObjectForPolicyChecks(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$copy = parent::adjustObjectForPolicyChecks($object, $xactions);
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_OWNER:
	$copy->setOwnerPHID($xaction->getNewValue());
	break;
	default:
	continue;
	}
	}

	return $copy;
	}

	/**
	* Get priorities for moving a task to a new priority.
	*/
	public static function getEdgeSubpriority(
	$priority,
	$is_end) {

	$query = id(new ManiphestTaskQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPriorities(array($priority))
	->setLimit(1);

	if ($is_end) {
	$query->setOrderVector(array('-priority', '-subpriority', '-id'));
	} else {
	$query->setOrderVector(array('priority', 'subpriority', 'id'));
	}

	$result = $query->executeOne();
	$step = (double)(2 << 32);

	if ($result) {
	$base = $result->getSubpriority();
	if ($is_end) {
	$sub = ($base - $step);
	} else {
	$sub = ($base + $step);
	}
	} else {
	$sub = 0;
	}

	return array($priority, $sub);
	}


	/**
	* Get priorities for moving a task before or after another task.
	*/
	public static function getAdjacentSubpriority(
	ManiphestTask $dst,
	- $is_after) {
	+ $is_after,
	+ $allow_recursion = true) {

	$query = id(new ManiphestTaskQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->setOrderBy(ManiphestTaskQuery::ORDER_PRIORITY)
	->withPriorities(array($dst->getPriority()))
	->setLimit(1);

	if ($is_after) {
	$query->setAfterID($dst->getID());
	} else {
	$query->setBeforeID($dst->getID());
	}

	$adjacent = $query->executeOne();

	$base = $dst->getSubpriority();
	$step = (double)(2 << 32);

	// If we find an adjacent task, we average the two subpriorities and
	// return the result.
	if ($adjacent) {
	+ $epsilon = 0.01;
	+
	// If the adjacent task has a subpriority that is identical or very
	// close to the task we're looking at, we're going to move it and all
	// tasks with the same subpriority a little farther down the subpriority
	// scale.
	- if (abs($adjacent->getSubpriority() - $base) < 0.01) {
	+ if ($allow_recursion &&
	+ (abs($adjacent->getSubpriority() - $base) < $epsilon)) {
	$conn_w = $adjacent->establishConnection('w');

	- // Get all of the tasks with the same subpriority as the adjacent
	+ $min = ($adjacent->getSubpriority() - ($epsilon));
	+ $max = ($adjacent->getSubpriority() + ($epsilon));
	+
	+ // Get all of the tasks with the similar subpriorities to the adjacent
	// task, including the adjacent task itself.
	- $shift_base = $adjacent->getSubpriority();
	$query = id(new ManiphestTaskQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPriorities(array($adjacent->getPriority()))
	- ->withSubpriorities(array($shift_base));
	+ ->withSubpriorityBetween($min, $max);

	if (!$is_after) {
	$query->setOrderVector(array('-priority', '-subpriority', '-id'));
	} else {
	$query->setOrderVector(array('priority', 'subpriority', 'id'));
	}

	$shift_all = $query->execute();
	$shift_last = last($shift_all);

	+ // Select the most extreme subpriority in the result set as the
	+ // base value.
	+ $shift_base = head($shift_all)->getSubpriority();
	+
	// Find the subpriority before or after the task at the end of the
	// block.
	list($shift_pri, $shift_sub) = self::getAdjacentSubpriority(
	$shift_last,
	- $is_after);
	+ $is_after,
	+ $allow_recursion = false);

	$delta = ($shift_sub - $shift_base);
	$count = count($shift_all);

	$shift = array();
	$cursor = 1;
	foreach ($shift_all as $shift_task) {
	$shift_target = $shift_base + (($cursor / $count) * $delta);
	$cursor++;

	queryfx(
	$conn_w,
	'UPDATE %T SET subpriority = %f WHERE id = %d',
	$adjacent->getTableName(),
	$shift_target,
	$shift_task->getID());

	// If we're shifting the adjacent task, update it.
	if ($shift_task->getID() == $adjacent->getID()) {
	$adjacent->setSubpriority($shift_target);
	}

	// If we're shifting the original target task, update the base
	// subpriority.
	if ($shift_task->getID() == $dst->getID()) {
	$base = $shift_target;
	}
	}
	}

	$sub = ($adjacent->getSubpriority() + $base) / 2;
	} else {
	// Otherwise, we take a step away from the target's subpriority and
	// use that.
	if ($is_after) {
	$sub = ($base - $step);
	} else {
	$sub = ($base + $step);
	}
	}

	return array($dst->getPriority(), $sub);
	}


	}
	diff --git a/src/applications/maniphest/query/ManiphestTaskQuery.php b/src/applications/maniphest/query/ManiphestTaskQuery.php
	index 3a91e2bbf4..0046bd5163 100644
	--- a/src/applications/maniphest/query/ManiphestTaskQuery.php
	+++ b/src/applications/maniphest/query/ManiphestTaskQuery.php
	@@ -1,1010 +1,1032 @@
	<?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 $subpriorityMin;
	+ private $subpriorityMax;

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

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

	private $needSubscriberPHIDs;
	private $needProjectPHIDs;
	private $blockingTasks;
	private $blockedTasks;
	private $projectPolicyCheckFailed = false;

	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) {
	$no_owner = ManiphestNoOwnerDatasource::FUNCTION_TOKEN;

	$this->includeUnowned = false;
	foreach ($owners as $k => $phid) {
	if ($phid === $no_owner \|\| $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 withSubpriorities(array $subpriorities) {
	$this->subpriorities = $subpriorities;
	return $this;
	}

	+ public function withSubpriorityBetween($min, $max) {
	+ $this->subpriorityMin = $min;
	+ $this->subpriorityMax = $max;
	+ 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;
	}

	/**
	* True returns tasks that are blocking other tasks only.
	* False returns tasks that are not blocking other tasks only.
	* Null returns tasks regardless of blocking status.
	*/
	public function withBlockingTasks($mode) {
	$this->blockingTasks = $mode;
	return $this;
	}

	public function shouldJoinBlockingTasks() {
	return $this->blockingTasks !== null;
	}

	/**
	* True returns tasks that are blocked by other tasks only.
	* False returns tasks that are not blocked by other tasks only.
	* Null returns tasks regardless of blocked by status.
	*/
	public function withBlockedTasks($mode) {
	$this->blockedTasks = $mode;
	return $this;
	}

	public function shouldJoinBlockedTasks() {
	return $this->blockedTasks !== null;
	}

	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 needSubscriberPHIDs($bool) {
	$this->needSubscriberPHIDs = $bool;
	return $this;
	}

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

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

	protected function willExecute() {
	// Make sure the user can see any projects specified in this
	// query FIRST.
	if ($this->projectPHIDs) {
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($this->projectPHIDs)
	->execute();
	$projects = mpull($projects, null, 'getPHID');
	foreach ($this->projectPHIDs as $index => $phid) {
	$project = idx($projects, $phid);
	if (!$project) {
	unset($this->projectPHIDs[$index]);
	continue;
	}
	}
	if (!$this->projectPHIDs) {
	$this->projectPolicyCheckFailed = true;
	}
	$this->projectPHIDs = array_values($this->projectPHIDs);
	}

	// If we already have an order vector, use it as provided.
	// TODO: This is a messy hack to make setOrderVector() stronger than
	// setPriority().
	$vector = $this->getOrderVector();
	$keys = mpull(iterator_to_array($vector), 'getOrderKey');
	if (array_values($keys) !== array('id')) {
	return;
	}

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

	if ($this->applicationSearchOrders) {
	$columns = array();
	foreach ($this->applicationSearchOrders as $order) {
	$part = 'custom:'.$order['key'];
	if ($order['ascending']) {
	$part = '-'.$part;
	}
	$columns[] = $part;
	}
	$columns[] = 'id';
	$parts[] = $columns;
	} else {
	switch ($this->orderBy) {
	case self::ORDER_PRIORITY:
	$parts[] = array('priority', 'subpriority', 'id');
	break;
	case self::ORDER_CREATED:
	$parts[] = array('id');
	break;
	case self::ORDER_MODIFIED:
	$parts[] = array('updated', 'id');
	break;
	case self::ORDER_TITLE:
	$parts[] = array('title', 'id');
	break;
	}
	}

	$parts = array_mergev($parts);
	// We may have a duplicate column if we are both ordering and grouping
	// by priority.
	$parts = array_unique($parts);
	$this->setOrderVector($parts);
	}

	protected function loadPage() {

	if ($this->projectPolicyCheckFailed) {
	throw new PhabricatorEmptyQueryException();
	}

	$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->buildDependenciesWhereClause($conn);
	$where[] = $this->buildAuthorWhereClause($conn);
	$where[] = $this->buildOwnerWhereClause($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);
	}

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

	if ($this->subpriorities) {
	$where[] = qsprintf(
	$conn,
	'task.subpriority IN (%Lf)',
	$this->subpriorities);
	}

	+ if ($this->subpriorityMin) {
	+ $where[] = qsprintf(
	+ $conn,
	+ 'task.subpriority >= %f',
	+ $this->subpriorityMin);
	+ }
	+
	+ if ($this->subpriorityMax) {
	+ $where[] = qsprintf(
	+ $conn,
	+ 'task.subpriority <= %f',
	+ $this->subpriorityMax);
	+ }
	+
	$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));
	}

	$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,
	$this->buildOrderClause($conn),
	$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) {
	$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;
	}

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

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

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

	return qsprintf(
	$conn,
	'task.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,
	'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("Unknown status query '{$this->status}'!");
	}
	return qsprintf(
	$conn,
	'task.status = %s',
	$constant);
	}
	}

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

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

	return qsprintf(
	$conn,
	'task.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,
	'task.ownerPHID IS NULL');
	} else {
	return qsprintf(
	$conn,
	'task.ownerPHID IS NOT NULL');
	}
	}

	if ($this->includeUnowned) {
	return qsprintf(
	$conn,
	'task.ownerPHID IN (%Ls) OR task.ownerPHID IS NULL',
	$this->ownerPHIDs);
	} else {
	return qsprintf(
	$conn,
	'task.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,
	'task.phid IN (%Ls)',
	$fulltext_results);
	}

	private function buildDependenciesWhereClause(
	AphrontDatabaseConnection $conn) {

	if (!$this->shouldJoinBlockedTasks() &&
	!$this->shouldJoinBlockingTasks()) {
	return null;
	}

	$parts = array();
	if ($this->blockingTasks === true) {
	$parts[] = qsprintf(
	$conn,
	'blocking.dst IS NOT NULL AND blockingtask.status IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	} else if ($this->blockingTasks === false) {
	$parts[] = qsprintf(
	$conn,
	'blocking.dst IS NULL OR blockingtask.status NOT IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	}

	if ($this->blockedTasks === true) {
	$parts[] = qsprintf(
	$conn,
	'blocked.dst IS NOT NULL AND blockedtask.status IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	} else if ($this->blockedTasks === false) {
	$parts[] = qsprintf(
	$conn,
	'blocked.dst IS NULL OR blockedtask.status NOT IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	}

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

	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 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->shouldJoinBlockingTasks()) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T blocking ON blocking.src = task.phid '.
	'AND blocking.type = %d '.
	'LEFT JOIN %T blockingtask ON blocking.dst = blockingtask.phid',
	$edge_table,
	ManiphestTaskDependedOnByTaskEdgeType::EDGECONST,
	id(new ManiphestTask())->getTableName());
	}
	if ($this->shouldJoinBlockedTasks()) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T blocked ON blocked.src = task.phid '.
	'AND blocked.type = %d '.
	'LEFT JOIN %T blockedtask ON blocked.dst = blockedtask.phid',
	$edge_table,
	ManiphestTaskDependsOnTaskEdgeType::EDGECONST,
	id(new ManiphestTask())->getTableName());
	}

	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) {
	$joins[] = qsprintf(
	$conn_r,
	'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_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);
	}

	protected function buildGroupClause(AphrontDatabaseConnection $conn_r) {
	$joined_multiple_rows = (count($this->projectPHIDs) > 1) \|\|
	(count($this->anyProjectPHIDs) > 1) \|\|
	$this->shouldJoinBlockingTasks() \|\|
	$this->shouldJoinBlockedTasks() \|\|
	($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);
	}

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

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

	return $id;
	}

	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,
	),
	'subpriority' => array(
	'table' => 'task',
	'column' => 'subpriority',
	'type' => 'float',
	),
	'updated' => array(
	'table' => 'task',
	'column' => 'dateModified',
	'type' => 'int',
	),
	);
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$cursor_parts = explode('.', $cursor, 2);
	$task_id = $cursor_parts[0];
	$group_id = idx($cursor_parts, 1);

	$task = $this->loadCursorObject($task_id);

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

	foreach ($keys as $key) {
	switch ($key) {
	case 'project':
	$value = null;
	if ($group_id) {
	$paging_projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($group_id))
	->execute();
	if ($paging_projects) {
	$value = head($paging_projects)->getName();
	}
	}
	$map[$key] = $value;
	break;
	}
	}

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

	return $map;
	}

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

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 20, 7:26 AM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 241517
Default Alt Text: (54 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions