No OneTemporary
Actions

Size

72 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/maniphest/__tests__/ManiphestTaskTestCase.php b/src/applications/maniphest/__tests__/ManiphestTaskTestCase.php
	index 5f5c198a84..1e571190d7 100644
	--- a/src/applications/maniphest/__tests__/ManiphestTaskTestCase.php
	+++ b/src/applications/maniphest/__tests__/ManiphestTaskTestCase.php
	@@ -1,221 +1,249 @@
	<?php

	final class ManiphestTaskTestCase extends PhabricatorTestCase {

	protected function getPhabricatorTestCaseConfiguration() {
	return array(
	self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES => true,
	);
	}

	public function testTaskReordering() {
	$viewer = $this->generateNewTestUser();

	$t1 = $this->newTask($viewer, pht('Task 1'));
	$t2 = $this->newTask($viewer, pht('Task 2'));
	$t3 = $this->newTask($viewer, pht('Task 3'));

	$auto_base = min(mpull(array($t1, $t2, $t3), 'getID'));


	// Default order should be reverse creation.
	$tasks = $this->loadTasks($viewer, $auto_base);
	$t1 = $tasks[1];
	$t2 = $tasks[2];
	$t3 = $tasks[3];
	$this->assertEqual(array(3, 2, 1), array_keys($tasks));


	// Move T3 to the middle.
	$this->moveTask($viewer, $t3, $t2, true);
	$tasks = $this->loadTasks($viewer, $auto_base);
	$t1 = $tasks[1];
	$t2 = $tasks[2];
	$t3 = $tasks[3];
	$this->assertEqual(array(2, 3, 1), array_keys($tasks));


	// Move T3 to the end.
	$this->moveTask($viewer, $t3, $t1, true);
	$tasks = $this->loadTasks($viewer, $auto_base);
	$t1 = $tasks[1];
	$t2 = $tasks[2];
	$t3 = $tasks[3];
	$this->assertEqual(array(2, 1, 3), array_keys($tasks));


	// Repeat the move above, there should be no overall change in order.
	$this->moveTask($viewer, $t3, $t1, true);
	$tasks = $this->loadTasks($viewer, $auto_base);
	$t1 = $tasks[1];
	$t2 = $tasks[2];
	$t3 = $tasks[3];
	$this->assertEqual(array(2, 1, 3), array_keys($tasks));


	// Move T3 to the first slot in the priority.
	$this->movePriority($viewer, $t3, $t3->getPriority(), false);
	$tasks = $this->loadTasks($viewer, $auto_base);
	$t1 = $tasks[1];
	$t2 = $tasks[2];
	$t3 = $tasks[3];
	$this->assertEqual(array(3, 2, 1), array_keys($tasks));


	// Move T3 to the last slot in the priority.
	$this->movePriority($viewer, $t3, $t3->getPriority(), true);
	$tasks = $this->loadTasks($viewer, $auto_base);
	$t1 = $tasks[1];
	$t2 = $tasks[2];
	$t3 = $tasks[3];
	$this->assertEqual(array(2, 1, 3), array_keys($tasks));


	// Move T3 before T2.
	$this->moveTask($viewer, $t3, $t2, false);
	$tasks = $this->loadTasks($viewer, $auto_base);
	$t1 = $tasks[1];
	$t2 = $tasks[2];
	$t3 = $tasks[3];
	$this->assertEqual(array(3, 2, 1), array_keys($tasks));


	// Move T3 before T1.
	$this->moveTask($viewer, $t3, $t1, false);
	$tasks = $this->loadTasks($viewer, $auto_base);
	$t1 = $tasks[1];
	$t2 = $tasks[2];
	$t3 = $tasks[3];
	$this->assertEqual(array(2, 3, 1), array_keys($tasks));

	}

	public function testTaskAdjacentBlocks() {
	$viewer = $this->generateNewTestUser();

	$t = array();
	for ($ii = 1; $ii < 10; $ii++) {
	$t[$ii] = $this->newTask($viewer, pht('Task Block %d', $ii));

	// This makes sure this test remains meaningful if we begin assigning
	// subpriorities when tasks are created.
	$t[$ii]->setSubpriority(0)->save();
	}

	$auto_base = min(mpull($t, 'getID'));

	$tasks = $this->loadTasks($viewer, $auto_base);
	$this->assertEqual(
	array(9, 8, 7, 6, 5, 4, 3, 2, 1),
	array_keys($tasks));

	$this->moveTask($viewer, $t[9], $t[8], true);
	$tasks = $this->loadTasks($viewer, $auto_base);
	$this->assertEqual(
	array(8, 9, 7, 6, 5, 4, 3, 2, 1),
	array_keys($tasks));

	// When there is a large block of tasks which all have the same
	// subpriority, they should be assigned distinct subpriorities as a
	// side effect of having a task moved into the block.

	$subpri = mpull($tasks, 'getSubpriority');
	$unique_subpri = array_unique($subpri);
	$this->assertEqual(
	9,
	count($subpri),
	pht('Expected subpriorities to be distributed.'));
	+
	+ // Move task 9 to the end.
	+ $this->moveTask($viewer, $t[9], $t[1], true);
	+ $tasks = $this->loadTasks($viewer, $auto_base);
	+ $this->assertEqual(
	+ array(8, 7, 6, 5, 4, 3, 2, 1, 9),
	+ array_keys($tasks));
	+
	+ // Move task 3 to the beginning.
	+ $this->moveTask($viewer, $t[3], $t[8], false);
	+ $tasks = $this->loadTasks($viewer, $auto_base);
	+ $this->assertEqual(
	+ array(3, 8, 7, 6, 5, 4, 2, 1, 9),
	+ array_keys($tasks));
	+
	+ // Move task 3 to the end.
	+ $this->moveTask($viewer, $t[3], $t[9], true);
	+ $tasks = $this->loadTasks($viewer, $auto_base);
	+ $this->assertEqual(
	+ array(8, 7, 6, 5, 4, 2, 1, 9, 3),
	+ array_keys($tasks));
	+
	+ // Move task 5 to before task 4 (this is its current position).
	+ $this->moveTask($viewer, $t[5], $t[4], false);
	+ $tasks = $this->loadTasks($viewer, $auto_base);
	+ $this->assertEqual(
	+ array(8, 7, 6, 5, 4, 2, 1, 9, 3),
	+ array_keys($tasks));
	}

	private function newTask(PhabricatorUser $viewer, $title) {
	$task = ManiphestTask::initializeNewTask($viewer);

	$xactions = array();

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTaskTitleTransaction::TRANSACTIONTYPE)
	->setNewValue($title);


	$this->applyTaskTransactions($viewer, $task, $xactions);

	return $task;
	}

	private function loadTasks(PhabricatorUser $viewer, $auto_base) {
	$tasks = id(new ManiphestTaskQuery())
	->setViewer($viewer)
	->setOrder(ManiphestTaskQuery::ORDER_PRIORITY)
	->execute();

	// NOTE: AUTO_INCREMENT changes survive ROLLBACK, and we can't throw them
	// away without committing the current transaction, so we adjust the
	// apparent task IDs as though the first one had been ID 1. This makes the
	// tests a little easier to understand.

	$map = array();
	foreach ($tasks as $task) {
	$map[($task->getID() - $auto_base) + 1] = $task;
	}

	return $map;
	}

	private function moveTask(PhabricatorUser $viewer, $src, $dst, $is_after) {
	list($pri, $sub) = ManiphestTransactionEditor::getAdjacentSubpriority(
	$dst,
	$is_after);

	$xactions = array();

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTaskPriorityTransaction::TRANSACTIONTYPE)
	->setNewValue($pri);

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTaskSubpriorityTransaction::TRANSACTIONTYPE)
	->setNewValue($sub);

	return $this->applyTaskTransactions($viewer, $src, $xactions);
	}

	private function movePriority(
	PhabricatorUser $viewer,
	$src,
	$target_priority,
	$is_end) {

	list($pri, $sub) = ManiphestTransactionEditor::getEdgeSubpriority(
	$target_priority,
	$is_end);

	$xactions = array();

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTaskPriorityTransaction::TRANSACTIONTYPE)
	->setNewValue($pri);

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTaskSubpriorityTransaction::TRANSACTIONTYPE)
	->setNewValue($sub);

	return $this->applyTaskTransactions($viewer, $src, $xactions);
	}

	private function applyTaskTransactions(
	PhabricatorUser $viewer,
	ManiphestTask $task,
	array $xactions) {

	$content_source = $this->newContentSource();

	$editor = id(new ManiphestTransactionEditor())
	->setActor($viewer)
	->setContentSource($content_source)
	->setContinueOnNoEffect(true)
	->applyTransactions($task, $xactions);

	return $task;
	}

	}
	diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	index c9e17cd4de..1b780549dc 100644
	--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	@@ -1,963 +1,1061 @@
	<?php

	final class ManiphestTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

	private $moreValidationErrors = array();

	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[] = PhabricatorTransactions::TYPE_COLUMNS;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;

	return $types;
	}

	public function getCreateObjectTitle($author, $object) {
	return pht('%s created this task.', $author);
	}

	public function getCreateObjectTitleForFeed($author, $object) {
	return pht('%s created %s.', $author, $object);
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return null;
	}
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return $xaction->getNewValue();
	}
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return (bool)$new;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	return;
	}
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	foreach ($xaction->getNewValue() as $move) {
	$this->applyBoardMove($object, $move);
	}
	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 ManiphestTaskStatusTransaction::TRANSACTIONTYPE:
	$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) {
	$parent_xaction = id(new ManiphestTransaction())
	->setTransactionType(
	ManiphestTaskUnblockTransaction::TRANSACTIONTYPE)
	->setOldValue(array($object->getPHID() => $old))
	->setNewValue(array($object->getPHID() => $new));

	if ($this->getIsNewObject()) {
	$parent_xaction->setMetadataValue('blocker.new', true);
	}

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

	return $xactions;
	}

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

	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 a task's subtasks 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->addRemarkupSection(
	pht('TASK DESCRIPTION'),
	$object->getDescription());
	}

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


	$board_phids = array();
	$type_columns = PhabricatorTransactions::TYPE_COLUMNS;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() == $type_columns) {
	$moves = $xaction->getNewValue();
	foreach ($moves as $move) {
	$board_phids[] = $move['boardPHID'];
	}
	}
	}

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

	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 requireCapabilities(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

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

	$app_capability_map = array(
	ManiphestTaskPriorityTransaction::TRANSACTIONTYPE =>
	ManiphestEditPriorityCapability::CAPABILITY,
	ManiphestTaskStatusTransaction::TRANSACTIONTYPE =>
	ManiphestEditStatusCapability::CAPABILITY,
	ManiphestTaskOwnerTransaction::TRANSACTIONTYPE =>
	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 ManiphestTaskOwnerTransaction::TRANSACTIONTYPE:
	$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,
	- $allow_recursion = true) {
	+ $is_after) {

	$query = id(new ManiphestTaskQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->setOrder(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;
	+ $epsilon = 1.0;

	// 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 ($allow_recursion &&
	- (abs($adjacent->getSubpriority() - $base) < $epsilon)) {
	- $conn_w = $adjacent->establishConnection('w');
	-
	- $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.
	- $query = id(new ManiphestTaskQuery())
	- ->setViewer(PhabricatorUser::getOmnipotentUser())
	- ->withPriorities(array($adjacent->getPriority()))
	- ->withSubpriorityBetween($min, $max);
	-
	- if (!$is_after) {
	- $query->setOrderVector(array('-priority', '-subpriority', '-id'));
	+ // close to the task we're looking at, we're going to spread out all
	+ // the nearby tasks.
	+
	+ $adjacent_sub = $adjacent->getSubpriority();
	+ if ((abs($adjacent_sub - $base) < $epsilon)) {
	+ $base = self::disperseBlock(
	+ $dst,
	+ $epsilon * 2);
	+ if ($is_after) {
	+ $sub = $base - $epsilon;
	} 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,
	- $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 = $base + $epsilon;
	}
	+ } else {
	+ $sub = ($adjacent_sub + $base) / 2;
	}
	-
	- $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);
	}

	+ /**
	+ * Distribute a cluster of tasks with similar subpriorities.
	+ */
	+ private static function disperseBlock(
	+ ManiphestTask $task,
	+ $spacing) {
	+
	+ $conn = $task->establishConnection('w');
	+
	+ // Find a block of subpriority space which is, on average, sparse enough
	+ // to hold all the tasks that are inside it with a reasonable level of
	+ // separation between them.
	+
	+ // We'll start by looking near the target task for a range of numbers
	+ // which has more space available than tasks. For example, if the target
	+ // task has subpriority 33 and we want to separate each task by at least 1,
	+ // we might start by looking in the range [23, 43].
	+
	+ // If we find fewer than 20 tasks there, we have room to reassign them
	+ // with the desired level of separation. We space them out, then we're
	+ // done.
	+
	+ // However: if we find more than 20 tasks, we don't have enough room to
	+ // distribute them. We'll widen our search and look in a bigger range,
	+ // maybe [13, 53]. This range has more space, so if we find fewer than
	+ // 40 tasks in this range we can spread them out. If we still find too
	+ // many tasks, we keep widening the search.
	+
	+ $base = $task->getSubpriority();
	+
	+ $scale = 4.0;
	+ while (true) {
	+ $range = ($spacing * $scale) / 2.0;
	+ $min = ($base - $range);
	+ $max = ($base + $range);
	+
	+ $result = queryfx_one(
	+ $conn,
	+ 'SELECT COUNT(*) N FROM %T WHERE priority = %d AND
	+ subpriority BETWEEN %f AND %f',
	+ $task->getTableName(),
	+ $task->getPriority(),
	+ $min,
	+ $max);
	+
	+ $count = $result['N'];
	+ if ($count < $scale) {
	+ // We have found a block which we can make sparse enough, so bail and
	+ // continue below with our selection.
	+ break;
	+ }
	+
	+ // This block had too many tasks for its size, so try again with a
	+ // bigger block.
	+ $scale *= 2.0;
	+ }
	+
	+ $rows = queryfx_all(
	+ $conn,
	+ 'SELECT id FROM %T WHERE priority = %d AND
	+ subpriority BETWEEN %f AND %f
	+ ORDER BY priority, subpriority, id',
	+ $task->getTableName(),
	+ $task->getPriority(),
	+ $min,
	+ $max);
	+
	+ $task_id = $task->getID();
	+ $result = null;
	+
	+ // NOTE: In strict mode (which we encourage enabling) we can't structure
	+ // this bulk update as an "INSERT ... ON DUPLICATE KEY UPDATE" unless we
	+ // provide default values for ALL of the columns that don't have defaults.
	+
	+ // This is gross, but we may be moving enough rows that individual
	+ // queries are unreasonably slow. An alternate construction which might
	+ // be worth evaluating is to use "CASE". Another approach is to disable
	+ // strict mode for this query.
	+
	+ $extra_columns = array(
	+ 'phid' => '""',
	+ 'authorPHID' => '""',
	+ 'status' => '""',
	+ 'priority' => 0,
	+ 'title' => '""',
	+ 'originalTitle' => '""',
	+ 'description' => '""',
	+ 'dateCreated' => 0,
	+ 'dateModified' => 0,
	+ 'mailKey' => '""',
	+ 'viewPolicy' => '""',
	+ 'editPolicy' => '""',
	+ 'ownerOrdering' => '""',
	+ 'spacePHID' => '""',
	+ 'bridgedObjectPHID' => '""',
	+ 'properties' => '""',
	+ 'points' => 0,
	+ 'subtype' => '""',
	+ );
	+
	+ $defaults = implode(', ', $extra_columns);
	+
	+ $sql = array();
	+ $offset = 0;
	+
	+ // Often, we'll have more room than we need in the range. Distribute the
	+ // tasks evenly over the whole range so that we're less likely to end up
	+ // with tasks spaced exactly the minimum distance apart, which may
	+ // get shifted again later. We have one fewer space to distribute than we
	+ // have tasks.
	+ $divisor = (double)(count($rows) - 1.0);
	+ if ($divisor > 0) {
	+ $available_distance = (($max - $min) / $divisor);
	+ } else {
	+ $available_distance = 0.0;
	+ }
	+
	+ foreach ($rows as $row) {
	+ $subpriority = $min + ($offset * $available_distance);
	+
	+ // If this is the task that we're spreading out relative to, keep track
	+ // of where it is ending up so we can return the new subpriority.
	+ $id = $row['id'];
	+ if ($id == $task_id) {
	+ $result = $subpriority;
	+ }
	+
	+ $sql[] = qsprintf(
	+ $conn,
	+ '(%d, %Q, %f)',
	+ $id,
	+ $defaults,
	+ $subpriority);
	+
	+ $offset++;
	+ }
	+
	+ foreach (PhabricatorLiskDAO::chunkSQL($sql) as $chunk) {
	+ queryfx(
	+ $conn,
	+ 'INSERT INTO %T (id, %Q, subpriority) VALUES %Q
	+ ON DUPLICATE KEY UPDATE subpriority = VALUES(subpriority)',
	+ $task->getTableName(),
	+ implode(', ', array_keys($extra_columns)),
	+ $chunk);
	+ }
	+
	+ return $result;
	+ }
	+
	protected function validateAllTransactions(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$errors = parent::validateAllTransactions($object, $xactions);

	if ($this->moreValidationErrors) {
	$errors = array_merge($errors, $this->moreValidationErrors);
	}

	return $errors;
	}

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

	$actor = $this->getActor();
	$actor_phid = $actor->getPHID();

	$results = parent::expandTransactions($object, $xactions);

	$is_unassigned = ($object->getOwnerPHID() === null);

	$any_assign = false;
	foreach ($xactions as $xaction) {
	if ($xaction->getTransactionType() ==
	ManiphestTaskOwnerTransaction::TRANSACTIONTYPE) {
	$any_assign = true;
	break;
	}
	}

	$is_open = !$object->isClosed();

	$new_status = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTaskStatusTransaction::TRANSACTIONTYPE:
	$new_status = $xaction->getNewValue();
	break;
	}
	}

	if ($new_status === null) {
	$is_closing = false;
	} else {
	$is_closing = ManiphestTaskStatus::isClosedStatus($new_status);
	}

	// If the task is not assigned, not being assigned, currently open, and
	// being closed, try to assign the actor as the owner.
	if ($is_unassigned && !$any_assign && $is_open && $is_closing) {
	$is_claim = ManiphestTaskStatus::isClaimStatus($new_status);

	// Don't assign the actor if they aren't a real user.
	// Don't claim the task if the status is configured to not claim.
	if ($actor_phid && $is_claim) {
	$results[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTaskOwnerTransaction::TRANSACTIONTYPE)
	->setNewValue($actor_phid);
	}
	}

	// Automatically subscribe the author when they create a task.
	if ($this->getIsNewObject()) {
	if ($actor_phid) {
	$results[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setNewValue(
	array(
	'+' => array($actor_phid => $actor_phid),
	));
	}
	}

	return $results;
	}

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

	$results = parent::expandTransaction($object, $xaction);

	$type = $xaction->getTransactionType();
	switch ($type) {
	case PhabricatorTransactions::TYPE_COLUMNS:
	try {
	$more_xactions = $this->buildMoveTransaction($object, $xaction);
	foreach ($more_xactions as $more_xaction) {
	$results[] = $more_xaction;
	}
	} catch (Exception $ex) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	$ex->getMessage(),
	$xaction);
	$this->moreValidationErrors[] = $error;
	}
	break;
	case ManiphestTaskOwnerTransaction::TRANSACTIONTYPE:
	// If this is a no-op update, don't expand it.
	$old_value = $object->getOwnerPHID();
	$new_value = $xaction->getNewValue();
	if ($old_value === $new_value) {
	continue;
	}

	// When a task is reassigned, move the old owner to the subscriber
	// list so they're still in the loop.
	if ($old_value) {
	$results[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setIgnoreOnNoEffect(true)
	->setNewValue(
	array(
	'+' => array($old_value => $old_value),
	));
	}
	break;
	}

	return $results;
	}

	private function buildMoveTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {

	$new = $xaction->getNewValue();
	if (!is_array($new)) {
	$this->validateColumnPHID($new);
	$new = array($new);
	}

	$nearby_phids = array();
	foreach ($new as $key => $value) {
	if (!is_array($value)) {
	$this->validateColumnPHID($value);
	$value = array(
	'columnPHID' => $value,
	);
	}

	PhutilTypeSpec::checkMap(
	$value,
	array(
	'columnPHID' => 'string',
	'beforePHID' => 'optional string',
	'afterPHID' => 'optional string',
	));

	$new[$key] = $value;

	if (!empty($value['beforePHID'])) {
	$nearby_phids[] = $value['beforePHID'];
	}

	if (!empty($value['afterPHID'])) {
	$nearby_phids[] = $value['afterPHID'];
	}
	}

	if ($nearby_phids) {
	$nearby_objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getActor())
	->withPHIDs($nearby_phids)
	->execute();
	$nearby_objects = mpull($nearby_objects, null, 'getPHID');
	} else {
	$nearby_objects = array();
	}

	$column_phids = ipull($new, 'columnPHID');
	if ($column_phids) {
	$columns = id(new PhabricatorProjectColumnQuery())
	->setViewer($this->getActor())
	->withPHIDs($column_phids)
	->execute();
	$columns = mpull($columns, null, 'getPHID');
	} else {
	$columns = array();
	}

	$board_phids = mpull($columns, 'getProjectPHID');
	$object_phid = $object->getPHID();

	$object_phids = $nearby_phids;

	// Note that we may not have an object PHID if we're creating a new
	// object.
	if ($object_phid) {
	$object_phids[] = $object_phid;
	}

	if ($object_phids) {
	$layout_engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($this->getActor())
	->setBoardPHIDs($board_phids)
	->setObjectPHIDs($object_phids)
	->setFetchAllBoards(true)
	->executeLayout();
	}

	foreach ($new as $key => $spec) {
	$column_phid = $spec['columnPHID'];
	$column = idx($columns, $column_phid);
	if (!$column) {
	throw new Exception(
	pht(
	'Column move transaction specifies column PHID "%s", but there '.
	'is no corresponding column with this PHID.',
	$column_phid));
	}

	$board_phid = $column->getProjectPHID();

	$nearby = array();

	if (!empty($spec['beforePHID'])) {
	$nearby['beforePHID'] = $spec['beforePHID'];
	}

	if (!empty($spec['afterPHID'])) {
	$nearby['afterPHID'] = $spec['afterPHID'];
	}

	if (count($nearby) > 1) {
	throw new Exception(
	pht(
	'Column move transaction moves object to multiple positions. '.
	'Specify only "beforePHID" or "afterPHID", not both.'));
	}

	foreach ($nearby as $where => $nearby_phid) {
	if (empty($nearby_objects[$nearby_phid])) {
	throw new Exception(
	pht(
	'Column move transaction specifies object "%s" as "%s", but '.
	'there is no corresponding object with this PHID.',
	$object_phid,
	$where));
	}

	$nearby_columns = $layout_engine->getObjectColumns(
	$board_phid,
	$nearby_phid);
	$nearby_columns = mpull($nearby_columns, null, 'getPHID');

	if (empty($nearby_columns[$column_phid])) {
	throw new Exception(
	pht(
	'Column move transaction specifies object "%s" as "%s" in '.
	'column "%s", but this object is not in that column!',
	$nearby_phid,
	$where,
	$column_phid));
	}
	}

	if ($object_phid) {
	$old_columns = $layout_engine->getObjectColumns(
	$board_phid,
	$object_phid);
	$old_column_phids = mpull($old_columns, 'getPHID');
	} else {
	$old_column_phids = array();
	}

	$spec += array(
	'boardPHID' => $board_phid,
	'fromColumnPHIDs' => $old_column_phids,
	);

	// Check if the object is already in this column, and isn't being moved.
	// We can just drop this column change if it has no effect.
	$from_map = array_fuse($spec['fromColumnPHIDs']);
	$already_here = isset($from_map[$column_phid]);
	$is_reordering = (bool)$nearby;

	if ($already_here && !$is_reordering) {
	unset($new[$key]);
	} else {
	$new[$key] = $spec;
	}
	}

	$new = array_values($new);
	$xaction->setNewValue($new);


	$more = array();

	// If we're moving the object into a column and it does not already belong
	// in the column, add the appropriate board. For normal columns, this
	// is the board PHID. For proxy columns, it is the proxy PHID, unless the
	// object is already a member of some descendant of the proxy PHID.

	// The major case where this can happen is moves via the API, but it also
	// happens when a user drags a task from the "Backlog" to a milestone
	// column.

	if ($object_phid) {
	$current_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object_phid,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	$current_phids = array_fuse($current_phids);
	} else {
	$current_phids = array();
	}

	$add_boards = array();
	foreach ($new as $move) {
	$column_phid = $move['columnPHID'];
	$board_phid = $move['boardPHID'];
	$column = $columns[$column_phid];
	$proxy_phid = $column->getProxyPHID();

	// If this is a normal column, add the board if the object isn't already
	// associated.
	if (!$proxy_phid) {
	if (!isset($current_phids[$board_phid])) {
	$add_boards[] = $board_phid;
	}
	continue;
	}

	// If this is a proxy column but the object is already associated with
	// the proxy board, we don't need to do anything.
	if (isset($current_phids[$proxy_phid])) {
	continue;
	}

	// If this a proxy column and the object is already associated with some
	// descendant of the proxy board, we also don't need to do anything.
	$descendants = id(new PhabricatorProjectQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withAncestorProjectPHIDs(array($proxy_phid))
	->execute();

	$found_descendant = false;
	foreach ($descendants as $descendant) {
	if (isset($current_phids[$descendant->getPHID()])) {
	$found_descendant = true;
	break;
	}
	}

	if ($found_descendant) {
	continue;
	}

	// Otherwise, we're moving the object to a proxy column which it is not
	// a member of yet, so add an association to the column's proxy board.

	$add_boards[] = $proxy_phid;
	}

	if ($add_boards) {
	$more[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue(
	'edge:type',
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST)
	->setIgnoreOnNoEffect(true)
	->setNewValue(
	array(
	'+' => array_fuse($add_boards),
	));
	}

	return $more;
	}

	private function applyBoardMove($object, array $move) {
	$board_phid = $move['boardPHID'];
	$column_phid = $move['columnPHID'];
	$before_phid = idx($move, 'beforePHID');
	$after_phid = idx($move, 'afterPHID');

	$object_phid = $object->getPHID();

	// We're doing layout with the ominpotent viewer to make sure we don't
	// remove positions in columns that exist, but which the actual actor
	// can't see.
	$omnipotent_viewer = PhabricatorUser::getOmnipotentUser();

	$select_phids = array($board_phid);

	$descendants = id(new PhabricatorProjectQuery())
	->setViewer($omnipotent_viewer)
	->withAncestorProjectPHIDs($select_phids)
	->execute();
	foreach ($descendants as $descendant) {
	$select_phids[] = $descendant->getPHID();
	}

	$board_tasks = id(new ManiphestTaskQuery())
	->setViewer($omnipotent_viewer)
	->withEdgeLogicPHIDs(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	PhabricatorQueryConstraint::OPERATOR_ANCESTOR,
	array($select_phids))
	->execute();

	$board_tasks = mpull($board_tasks, null, 'getPHID');
	$board_tasks[$object_phid] = $object;

	// Make sure tasks are sorted by ID, so we lay out new positions in
	// a consistent way.
	$board_tasks = msort($board_tasks, 'getID');

	$object_phids = array_keys($board_tasks);

	$engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($omnipotent_viewer)
	->setBoardPHIDs(array($board_phid))
	->setObjectPHIDs($object_phids)
	->executeLayout();

	// TODO: This logic needs to be revised when we legitimately support
	// multiple column positions.
	$columns = $engine->getObjectColumns($board_phid, $object_phid);
	foreach ($columns as $column) {
	$engine->queueRemovePosition(
	$board_phid,
	$column->getPHID(),
	$object_phid);
	}

	if ($before_phid) {
	$engine->queueAddPositionBefore(
	$board_phid,
	$column_phid,
	$object_phid,
	$before_phid);
	} else if ($after_phid) {
	$engine->queueAddPositionAfter(
	$board_phid,
	$column_phid,
	$object_phid,
	$after_phid);
	} else {
	$engine->queueAddPosition(
	$board_phid,
	$column_phid,
	$object_phid);
	}

	$engine->applyPositionUpdates();
	}


	private function validateColumnPHID($value) {
	if (phid_get_type($value) == PhabricatorProjectColumnPHIDType::TYPECONST) {
	return;
	}

	throw new Exception(
	pht(
	'When moving objects between columns on a board, columns must '.
	'be identified by PHIDs. This transaction uses "%s" to identify '.
	'a column, but that is not a valid column PHID.',
	$value));
	}



	}
	diff --git a/src/applications/maniphest/query/ManiphestTaskQuery.php b/src/applications/maniphest/query/ManiphestTaskQuery.php
	index 4cf47f40cb..704a67f548 100644
	--- a/src/applications/maniphest/query/ManiphestTaskQuery.php
	+++ b/src/applications/maniphest/query/ManiphestTaskQuery.php
	@@ -1,908 +1,886 @@
	<?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 $subpriorityMin;
	- private $subpriorityMax;
	private $bridgedObjectPHIDs;
	private $hasOpenParents;
	private $hasOpenSubtasks;
	private $parentTaskIDs;
	private $subtaskIDs;
	private $subtypes;

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

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

	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 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 newResultObject() {
	return new ManiphestTask();
	}

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

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

	$group_column = '';
	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;
	}

	$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);
	$where[] = $this->buildFullTextWhereClause($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->priorities !== null) {
	$where[] = qsprintf(
	$conn,
	'task.priority IN (%Ld)',
	$this->priorities);
	}

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

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

	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) {
	$subclause[] = qsprintf(
	$conn,
	'task.ownerPHID IN (%Ls)',
	$this->ownerPHIDs);
	}

	if (!$subclause) {
	return '';
	}

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

	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 10,000 will raise errors in
	// Elasticsearch, and billions of results won't fit in memory anyway.
	$fulltext_query->setParameter('limit', 10000);
	$fulltext_query->setParameter('types',
	array(ManiphestTaskPHIDType::TYPECONST));

	$fulltext_results = PhabricatorSearchService::executeSearch(
	$fulltext_query);

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

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

	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 = 'JOIN';
	} else {
	$join_type = '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 = 'JOIN';
	} else {
	$join_type = '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_r) {
	$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 'GROUP BY task.phid, projectGroup.dst';
	} else {
	return 'GROUP BY task.phid';
	}
	} else {
	return '';
	}
	}


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

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

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

	return $id;
	}

	public function getBuiltinOrders() {
	$orders = array(
	'priority' => array(
	'vector' => array('priority', 'subpriority', '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)'),
	),
	'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',
	'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,
	),
	'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';
	}

	}
	diff --git a/src/applications/project/controller/PhabricatorProjectMoveController.php b/src/applications/project/controller/PhabricatorProjectMoveController.php
	index 68915664cb..801acbb90e 100644
	--- a/src/applications/project/controller/PhabricatorProjectMoveController.php
	+++ b/src/applications/project/controller/PhabricatorProjectMoveController.php
	@@ -1,204 +1,207 @@
	<?php

	final class PhabricatorProjectMoveController
	extends PhabricatorProjectController {

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getViewer();
	$id = $request->getURIData('id');

	$request->validateCSRF();

	$column_phid = $request->getStr('columnPHID');
	$object_phid = $request->getStr('objectPHID');
	$after_phid = $request->getStr('afterPHID');
	$before_phid = $request->getStr('beforePHID');
	$order = $request->getStr('order', PhabricatorProjectColumn::DEFAULT_ORDER);

	$project = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	))
	->withIDs(array($id))
	->executeOne();
	if (!$project) {
	return new Aphront404Response();
	}

	$board_phid = $project->getPHID();

	$object = id(new ManiphestTaskQuery())
	->setViewer($viewer)
	->withPHIDs(array($object_phid))
	->needProjectPHIDs(true)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();

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

	$columns = id(new PhabricatorProjectColumnQuery())
	->setViewer($viewer)
	->withProjectPHIDs(array($project->getPHID()))
	->execute();

	$columns = mpull($columns, null, 'getPHID');
	$column = idx($columns, $column_phid);
	if (!$column) {
	// User is trying to drop this object into a nonexistent column, just kick
	// them out.
	return new Aphront404Response();
	}

	$engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($viewer)
	->setBoardPHIDs(array($board_phid))
	->setObjectPHIDs(array($object_phid))
	->executeLayout();

	$columns = $engine->getObjectColumns($board_phid, $object_phid);
	$old_column_phids = mpull($columns, 'getPHID');

	$xactions = array();

	$order_params = array();
	if ($order == PhabricatorProjectColumn::ORDER_NATURAL) {
	if ($after_phid) {
	$order_params['afterPHID'] = $after_phid;
	} else if ($before_phid) {
	$order_params['beforePHID'] = $before_phid;
	}
	}

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

	if ($order == PhabricatorProjectColumn::ORDER_PRIORITY) {
	$priority_xactions = $this->getPriorityTransactions(
	$object,
	$after_phid,
	$before_phid);
	foreach ($priority_xactions as $xaction) {
	$xactions[] = $xaction;
	}
	}

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

	$editor->applyTransactions($object, $xactions);

	return $this->newCardResponse($board_phid, $object_phid);
	}

	private function getPriorityTransactions(
	ManiphestTask $task,
	$after_phid,
	$before_phid) {

	list($after_task, $before_task) = $this->loadPriorityTasks(
	$after_phid,
	$before_phid);

	$must_move = false;
	if ($after_task && !$task->isLowerPriorityThan($after_task)) {
	$must_move = true;
	}

	if ($before_task && !$task->isHigherPriorityThan($before_task)) {
	$must_move = true;
	}

	// The move doesn't require a priority change to be valid, so don't
	// change the priority since we are not being forced to.
	if (!$must_move) {
	return array();
	}

	$try = array(
	array($after_task, true),
	array($before_task, false),
	);

	$pri = null;
	$sub = null;
	foreach ($try as $spec) {
	list($task, $is_after) = $spec;

	if (!$task) {
	continue;
	}

	list($pri, $sub) = ManiphestTransactionEditor::getAdjacentSubpriority(
	$task,
	$is_after);
	+
	+ // If we find a priority on the first try, don't keep going.
	+ break;
	}

	$xactions = array();
	if ($pri !== null) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTaskPriorityTransaction::TRANSACTIONTYPE)
	->setNewValue($pri);
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(
	ManiphestTaskSubpriorityTransaction::TRANSACTIONTYPE)
	->setNewValue($sub);
	}

	return $xactions;
	}

	private function loadPriorityTasks($after_phid, $before_phid) {
	$viewer = $this->getViewer();

	$task_phids = array();

	if ($after_phid) {
	$task_phids[] = $after_phid;
	}
	if ($before_phid) {
	$task_phids[] = $before_phid;
	}

	if (!$task_phids) {
	return array(null, null);
	}

	$tasks = id(new ManiphestTaskQuery())
	->setViewer($viewer)
	->withPHIDs($task_phids)
	->execute();
	$tasks = mpull($tasks, null, 'getPHID');

	if ($after_phid) {
	$after_task = idx($tasks, $after_phid);
	} else {
	$after_task = null;
	}

	if ($before_phid) {
	$before_task = idx($tasks, $before_phid);
	} else {
	$before_task = null;
	}

	return array($after_task, $before_task);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Jul 28, 11:05 PM (1 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 187610
Default Alt Text: (72 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions