No OneTemporary
Actions

Size

88 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 08cfc66632..97c567c30d 100644
	--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
	@@ -1,1070 +1,1076 @@
	<?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[] = ManiphestTransaction::TYPE_PARENT;
	$types[] = ManiphestTransaction::TYPE_COLUMN;
	$types[] = ManiphestTransaction::TYPE_COVER_IMAGE;
	$types[] = ManiphestTransaction::TYPE_POINTS;
	$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_COVER_IMAGE:
	return $object->getCoverImageFilePHID();
	case ManiphestTransaction::TYPE_POINTS:
	$points = $object->getPoints();
	if ($points !== null) {
	$points = (double)$points;
	}
	return $points;
	case ManiphestTransaction::TYPE_MERGED_INTO:
	case ManiphestTransaction::TYPE_MERGED_FROM:
	return null;
	case ManiphestTransaction::TYPE_PARENT:
	case ManiphestTransaction::TYPE_COLUMN:
	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:
	case ManiphestTransaction::TYPE_COVER_IMAGE:
	return $xaction->getNewValue();
	case ManiphestTransaction::TYPE_PARENT:
	case ManiphestTransaction::TYPE_COLUMN:
	return $xaction->getNewValue();
	case ManiphestTransaction::TYPE_POINTS:
	$value = $xaction->getNewValue();
	if (!strlen($value)) {
	$value = null;
	}
	if ($value !== null) {
	$value = (double)$value;
	}
	return $value;
	}
	}

	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_COVER_IMAGE:
	$file_phid = $xaction->getNewValue();

	if ($file_phid) {
	$file = id(new PhabricatorFileQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($file_phid))
	->executeOne();
	} else {
	$file = null;
	}

	if (!$file \|\| !$file->isTransformableImage()) {
	$object->setProperty('cover.filePHID', null);
	$object->setProperty('cover.thumbnailPHID', null);
	return;
	}

	$xform_key = PhabricatorFileThumbnailTransform::TRANSFORM_WORKCARD;

	$xform = PhabricatorFileTransform::getTransformByKey($xform_key)
	->executeTransform($file);

	$object->setProperty('cover.filePHID', $file->getPHID());
	$object->setProperty('cover.thumbnailPHID', $xform->getPHID());
	return;
	case ManiphestTransaction::TYPE_POINTS:
	$object->setPoints($xaction->getNewValue());
	return;
	case ManiphestTransaction::TYPE_MERGED_FROM:
	case ManiphestTransaction::TYPE_PARENT:
	case ManiphestTransaction::TYPE_COLUMN:
	return;
	}
	}

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

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_PARENT:
	$parent_phid = $xaction->getNewValue();
	$parent_type = ManiphestTaskDependsOnTaskEdgeType::EDGECONST;
	$task_phid = $object->getPHID();

	id(new PhabricatorEdgeEditor())
	->addEdge($parent_phid, $parent_type, $task_phid)
	->save();
	break;
	case ManiphestTransaction::TYPE_PROJECT_COLUMN:
	$board_phid = idx($xaction->getNewValue(), 'projectPHID');
	if (!$board_phid) {
	throw new Exception(
	pht(
	"Expected '%s' in column transaction.",
	'projectPHID'));
	}

	$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 '%s' in column transaction.",
	'columnPHIDs'));
	}

	$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.

	$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();

	- $object_phids = mpull($board_tasks, 'getPHID');
	- $object_phids[] = $object_phid;
	+ $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 if we legitimately support
	// multiple column positions.

	// NOTE: When a task is newly created, it's implicitly added to the
	// backlog but we don't currently record that in the "$old_phids". Just
	// clean it up for now.
	$columns = $engine->getObjectColumns($board_phid, $object_phid);
	foreach ($columns as $column) {
	$engine->queueRemovePosition(
	$board_phid,
	$column->getPHID(),
	$object_phid);
	}

	// Remove all existing column positions on the board.
	foreach ($old_phids as $column_phid) {
	$engine->queueRemovePosition(
	$board_phid,
	$column_phid,
	$object_phid);
	}

	// Add new positions.
	foreach ($new_phids as $column_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();

	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) {
	$parent_xaction = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_UNBLOCK)
	->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 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->addRemarkupSection(
	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 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,
	$allow_recursion = true) {

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

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

	protected function validateTransaction(
	PhabricatorLiskDAO $object,
	$type,
	array $xactions) {

	$errors = parent::validateTransaction($object, $type, $xactions);

	switch ($type) {
	case ManiphestTransaction::TYPE_TITLE:
	$missing = $this->validateIsEmptyTextField(
	$object->getTitle(),
	$xactions);

	if ($missing) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Required'),
	pht('Task title is required.'),
	nonempty(last($xactions), null));

	$error->setIsMissingFieldError(true);
	$errors[] = $error;
	}
	break;
	case ManiphestTransaction::TYPE_PARENT:
	$with_effect = array();
	foreach ($xactions as $xaction) {
	$task_phid = $xaction->getNewValue();
	if (!$task_phid) {
	continue;
	}

	$with_effect[] = $xaction;

	$task = id(new ManiphestTaskQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($task_phid))
	->executeOne();
	if (!$task) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'Parent task identifier "%s" does not identify a visible '.
	'task.',
	$task_phid),
	$xaction);
	}
	}

	if ($with_effect && !$this->getIsNewObject()) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'You can only select a parent task when creating a '.
	'transaction for the first time.'),
	last($with_effect));
	}
	break;
	case ManiphestTransaction::TYPE_COLUMN:
	$with_effect = array();
	foreach ($xactions as $xaction) {
	$column_phid = $xaction->getNewValue();
	if (!$column_phid) {
	continue;
	}

	$with_effect[] = $xaction;

	$column = $this->loadProjectColumn($column_phid);
	if (!$column) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'Column PHID "%s" does not identify a visible column.',
	$column_phid),
	$xaction);
	}
	}

	if ($with_effect && !$this->getIsNewObject()) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'You can only put a task into an initial column during task '.
	'creation.'),
	last($with_effect));
	}
	break;
	case ManiphestTransaction::TYPE_OWNER:
	foreach ($xactions as $xaction) {
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();
	if (!strlen($new)) {
	continue;
	}

	if ($new === $old) {
	continue;
	}

	$assignee_list = id(new PhabricatorPeopleQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($new))
	->execute();
	if (!$assignee_list) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'User "%s" is not a valid user.',
	$new),
	$xaction);
	}
	}
	break;
	case ManiphestTransaction::TYPE_COVER_IMAGE:
	foreach ($xactions as $xaction) {
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();
	if (!$new) {
	continue;
	}

	if ($new === $old) {
	continue;
	}

	$file = id(new PhabricatorFileQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($new))
	->executeOne();
	if (!$file) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('File "%s" is not valid.', $new),
	$xaction);
	continue;
	}

	if (!$file->isTransformableImage()) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('File "%s" is not a valid image file.', $new),
	$xaction);
	continue;
	}
	}
	break;

	case ManiphestTransaction::TYPE_POINTS:
	foreach ($xactions as $xaction) {
	$new = $xaction->getNewValue();
	if (strlen($new) && !is_numeric($new)) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('Points value must be numeric or empty.'),
	$xaction);
	continue;
	}

	if ((double)$new < 0) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht('Points value must be nonnegative.'),
	$xaction);
	continue;
	}
	}
	break;

	}

	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() == ManiphestTransaction::TYPE_OWNER) {
	$any_assign = true;
	break;
	}
	}

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

	$new_status = null;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_STATUS:
	$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(ManiphestTransaction::TYPE_OWNER)
	->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);

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_COLUMN:
	$column_phid = $xaction->getNewValue();
	if (!$column_phid) {
	break;
	}

	// When a task is created into a column, we also generate a transaction
	// to actually put it in that column.
	$column = $this->loadProjectColumn($column_phid);
	$results[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_PROJECT_COLUMN)
	->setOldValue(
	array(
	'projectPHID' => $column->getProjectPHID(),
	'columnPHIDs' => array(),
	))
	->setNewValue(
	array(
	'projectPHID' => $column->getProjectPHID(),
	'columnPHIDs' => array($column->getPHID()),
	));
	break;
	case ManiphestTransaction::TYPE_OWNER:
	// When a task is reassigned, move the old owner to the subscriber
	// list so they're still in the loop.
	$owner_phid = $object->getOwnerPHID();
	if ($owner_phid) {
	$results[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
	->setIgnoreOnNoEffect(true)
	->setNewValue(
	array(
	'+' => array($owner_phid => $owner_phid),
	));
	}
	break;
	}

	return $results;
	}

	private function loadProjectColumn($column_phid) {
	return id(new PhabricatorProjectColumnQuery())
	->setViewer($this->getActor())
	->withPHIDs(array($column_phid))
	->executeOne();
	}

	protected function extractFilePHIDsFromCustomTransaction(
	PhabricatorLiskDAO $object,
	PhabricatorApplicationTransaction $xaction) {
	$phids = parent::extractFilePHIDsFromCustomTransaction($object, $xaction);

	switch ($xaction->getTransactionType()) {
	case ManiphestTransaction::TYPE_COVER_IMAGE:
	$phids[] = $xaction->getNewValue();
	break;
	}

	return $phids;
	}


	}
	diff --git a/src/applications/project/controller/PhabricatorProjectBoardViewController.php b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	index e8de61e3cc..963cb2a752 100644
	--- a/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	+++ b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	@@ -1,1083 +1,1087 @@
	<?php

	final class PhabricatorProjectBoardViewController
	extends PhabricatorProjectBoardController {

	const BATCH_EDIT_ALL = 'all';

	private $id;
	private $slug;
	private $queryKey;
	private $sortKey;
	private $showHidden;

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getUser();

	$response = $this->loadProject();
	if ($response) {
	return $response;
	}

	$project = $this->getProject();

	$this->readRequestState();

	$board_uri = $this->getApplicationURI('board/'.$project->getID().'/');

	$search_engine = id(new ManiphestTaskSearchEngine())
	->setViewer($viewer)
	->setBaseURI($board_uri)
	->setIsBoardView(true);

	if ($request->isFormPost() && !$request->getBool('initialize')) {
	$saved = $search_engine->buildSavedQueryFromRequest($request);
	$search_engine->saveQuery($saved);
	$filter_form = id(new AphrontFormView())
	->setUser($viewer);
	$search_engine->buildSearchForm($filter_form, $saved);
	if ($search_engine->getErrors()) {
	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle(pht('Advanced Filter'))
	->appendChild($filter_form->buildLayoutView())
	->setErrors($search_engine->getErrors())
	->setSubmitURI($board_uri)
	->addSubmitButton(pht('Apply Filter'))
	->addCancelButton($board_uri);
	}
	return id(new AphrontRedirectResponse())->setURI(
	$this->getURIWithState(
	$search_engine->getQueryResultsPageURI($saved->getQueryKey())));
	}

	$query_key = $this->getDefaultFilter($project);

	$request_query = $request->getStr('filter');
	if (strlen($request_query)) {
	$query_key = $request_query;
	}

	$uri_query = $request->getURIData('queryKey');
	if (strlen($uri_query)) {
	$query_key = $uri_query;
	}

	$this->queryKey = $query_key;

	$custom_query = null;
	if ($search_engine->isBuiltinQuery($query_key)) {
	$saved = $search_engine->buildSavedQueryFromBuiltin($query_key);
	} else {
	$saved = id(new PhabricatorSavedQueryQuery())
	->setViewer($viewer)
	->withQueryKeys(array($query_key))
	->executeOne();

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

	$custom_query = $saved;
	}

	if ($request->getURIData('filter')) {
	$filter_form = id(new AphrontFormView())
	->setUser($viewer);
	$search_engine->buildSearchForm($filter_form, $saved);

	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle(pht('Advanced Filter'))
	->appendChild($filter_form->buildLayoutView())
	->setSubmitURI($board_uri)
	->addSubmitButton(pht('Apply Filter'))
	->addCancelButton($board_uri);
	}

	$task_query = $search_engine->buildQueryFromSavedQuery($saved);

	$select_phids = array($project->getPHID());
	if ($project->getHasSubprojects() \|\| $project->getHasMilestones()) {
	$descendants = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withAncestorProjectPHIDs($select_phids)
	->execute();
	foreach ($descendants as $descendant) {
	$select_phids[] = $descendant->getPHID();
	}
	}

	$tasks = $task_query
	->withEdgeLogicPHIDs(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	PhabricatorQueryConstraint::OPERATOR_ANCESTOR,
	array($select_phids))
	->setOrder(ManiphestTaskQuery::ORDER_PRIORITY)
	->setViewer($viewer)
	->execute();
	$tasks = mpull($tasks, null, 'getPHID');

	$board_phid = $project->getPHID();

	+ // Regardless of display order, pass tasks to the layout engine in ID order
	+ // so layout is consistent.
	+ $board_tasks = msort($tasks, 'getID');
	+
	$layout_engine = id(new PhabricatorBoardLayoutEngine())
	->setViewer($viewer)
	->setBoardPHIDs(array($board_phid))
	- ->setObjectPHIDs(array_keys($tasks))
	+ ->setObjectPHIDs(array_keys($board_tasks))
	->setFetchAllBoards(true)
	->executeLayout();

	$columns = $layout_engine->getColumns($board_phid);
	if (!$columns \|\| !$project->getHasWorkboard()) {
	$has_normal_columns = false;

	foreach ($columns as $column) {
	if (!$column->getProxyPHID()) {
	$has_normal_columns = true;
	break;
	}
	}

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);

	if (!$has_normal_columns) {
	if (!$can_edit) {
	$content = $this->buildNoAccessContent($project);
	} else {
	$content = $this->buildInitializeContent($project);
	}
	} else {
	if (!$can_edit) {
	$content = $this->buildDisabledContent($project);
	} else {
	$content = $this->buildEnableContent($project);
	}
	}

	if ($content instanceof AphrontResponse) {
	return $content;
	}

	$nav = $this->getProfileMenu();
	$nav->selectFilter(PhabricatorProject::PANEL_WORKBOARD);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Workboard'));

	return $this->newPage()
	->setTitle(
	array(
	$project->getDisplayName(),
	pht('Workboard'),
	))
	->setNavigation($nav)
	->setCrumbs($crumbs)
	->appendChild($content);
	}

	$task_can_edit_map = id(new PhabricatorPolicyFilter())
	->setViewer($viewer)
	->requireCapabilities(array(PhabricatorPolicyCapability::CAN_EDIT))
	->apply($tasks);

	// If this is a batch edit, select the editable tasks in the chosen column
	// and ship the user into the batch editor.
	$batch_edit = $request->getStr('batch');
	if ($batch_edit) {
	if ($batch_edit !== self::BATCH_EDIT_ALL) {
	$column_id_map = mpull($columns, null, 'getID');
	$batch_column = idx($column_id_map, $batch_edit);
	if (!$batch_column) {
	return new Aphront404Response();
	}

	$batch_task_phids = $layout_engine->getColumnObjectPHIDs(
	$board_phid,
	$batch_column->getPHID());

	foreach ($batch_task_phids as $key => $batch_task_phid) {
	if (empty($task_can_edit_map[$batch_task_phid])) {
	unset($batch_task_phids[$key]);
	}
	}

	$batch_tasks = array_select_keys($tasks, $batch_task_phids);
	} else {
	$batch_tasks = $task_can_edit_map;
	}

	if (!$batch_tasks) {
	$cancel_uri = $this->getURIWithState($board_uri);
	return $this->newDialog()
	->setTitle(pht('No Editable Tasks'))
	->appendParagraph(
	pht(
	'The selected column contains no visible tasks which you '.
	'have permission to edit.'))
	->addCancelButton($board_uri);
	}

	$batch_ids = mpull($batch_tasks, 'getID');
	$batch_ids = implode(',', $batch_ids);

	$batch_uri = new PhutilURI('/maniphest/batch/');
	$batch_uri->setQueryParam('board', $this->id);
	$batch_uri->setQueryParam('batch', $batch_ids);
	return id(new AphrontRedirectResponse())
	->setURI($batch_uri);
	}

	$board_id = celerity_generate_unique_node_id();

	$board = id(new PHUIWorkboardView())
	->setUser($viewer)
	->setID($board_id)
	->addSigil('jx-workboard')
	->setMetadata(
	array(
	'boardPHID' => $project->getPHID(),
	));

	$visible_columns = array();
	$column_phids = array();
	$visible_phids = array();
	foreach ($columns as $column) {
	if (!$this->showHidden) {
	if ($column->isHidden()) {
	continue;
	}
	}

	$proxy = $column->getProxy();
	if ($proxy && !$proxy->isMilestone()) {
	// TODO: For now, don't show subproject columns because we can't
	// handle tasks with multiple positions yet.
	continue;
	}

	$task_phids = $layout_engine->getColumnObjectPHIDs(
	$board_phid,
	$column->getPHID());

	$column_tasks = array_select_keys($tasks, $task_phids);

	// If we aren't using "natural" order, reorder the column by the original
	// query order.
	if ($this->sortKey != PhabricatorProjectColumn::ORDER_NATURAL) {
	$column_tasks = array_select_keys($column_tasks, array_keys($tasks));
	}

	$column_phid = $column->getPHID();

	$visible_columns[$column_phid] = $column;
	$column_phids[$column_phid] = $column_tasks;

	foreach ($column_tasks as $phid => $task) {
	$visible_phids[$phid] = $phid;
	}
	}

	$rendering_engine = id(new PhabricatorBoardRenderingEngine())
	->setViewer($viewer)
	->setObjects(array_select_keys($tasks, $visible_phids))
	->setEditMap($task_can_edit_map)
	->setExcludedProjectPHIDs($select_phids);

	$templates = array();
	$column_maps = array();
	$all_tasks = array();
	foreach ($visible_columns as $column_phid => $column) {
	$column_tasks = $column_phids[$column_phid];

	$panel = id(new PHUIWorkpanelView())
	->setHeader($column->getDisplayName())
	->setSubHeader($column->getDisplayType())
	->addSigil('workpanel');

	$proxy = $column->getProxy();
	if ($proxy) {
	$proxy_id = $proxy->getID();
	$href = $this->getApplicationURI("view/{$proxy_id}/");
	$panel->setHref($href);
	}

	$header_icon = $column->getHeaderIcon();
	if ($header_icon) {
	$panel->setHeaderIcon($header_icon);
	}

	$display_class = $column->getDisplayClass();
	if ($display_class) {
	$panel->addClass($display_class);
	}

	if ($column->isHidden()) {
	$panel->addClass('project-panel-hidden');
	}

	$column_menu = $this->buildColumnMenu($project, $column);
	$panel->addHeaderAction($column_menu);

	$count_tag = id(new PHUITagView())
	->setType(PHUITagView::TYPE_SHADE)
	->setShade(PHUITagView::COLOR_BLUE)
	->addSigil('column-points')
	->setName(
	javelin_tag(
	'span',
	array(
	'sigil' => 'column-points-content',
	),
	pht('-')))
	->setStyle('display: none');

	$panel->setHeaderTag($count_tag);

	$cards = id(new PHUIObjectItemListView())
	->setUser($viewer)
	->setFlush(true)
	->setAllowEmptyList(true)
	->addSigil('project-column')
	->setItemClass('phui-workcard')
	->setMetadata(
	array(
	'columnPHID' => $column->getPHID(),
	'pointLimit' => $column->getPointLimit(),
	));

	foreach ($column_tasks as $task) {
	$object_phid = $task->getPHID();

	$card = $rendering_engine->renderCard($object_phid);
	$templates[$object_phid] = hsprintf('%s', $card->getItem());
	$column_maps[$column_phid][] = $object_phid;

	$all_tasks[$object_phid] = $task;
	}

	$panel->setCards($cards);
	$board->addPanel($panel);
	}

	$behavior_config = array(
	'moveURI' => $this->getApplicationURI('move/'.$project->getID().'/'),
	'createURI' => $this->getCreateURI(),
	'uploadURI' => '/file/dropupload/',
	'coverURI' => $this->getApplicationURI('cover/'),
	'chunkThreshold' => PhabricatorFileStorageEngine::getChunkThreshold(),
	'pointsEnabled' => ManiphestTaskPoints::getIsEnabled(),

	'boardPHID' => $project->getPHID(),
	'order' => $this->sortKey,
	'templateMap' => $templates,
	'columnMaps' => $column_maps,
	'orderMaps' => mpull($all_tasks, 'getWorkboardOrderVectors'),
	'propertyMaps' => mpull($all_tasks, 'getWorkboardProperties'),

	'boardID' => $board_id,
	'projectPHID' => $project->getPHID(),
	);
	$this->initBehavior('project-boards', $behavior_config);


	$sort_menu = $this->buildSortMenu(
	$viewer,
	$project,
	$this->sortKey);

	$filter_menu = $this->buildFilterMenu(
	$viewer,
	$project,
	$custom_query,
	$search_engine,
	$query_key);

	$manage_menu = $this->buildManageMenu($project, $this->showHidden);

	$header_link = phutil_tag(
	'a',
	array(
	'href' => $this->getApplicationURI('profile/'.$project->getID().'/'),
	),
	$project->getName());

	$board_box = id(new PHUIBoxView())
	->appendChild($board)
	->addClass('project-board-wrapper');

	$nav = $this->getProfileMenu();
	$divider = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_DIVIDER);
	$fullscreen = $this->buildFullscreenMenu();

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(pht('Workboard'));
	$crumbs->setBorder(true);

	$crumbs->addAction($sort_menu);
	$crumbs->addAction($filter_menu);
	$crumbs->addAction($divider);
	$crumbs->addAction($manage_menu);
	$crumbs->addAction($fullscreen);

	// TODO: Wire to Workboard Preferences
	// require_celerity_resource('phui-workboard-color-css');
	// ->addClass('phui-workboard-color')
	// ->addClass('phui-workboard-bluegrey')

	return $this->newPage()
	->setTitle(
	array(
	$project->getDisplayName(),
	pht('Workboard'),
	))
	->setPageObjectPHIDs(array($project->getPHID()))
	->setShowFooter(false)
	->setNavigation($nav)
	->setCrumbs($crumbs)
	->addQuicksandConfig(
	array(
	'boardConfig' => $behavior_config,
	))
	->appendChild(
	array(
	$board_box,
	));
	}

	private function readRequestState() {
	$request = $this->getRequest();
	$project = $this->getProject();

	$this->showHidden = $request->getBool('hidden');
	$this->id = $project->getID();

	$sort_key = $this->getDefaultSort($project);

	$request_sort = $request->getStr('order');
	if ($this->isValidSort($request_sort)) {
	$sort_key = $request_sort;
	}

	$this->sortKey = $sort_key;
	}

	private function getDefaultSort(PhabricatorProject $project) {
	$default_sort = $project->getDefaultWorkboardSort();

	if ($this->isValidSort($default_sort)) {
	return $default_sort;
	}

	return PhabricatorProjectColumn::DEFAULT_ORDER;
	}

	private function getDefaultFilter(PhabricatorProject $project) {
	$default_filter = $project->getDefaultWorkboardFilter();

	if (strlen($default_filter)) {
	return $default_filter;
	}

	return 'open';
	}

	private function isValidSort($sort) {
	switch ($sort) {
	case PhabricatorProjectColumn::ORDER_NATURAL:
	case PhabricatorProjectColumn::ORDER_PRIORITY:
	return true;
	}

	return false;
	}

	private function buildSortMenu(
	PhabricatorUser $viewer,
	PhabricatorProject $project,
	$sort_key) {

	$sort_icon = id(new PHUIIconView())
	->setIcon('fa-sort-amount-asc bluegrey');

	$named = array(
	PhabricatorProjectColumn::ORDER_NATURAL => pht('Natural'),
	PhabricatorProjectColumn::ORDER_PRIORITY => pht('Sort by Priority'),
	);

	$base_uri = $this->getURIWithState();

	$items = array();
	foreach ($named as $key => $name) {
	$is_selected = ($key == $sort_key);
	if ($is_selected) {
	$active_order = $name;
	}

	$item = id(new PhabricatorActionView())
	->setIcon('fa-sort-amount-asc')
	->setSelected($is_selected)
	->setName($name);

	$uri = $base_uri->alter('order', $key);
	$item->setHref($uri);

	$items[] = $item;
	}

	$id = $project->getID();

	$save_uri = "default/{$id}/sort/";
	$save_uri = $this->getApplicationURI($save_uri);
	$save_uri = $this->getURIWithState($save_uri, $force = true);

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-floppy-o')
	->setName(pht('Save as Default'))
	->setHref($save_uri)
	->setWorkflow(true)
	->setDisabled(!$can_edit);

	$sort_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($items as $item) {
	$sort_menu->addAction($item);
	}

	$sort_button = id(new PHUIListItemView())
	->setName($active_order)
	->setIcon('fa-sort-amount-asc')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $sort_menu),
	));

	return $sort_button;
	}

	private function buildFilterMenu(
	PhabricatorUser $viewer,
	PhabricatorProject $project,
	$custom_query,
	PhabricatorApplicationSearchEngine $engine,
	$query_key) {

	$named = array(
	'open' => pht('Open Tasks'),
	'all' => pht('All Tasks'),
	);

	if ($viewer->isLoggedIn()) {
	$named['assigned'] = pht('Assigned to Me');
	}

	if ($custom_query) {
	$named[$custom_query->getQueryKey()] = pht('Custom Filter');
	}

	$items = array();
	foreach ($named as $key => $name) {
	$is_selected = ($key == $query_key);
	if ($is_selected) {
	$active_filter = $name;
	}

	$is_custom = false;
	if ($custom_query) {
	$is_custom = ($key == $custom_query->getQueryKey());
	}

	$item = id(new PhabricatorActionView())
	->setIcon('fa-search')
	->setSelected($is_selected)
	->setName($name);

	if ($is_custom) {
	$uri = $this->getApplicationURI(
	'board/'.$this->id.'/filter/query/'.$key.'/');
	$item->setWorkflow(true);
	} else {
	$uri = $engine->getQueryResultsPageURI($key);
	}

	$uri = $this->getURIWithState($uri)
	->setQueryParam('filter', null);
	$item->setHref($uri);

	$items[] = $item;
	}

	$id = $project->getID();

	$filter_uri = $this->getApplicationURI("board/{$id}/filter/");
	$filter_uri = $this->getURIWithState($filter_uri, $force = true);

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-cog')
	->setHref($filter_uri)
	->setWorkflow(true)
	->setName(pht('Advanced Filter...'));

	$save_uri = "default/{$id}/filter/";
	$save_uri = $this->getApplicationURI($save_uri);
	$save_uri = $this->getURIWithState($save_uri, $force = true);

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-floppy-o')
	->setName(pht('Save as Default'))
	->setHref($save_uri)
	->setWorkflow(true)
	->setDisabled(!$can_edit);

	$filter_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($items as $item) {
	$filter_menu->addAction($item);
	}

	$filter_button = id(new PHUIListItemView())
	->setName($active_filter)
	->setIcon('fa-search')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $filter_menu),
	));

	return $filter_button;
	}

	private function buildManageMenu(
	PhabricatorProject $project,
	$show_hidden) {

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

	$id = $project->getID();

	$disable_uri = $this->getApplicationURI("board/{$id}/disable/");
	$add_uri = $this->getApplicationURI("board/{$id}/edit/");
	$reorder_uri = $this->getApplicationURI("board/{$id}/reorder/");

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);

	$manage_items = array();

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-plus')
	->setName(pht('Add Column'))
	->setHref($add_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(true);

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-exchange')
	->setName(pht('Reorder Columns'))
	->setHref($reorder_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(true);

	if ($show_hidden) {
	$hidden_uri = $this->getURIWithState()
	->setQueryParam('hidden', null);
	$hidden_icon = 'fa-eye-slash';
	$hidden_text = pht('Hide Hidden Columns');
	} else {
	$hidden_uri = $this->getURIWithState()
	->setQueryParam('hidden', 'true');
	$hidden_icon = 'fa-eye';
	$hidden_text = pht('Show Hidden Columns');
	}

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon($hidden_icon)
	->setName($hidden_text)
	->setHref($hidden_uri);

	$batch_edit_uri = $request->getRequestURI();
	$batch_edit_uri->setQueryParam('batch', self::BATCH_EDIT_ALL);
	$can_batch_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
	ManiphestBulkEditCapability::CAPABILITY);

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-list-ul')
	->setName(pht('Batch Edit Visible Tasks...'))
	->setHref($batch_edit_uri)
	->setDisabled(!$can_batch_edit);

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-ban')
	->setName(pht('Disable Workboard'))
	->setHref($disable_uri)
	->setWorkflow(true)
	->setDisabled(!$can_edit);

	$manage_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($manage_items as $item) {
	$manage_menu->addAction($item);
	}

	$manage_button = id(new PHUIListItemView())
	->setIcon('fa-cog')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->addSigil('has-tooltip')
	->setMetadata(
	array(
	'tip' => pht('Manage'),
	'align' => 'S',
	'items' => hsprintf('%s', $manage_menu),
	));

	return $manage_button;
	}

	private function buildFullscreenMenu() {

	$up = id(new PHUIListItemView())
	->setIcon('fa-arrows-alt')
	->setHref('#')
	->addClass('phui-workboard-expand-icon')
	->addSigil('jx-toggle-class')
	->addSigil('has-tooltip')
	->setMetaData(array(
	'tip' => pht('Fullscreen'),
	'map' => array(
	'phabricator-standard-page' => 'phui-workboard-fullscreen',
	),
	));

	return $up;
	}

	private function buildColumnMenu(
	PhabricatorProject $project,
	PhabricatorProjectColumn $column) {

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

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);

	$column_items = array();

	if ($column->getProxyPHID()) {
	$default_phid = $column->getProxyPHID();
	} else {
	$default_phid = $column->getProjectPHID();
	}

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-plus')
	->setName(pht('Create Task...'))
	->setHref($this->getCreateURI())
	->addSigil('column-add-task')
	->setMetadata(
	array(
	'columnPHID' => $column->getPHID(),
	'boardPHID' => $project->getPHID(),
	'projectPHID' => $default_phid,
	));

	$batch_edit_uri = $request->getRequestURI();
	$batch_edit_uri->setQueryParam('batch', $column->getID());
	$can_batch_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
	ManiphestBulkEditCapability::CAPABILITY);

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-list-ul')
	->setName(pht('Batch Edit Tasks...'))
	->setHref($batch_edit_uri)
	->setDisabled(!$can_batch_edit);

	$detail_uri = $this->getApplicationURI(
	'board/'.$this->id.'/column/'.$column->getID().'/');

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-columns')
	->setName(pht('Column Details'))
	->setHref($detail_uri);

	$can_hide = ($can_edit && !$column->isDefaultColumn());
	$hide_uri = 'board/'.$this->id.'/hide/'.$column->getID().'/';
	$hide_uri = $this->getApplicationURI($hide_uri);
	$hide_uri = $this->getURIWithState($hide_uri);

	if (!$column->isHidden()) {
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Hide Column'))
	->setIcon('fa-eye-slash')
	->setHref($hide_uri)
	->setDisabled(!$can_hide)
	->setWorkflow(true);
	} else {
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Show Column'))
	->setIcon('fa-eye')
	->setHref($hide_uri)
	->setDisabled(!$can_hide)
	->setWorkflow(true);
	}

	$column_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($column_items as $item) {
	$column_menu->addAction($item);
	}

	$column_button = id(new PHUIIconView())
	->setIcon('fa-caret-down')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $column_menu),
	));

	return $column_button;
	}


	/**
	* Add current state parameters (like order and the visibility of hidden
	* columns) to a URI.
	*
	* This allows actions which toggle or adjust one piece of state to keep
	* the rest of the board state persistent. If no URI is provided, this method
	* starts with the request URI.
	*
	* @param string\|null URI to add state parameters to.
	* @param bool True to explicitly include all state.
	* @return PhutilURI URI with state parameters.
	*/
	private function getURIWithState($base = null, $force = false) {
	$project = $this->getProject();

	if ($base === null) {
	$base = $this->getRequest()->getRequestURI();
	}

	$base = new PhutilURI($base);

	if ($force \|\| ($this->sortKey != $this->getDefaultSort($project))) {
	$base->setQueryParam('order', $this->sortKey);
	} else {
	$base->setQueryParam('order', null);
	}

	if ($force \|\| ($this->queryKey != $this->getDefaultFilter($project))) {
	$base->setQueryParam('filter', $this->queryKey);
	} else {
	$base->setQueryParam('filter', null);
	}

	$base->setQueryParam('hidden', $this->showHidden ? 'true' : null);

	return $base;
	}

	private function getCreateURI() {
	$viewer = $this->getViewer();

	// TODO: This should be cleaned up, but maybe we're going to make options
	// for each column or board?
	$edit_config = id(new ManiphestEditEngine())
	->setViewer($viewer)
	->loadDefaultEditConfiguration();
	if ($edit_config) {
	$form_key = $edit_config->getIdentifier();
	$create_uri = "/maniphest/task/edit/form/{$form_key}/";
	} else {
	$create_uri = '/maniphest/task/edit/';
	}

	return $create_uri;
	}


	private function buildInitializeContent(PhabricatorProject $project) {
	$request = $this->getRequest();
	$viewer = $this->getViewer();

	$type = $request->getStr('initialize-type');

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");
	$board_uri = $this->getApplicationURI("board/{$id}/");
	$import_uri = $this->getApplicationURI("board/{$id}/import/");

	$set_default = $request->getBool('default');
	if ($set_default) {
	$this
	->getProfilePanelEngine()
	->adjustDefault(PhabricatorProject::PANEL_WORKBOARD);
	}

	if ($request->isFormPost()) {
	if ($type == 'backlog-only') {
	$column = PhabricatorProjectColumn::initializeNewColumn($viewer)
	->setSequence(0)
	->setProperty('isDefault', true)
	->setProjectPHID($project->getPHID())
	->save();

	$project->setHasWorkboard(1)->save();

	return id(new AphrontRedirectResponse())
	->setURI($board_uri);
	} else {
	return id(new AphrontRedirectResponse())
	->setURI($import_uri);
	}
	}

	// TODO: Tailor this UI if the project is already a parent project. We
	// should not offer options for creating a parent project workboard, since
	// they can't have their own columns.

	$new_selector = id(new AphrontFormRadioButtonControl())
	->setLabel(pht('Columns'))
	->setName('initialize-type')
	->setValue('backlog-only')
	->addButton(
	'backlog-only',
	pht('New Empty Board'),
	pht('Create a new board with just a backlog column.'))
	->addButton(
	'import',
	pht('Import Columns'),
	pht('Import board columns from another project.'));

	$default_checkbox = id(new AphrontFormCheckboxControl())
	->setLabel(pht('Make Default'))
	->addCheckbox(
	'default',
	1,
	pht('Make the workboard the default view for this project.'),
	true);

	$form = id(new AphrontFormView())
	->setUser($viewer)
	->addHiddenInput('initialize', 1)
	->appendRemarkupInstructions(
	pht('The workboard for this project has not been created yet.'))
	->appendControl($new_selector)
	->appendControl($default_checkbox)
	->appendControl(
	id(new AphrontFormSubmitControl())
	->addCancelButton($profile_uri)
	->setValue(pht('Create Workboard')));

	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Create Workboard'))
	->setForm($form);

	return $box;
	}

	private function buildNoAccessContent(PhabricatorProject $project) {
	$viewer = $this->getViewer();

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");

	return $this->newDialog()
	->setTitle(pht('Unable to Create Workboard'))
	->appendParagraph(
	pht(
	'The workboard for this project has not been created yet, '.
	'but you do not have permission to create it. Only users '.
	'who can edit this project can create a workboard for it.'))
	->addCancelButton($profile_uri);
	}


	private function buildEnableContent(PhabricatorProject $project) {
	$request = $this->getRequest();
	$viewer = $this->getViewer();

	$id = $project->getID();
	$profile_uri = $this->getApplicationURI("profile/{$id}/");
	$board_uri = $this->getApplicationURI("board/{$id}/");

	if ($request->isFormPost()) {
	$xactions = array();

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_HASWORKBOARD)
	->setNewValue(1);

	id(new PhabricatorProjectTransactionEditor())
	->setActor($viewer)
	->setContentSourceFromRequest($request)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->applyTransactions($project, $xactions);

	return id(new AphrontRedirectResponse())
	->setURI($board_uri);
	}

	return $this->newDialog()
	->setTitle(pht('Workboard Disabled'))
	->addHiddenInput('initialize', 1)
	->appendParagraph(
	pht(
	'This workboard has been disabled, but can be restored to its '.
	'former glory.'))
	->addCancelButton($profile_uri)
	->addSubmitButton(pht('Enable Workboard'));
	}

	private function buildDisabledContent(PhabricatorProject $project) {
	$viewer = $this->getViewer();

	$id = $project->getID();

	$profile_uri = $this->getApplicationURI("profile/{$id}/");

	return $this->newDialog()
	->setTitle(pht('Workboard Disabled'))
	->appendParagraph(
	pht(
	'This workboard has been disabled, and you do not have permission '.
	'to enable it. Only users who can edit this project can restore '.
	'the workboard.'))
	->addCancelButton($profile_uri);
	}

	}
	diff --git a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	index 3525af5ff0..248677fbec 100644
	--- a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	+++ b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	@@ -1,609 +1,612 @@
	<?php

	final class PhabricatorBoardLayoutEngine extends Phobject {

	private $viewer;
	private $boardPHIDs;
	private $objectPHIDs;
	private $boards;
	private $columnMap = array();
	private $objectColumnMap = array();
	private $boardLayout = array();
	private $fetchAllBoards;

	private $remQueue = array();
	private $addQueue = array();

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

	public function getViewer() {
	return $this->viewer;
	}

	public function setBoardPHIDs(array $board_phids) {
	$this->boardPHIDs = array_fuse($board_phids);
	return $this;
	}

	public function getBoardPHIDs() {
	return $this->boardPHIDs;
	}

	public function setObjectPHIDs(array $object_phids) {
	$this->objectPHIDs = array_fuse($object_phids);
	return $this;
	}

	public function getObjectPHIDs() {
	return $this->objectPHIDs;
	}

	/**
	* Fetch all boards, even if the board is disabled.
	*/
	public function setFetchAllBoards($fetch_all) {
	$this->fetchAllBoards = $fetch_all;
	return $this;
	}

	public function getFetchAllBoards() {
	return $this->fetchAllBoards;
	}

	public function executeLayout() {
	$viewer = $this->getViewer();

	$boards = $this->loadBoards();
	if (!$boards) {
	return $this;
	}

	$columns = $this->loadColumns($boards);
	$positions = $this->loadPositions($boards);

	foreach ($boards as $board_phid => $board) {
	$board_columns = idx($columns, $board_phid);

	// Don't layout boards with no columns. These boards need to be formally
	// created first.
	if (!$columns) {
	continue;
	}

	$board_positions = idx($positions, $board_phid, array());

	$this->layoutBoard($board, $board_columns, $board_positions);
	}

	return $this;
	}

	public function getColumns($board_phid) {
	$columns = idx($this->boardLayout, $board_phid, array());
	return array_select_keys($this->columnMap, array_keys($columns));
	}

	public function getColumnObjectPositions($board_phid, $column_phid) {
	$columns = idx($this->boardLayout, $board_phid, array());
	return idx($columns, $column_phid, array());
	}


	public function getColumnObjectPHIDs($board_phid, $column_phid) {
	$positions = $this->getColumnObjectPositions($board_phid, $column_phid);
	return mpull($positions, 'getObjectPHID');
	}

	public function getObjectColumns($board_phid, $object_phid) {
	$board_map = idx($this->objectColumnMap, $board_phid, array());

	$column_phids = idx($board_map, $object_phid);
	if (!$column_phids) {
	return array();
	}

	return array_select_keys($this->columnMap, $column_phids);
	}

	public function queueRemovePosition(
	$board_phid,
	$column_phid,
	$object_phid) {

	$board_layout = idx($this->boardLayout, $board_phid, array());
	$positions = idx($board_layout, $column_phid, array());
	$position = idx($positions, $object_phid);

	if ($position) {
	$this->remQueue[] = $position;

	// If this position hasn't been saved yet, get it out of the add queue.
	if (!$position->getID()) {
	foreach ($this->addQueue as $key => $add_position) {
	if ($add_position === $position) {
	unset($this->addQueue[$key]);
	}
	}
	}
	}

	unset($this->boardLayout[$board_phid][$column_phid][$object_phid]);

	return $this;
	}

	public function queueAddPositionBefore(
	$board_phid,
	$column_phid,
	$object_phid,
	$before_phid) {

	return $this->queueAddPositionRelative(
	$board_phid,
	$column_phid,
	$object_phid,
	$before_phid,
	true);
	}

	public function queueAddPositionAfter(
	$board_phid,
	$column_phid,
	$object_phid,
	$after_phid) {

	return $this->queueAddPositionRelative(
	$board_phid,
	$column_phid,
	$object_phid,
	$after_phid,
	false);
	}

	public function queueAddPosition(
	$board_phid,
	$column_phid,
	$object_phid) {
	return $this->queueAddPositionRelative(
	$board_phid,
	$column_phid,
	$object_phid,
	null,
	true);
	}

	private function queueAddPositionRelative(
	$board_phid,
	$column_phid,
	$object_phid,
	$relative_phid,
	$is_before) {

	$board_layout = idx($this->boardLayout, $board_phid, array());
	$positions = idx($board_layout, $column_phid, array());

	// Check if the object is already in the column, and remove it if it is.
	$object_position = idx($positions, $object_phid);
	unset($positions[$object_phid]);

	if (!$object_position) {
	$object_position = id(new PhabricatorProjectColumnPosition())
	->setBoardPHID($board_phid)
	->setColumnPHID($column_phid)
	->setObjectPHID($object_phid);
	}

	$found = false;
	if (!$positions) {
	$object_position->setSequence(0);
	} else {
	foreach ($positions as $position) {
	if (!$found) {
	if ($relative_phid === null) {
	$is_match = true;
	} else {
	$position_phid = $position->getObjectPHID();
	$is_match = ($relative_phid == $position_phid);
	}

	if ($is_match) {
	$found = true;

	$sequence = $position->getSequence();

	if (!$is_before) {
	$sequence++;
	}

	$object_position->setSequence($sequence++);

	if (!$is_before) {
	// If we're inserting after this position, continue the loop so
	// we don't update it.
	continue;
	}
	}
	}

	if ($found) {
	$position->setSequence($sequence++);
	$this->addQueue[] = $position;
	}
	}
	}

	if ($relative_phid && !$found) {
	throw new Exception(
	pht(
	'Unable to find object "%s" in column "%s" on board "%s".',
	$relative_phid,
	$column_phid,
	$board_phid));
	}

	$this->addQueue[] = $object_position;

	$positions[$object_phid] = $object_position;
	$positions = msort($positions, 'getOrderingKey');

	$this->boardLayout[$board_phid][$column_phid] = $positions;

	return $this;
	}

	public function applyPositionUpdates() {
	foreach ($this->remQueue as $position) {
	if ($position->getID()) {
	$position->delete();
	}
	}
	$this->remQueue = array();

	$adds = array();
	$updates = array();

	foreach ($this->addQueue as $position) {
	$id = $position->getID();
	if ($id) {
	$updates[$id] = $position;
	} else {
	$adds[] = $position;
	}
	}
	$this->addQueue = array();

	$table = new PhabricatorProjectColumnPosition();
	$conn_w = $table->establishConnection('w');

	$pairs = array();
	foreach ($updates as $id => $position) {
	// 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,
	$position->getSequence());
	}

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

	foreach ($adds as $position) {
	$position->save();
	}

	return $this;
	}

	private function loadBoards() {
	$viewer = $this->getViewer();
	$board_phids = $this->getBoardPHIDs();

	$boards = id(new PhabricatorObjectQuery())
	->setViewer($viewer)
	->withPHIDs($board_phids)
	->execute();
	$boards = mpull($boards, null, 'getPHID');

	if (!$this->fetchAllBoards) {
	foreach ($boards as $key => $board) {
	if (!$board->getHasWorkboard()) {
	unset($boards[$key]);
	}
	}
	}

	return $boards;
	}

	private function loadColumns(array $boards) {
	$viewer = $this->getViewer();

	$columns = id(new PhabricatorProjectColumnQuery())
	->setViewer($viewer)
	->withProjectPHIDs(array_keys($boards))
	->execute();
	$columns = msort($columns, 'getOrderingKey');
	$columns = mpull($columns, null, 'getPHID');

	$need_children = array();
	foreach ($boards as $phid => $board) {
	if ($board->getHasMilestones() \|\| $board->getHasSubprojects()) {
	$need_children[] = $phid;
	}
	}

	if ($need_children) {
	$children = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withParentProjectPHIDs($need_children)
	->execute();
	$children = mpull($children, null, 'getPHID');
	$children = mgroup($children, 'getParentProjectPHID');
	} else {
	$children = array();
	}

	$columns = mgroup($columns, 'getProjectPHID');
	foreach ($boards as $board_phid => $board) {
	$board_columns = idx($columns, $board_phid, array());

	// If the project has milestones, create any missing columns.
	if ($board->getHasMilestones() \|\| $board->getHasSubprojects()) {
	$child_projects = idx($children, $board_phid, array());

	if ($board_columns) {
	$next_sequence = last($board_columns)->getSequence() + 1;
	} else {
	$next_sequence = 1;
	}

	$proxy_columns = mpull($board_columns, null, 'getProxyPHID');
	foreach ($child_projects as $child_phid => $child) {
	if (isset($proxy_columns[$child_phid])) {
	continue;
	}

	$new_column = PhabricatorProjectColumn::initializeNewColumn($viewer)
	->attachProject($board)
	->attachProxy($child)
	->setSequence($next_sequence++)
	->setProjectPHID($board_phid)
	->setProxyPHID($child_phid);

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$new_column->save();
	unset($unguarded);

	$board_columns[$new_column->getPHID()] = $new_column;
	}
	}

	$board_columns = msort($board_columns, 'getOrderingKey');

	$columns[$board_phid] = $board_columns;
	}

	foreach ($columns as $board_phid => $board_columns) {
	foreach ($board_columns as $board_column) {
	$column_phid = $board_column->getPHID();
	$this->columnMap[$column_phid] = $board_column;
	}
	}

	return $columns;
	}

	private function loadPositions(array $boards) {
	$viewer = $this->getViewer();

	$object_phids = $this->getObjectPHIDs();
	if (!$object_phids) {
	return array();
	}

	$positions = id(new PhabricatorProjectColumnPositionQuery())
	->setViewer($viewer)
	->withBoardPHIDs(array_keys($boards))
	->withObjectPHIDs($object_phids)
	->execute();
	$positions = msort($positions, 'getOrderingKey');
	$positions = mgroup($positions, 'getBoardPHID');

	return $positions;
	}

	private function layoutBoard(
	$board,
	array $columns,
	array $positions) {

	$viewer = $this->getViewer();

	$board_phid = $board->getPHID();
	$position_groups = mgroup($positions, 'getObjectPHID');

	$layout = array();
	$default_phid = null;
	foreach ($columns as $column) {
	$column_phid = $column->getPHID();
	$layout[$column_phid] = array();

	if ($column->isDefaultColumn()) {
	$default_phid = $column_phid;
	}
	}

	// Find all the columns which are proxies for other objects.
	$proxy_map = array();
	foreach ($columns as $column) {
	$proxy_phid = $column->getProxyPHID();
	if ($proxy_phid) {
	$proxy_map[$proxy_phid] = $column->getPHID();
	}
	}

	$object_phids = $this->getObjectPHIDs();

	// If we have proxies, we need to force cards into the correct proxy
	// columns.
	if ($proxy_map && $object_phids) {
	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs($object_phids)
	->withEdgeTypes(
	array(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	));
	$edge_query->execute();

	$project_phids = $edge_query->getDestinationPHIDs();
	$project_phids = array_fuse($project_phids);
	} else {
	$project_phids = array();
	}

	if ($project_phids) {
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->withPHIDs($project_phids)
	->execute();
	$projects = mpull($projects, null, 'getPHID');
	} else {
	$projects = array();
	}

	// Build a map from every project that any task is tagged with to the
	// ancestor project which has a column on this board, if one exists.
	$ancestor_map = array();
	foreach ($projects as $phid => $project) {
	if (isset($proxy_map[$phid])) {
	$ancestor_map[$phid] = $proxy_map[$phid];
	} else {
	$seen = array($phid);
	foreach ($project->getAncestorProjects() as $ancestor) {
	$ancestor_phid = $ancestor->getPHID();
	$seen[] = $ancestor_phid;
	if (isset($proxy_map[$ancestor_phid])) {
	foreach ($seen as $project_phid) {
	$ancestor_map[$project_phid] = $proxy_map[$ancestor_phid];
	}
	}
	}
	}
	}

	+ $view_sequence = 1;
	foreach ($object_phids as $object_phid) {
	$positions = idx($position_groups, $object_phid, array());

	// First, check for objects that have corresponding proxy columns. We're
	// going to overwrite normal column positions if a tag belongs to a proxy
	// column, since you can't be in normal columns if you're in proxy
	// columns.
	$proxy_hits = array();
	if ($proxy_map) {
	$object_project_phids = $edge_query->getDestinationPHIDs(
	array(
	$object_phid,
	));

	foreach ($object_project_phids as $project_phid) {
	if (isset($ancestor_map[$project_phid])) {
	$proxy_hits[] = $ancestor_map[$project_phid];
	}
	}
	}

	if ($proxy_hits) {
	// TODO: For now, only one column hit is permissible.
	$proxy_hits = array_slice($proxy_hits, 0, 1);

	$proxy_hits = array_fuse($proxy_hits);

	// Check the object positions: we hope to find a position in each
	// column the object should be part of. We're going to drop any
	// invalid positions and create new positions where positions are
	// missing.
	foreach ($positions as $key => $position) {
	$column_phid = $position->getColumnPHID();
	if (isset($proxy_hits[$column_phid])) {
	// Valid column, mark the position as found.
	unset($proxy_hits[$column_phid]);
	} else {
	// Invalid column, ignore the position.
	unset($positions[$key]);
	}
	}

	// Create new positions for anything we haven't found.
	foreach ($proxy_hits as $proxy_hit) {
	$new_position = id(new PhabricatorProjectColumnPosition())
	->setBoardPHID($board_phid)
	->setColumnPHID($proxy_hit)
	->setObjectPHID($object_phid)
	- ->setSequence(0);
	+ ->setSequence(0)
	+ ->setViewSequence($view_sequence++);

	$this->addQueue[] = $new_position;

	$positions[] = $new_position;
	}
	} else {
	// Ignore any positions in columns which no longer exist. We don't
	// actively destory them because the rest of the code ignores them and
	// there's no real need to destroy the data.
	foreach ($positions as $key => $position) {
	$column_phid = $position->getColumnPHID();
	if (empty($columns[$column_phid])) {
	unset($positions[$key]);
	}
	}

	// If the object has no position, put it on the default column if
	// one exists.
	if (!$positions && $default_phid) {
	$new_position = id(new PhabricatorProjectColumnPosition())
	->setBoardPHID($board_phid)
	->setColumnPHID($default_phid)
	->setObjectPHID($object_phid)
	- ->setSequence(0);
	+ ->setSequence(0)
	+ ->setViewSequence($view_sequence++);

	$this->addQueue[] = $new_position;

	$positions = array(
	$new_position,
	);
	}
	}

	foreach ($positions as $position) {
	$column_phid = $position->getColumnPHID();
	$layout[$column_phid][$object_phid] = $position;
	}
	}

	foreach ($layout as $column_phid => $map) {
	$map = msort($map, 'getOrderingKey');
	$layout[$column_phid] = $map;

	foreach ($map as $object_phid => $position) {
	$this->objectColumnMap[$board_phid][$object_phid][] = $column_phid;
	}
	}

	$this->boardLayout[$board_phid] = $layout;
	}

	}
	diff --git a/src/applications/project/storage/PhabricatorProjectColumnPosition.php b/src/applications/project/storage/PhabricatorProjectColumnPosition.php
	index c59676f8e4..40929606ac 100644
	--- a/src/applications/project/storage/PhabricatorProjectColumnPosition.php
	+++ b/src/applications/project/storage/PhabricatorProjectColumnPosition.php
	@@ -1,81 +1,94 @@
	<?php

	final class PhabricatorProjectColumnPosition extends PhabricatorProjectDAO
	implements PhabricatorPolicyInterface {

	protected $boardPHID;
	protected $columnPHID;
	protected $objectPHID;
	protected $sequence;

	private $column = self::ATTACHABLE;
	+ private $viewSequence = 0;

	protected function getConfiguration() {
	return array(
	self::CONFIG_TIMESTAMPS => false,
	self::CONFIG_COLUMN_SCHEMA => array(
	'sequence' => 'uint32',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'boardPHID' => array(
	'columns' => array('boardPHID', 'columnPHID', 'objectPHID'),
	'unique' => true,
	),
	'objectPHID' => array(
	'columns' => array('objectPHID', 'boardPHID'),
	),
	'boardPHID_2' => array(
	'columns' => array('boardPHID', 'columnPHID', 'sequence'),
	),
	),
	) + parent::getConfiguration();
	}

	public function getColumn() {
	return $this->assertAttached($this->column);
	}

	public function attachColumn(PhabricatorProjectColumn $column) {
	$this->column = $column;
	return $this;
	}

	+ public function setViewSequence($view_sequence) {
	+ $this->viewSequence = $view_sequence;
	+ return $this;
	+ }
	+
	public function getOrderingKey() {
	- if (!$this->getID() && !$this->getSequence()) {
	- return 0;
	- }
	+ // We're ordering both real positions and "virtual" positions which we have
	+ // created but not saved yet.
	+
	+ // Low sequence numbers go above high sequence numbers. Virtual positions
	+ // will have sequence number 0.
	+
	+ // High virtual sequence numbers go above low virtual sequence numbers.
	+ // The layout engine gets objects in ID order, and this puts them in
	+ // reverse ID order.
	+
	+ // High IDs go above low IDs.

	- // Low sequence numbers go above high sequence numbers.
	- // High position IDs go above low position IDs.
	- // Broadly, this makes newly added stuff float to the top.
	+ // Broadly, this collectively makes newly added stuff float to the top.

	return sprintf(
	- '~%012d%012d',
	+ '~%012d%012d%012d',
	$this->getSequence(),
	+ ((1 << 31) - $this->viewSequence),
	((1 << 31) - $this->getID()));
	}

	/* -( PhabricatorPolicyInterface )----------------------------------------- */

	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::getMostOpenPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return false;
	}

	public function describeAutomaticCapability($capability) {
	return null;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Apr 7, 9:04 AM (1 d, 4 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1166004
Default Alt Text: (88 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions