No OneTemporary
Actions

Size

17 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	index 83fb943b76..22aaed2d4b 100644
	--- a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	+++ b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	@@ -1,595 +1,595 @@
	<?php

	final class PhabricatorBoardLayoutEngine extends Phobject {

	private $viewer;
	private $boardPHIDs;
	- private $objectPHIDs;
	+ private $objectPHIDs = array();
	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 queueAddPosition(
	$board_phid,
	$column_phid,
	$object_phid,
	array $after_phids,
	array $before_phids) {

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

	if (!$positions) {
	$object_position->setSequence(0);
	} else {
	// The user's view of the board may fall out of date, so they might
	// try to drop a card under a different card which is no longer where
	// they thought it was.

	// When this happens, we perform the move anyway, since this is almost
	// certainly what users want when interacting with the UI. We'l try to
	// fall back to another nearby card if the client provided us one. If
	// we don't find any of the cards the client specified in the column,
	// we'll just move the card to the default position.

	$search_phids = array();
	foreach ($after_phids as $after_phid) {
	$search_phids[] = array($after_phid, false);
	}

	foreach ($before_phids as $before_phid) {
	$search_phids[] = array($before_phid, true);
	}

	// This makes us fall back to the default position if we fail every
	// candidate position. The default position counts as a "before" position
	// because we want to put the new card at the top of the column.
	$search_phids[] = array(null, true);

	$found = false;
	foreach ($search_phids as $search_position) {
	list($relative_phid, $is_before) = $search_position;
	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 ($found) {
	break;
	}
	}
	}

	$this->addQueue[] = $object_position;

	$positions[$object_phid] = $object_position;
	$positions = msortv($positions, 'newColumnPositionOrderVector');

	$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 %LQ ON DUPLICATE KEY UPDATE sequence = VALUES(sequence)',
	$table->getTableName(),
	$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))
	->needTriggers(true)
	->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 = msortv($positions, 'newColumnPositionOrderVector');
	$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)
	->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)
	->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 = msortv($map, 'newColumnPositionOrderVector');
	$layout[$column_phid] = $map;

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

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 15:11 (3 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1125843
Default Alt Text: (17 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions