No OneTemporary
Actions

Size

50 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php b/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php
	index 6c0f05ebbb..74f637f16d 100644
	--- a/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php
	+++ b/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php
	@@ -1,1198 +1,1357 @@
	<?php

	final class PhabricatorProjectCoreTestCase extends PhabricatorTestCase {

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

	public function testViewProject() {
	$user = $this->createUser();
	$user->save();

	$user2 = $this->createUser();
	$user2->save();

	$proj = $this->createProject($user);

	$proj = $this->refreshProject($proj, $user, true);

	$this->joinProject($proj, $user);
	$proj->setViewPolicy(PhabricatorPolicies::POLICY_USER);
	$proj->save();

	$can_view = PhabricatorPolicyCapability::CAN_VIEW;

	// When the view policy is set to "users", any user can see the project.
	$this->assertTrue((bool)$this->refreshProject($proj, $user));
	$this->assertTrue((bool)$this->refreshProject($proj, $user2));


	// When the view policy is set to "no one", members can still see the
	// project.
	$proj->setViewPolicy(PhabricatorPolicies::POLICY_NOONE);
	$proj->save();

	$this->assertTrue((bool)$this->refreshProject($proj, $user));
	$this->assertFalse((bool)$this->refreshProject($proj, $user2));
	}

	public function testIsViewerMemberOrWatcher() {
	$user1 = $this->createUser()
	->save();

	$user2 = $this->createUser()
	->save();

	$user3 = $this->createUser()
	->save();

	$proj1 = $this->createProject($user1);
	$proj1 = $this->refreshProject($proj1, $user1);

	$this->joinProject($proj1, $user1);
	$this->joinProject($proj1, $user3);
	$this->watchProject($proj1, $user3);

	$proj1 = $this->refreshProject($proj1, $user1);

	$this->assertTrue($proj1->isUserMember($user1->getPHID()));

	$proj1 = $this->refreshProject($proj1, $user1, false, true);

	$this->assertTrue($proj1->isUserMember($user1->getPHID()));
	$this->assertFalse($proj1->isUserWatcher($user1->getPHID()));

	$proj1 = $this->refreshProject($proj1, $user1, true, false);

	$this->assertTrue($proj1->isUserMember($user1->getPHID()));
	$this->assertFalse($proj1->isUserMember($user2->getPHID()));
	$this->assertTrue($proj1->isUserMember($user3->getPHID()));

	$proj1 = $this->refreshProject($proj1, $user1, true, true);

	$this->assertTrue($proj1->isUserMember($user1->getPHID()));
	$this->assertFalse($proj1->isUserMember($user2->getPHID()));
	$this->assertTrue($proj1->isUserMember($user3->getPHID()));

	$this->assertFalse($proj1->isUserWatcher($user1->getPHID()));
	$this->assertFalse($proj1->isUserWatcher($user2->getPHID()));
	$this->assertTrue($proj1->isUserWatcher($user3->getPHID()));
	}

	public function testEditProject() {
	$user = $this->createUser();
	$user->save();

	$user2 = $this->createUser();
	$user2->save();

	$proj = $this->createProject($user);


	// When edit and view policies are set to "user", anyone can edit.
	$proj->setViewPolicy(PhabricatorPolicies::POLICY_USER);
	$proj->setEditPolicy(PhabricatorPolicies::POLICY_USER);
	$proj->save();

	$this->assertTrue($this->attemptProjectEdit($proj, $user));


	// When edit policy is set to "no one", no one can edit.
	$proj->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
	$proj->save();

	$caught = null;
	try {
	$this->attemptProjectEdit($proj, $user);
	} catch (Exception $ex) {
	$caught = $ex;
	}
	$this->assertTrue($caught instanceof Exception);
	}

	public function testAncestorMembers() {
	$user1 = $this->createUser();
	$user1->save();

	$user2 = $this->createUser();
	$user2->save();

	$parent = $this->createProject($user1);
	$child = $this->createProject($user1, $parent);

	$this->joinProject($child, $user1);
	$this->joinProject($child, $user2);

	$project = id(new PhabricatorProjectQuery())
	->setViewer($user1)
	->withPHIDs(array($child->getPHID()))
	->needAncestorMembers(true)
	->executeOne();

	$members = array_fuse($project->getParentProject()->getMemberPHIDs());
	ksort($members);

	$expect = array_fuse(
	array(
	$user1->getPHID(),
	$user2->getPHID(),
	));
	ksort($expect);

	$this->assertEqual($expect, $members);
	}

	public function testAncestryQueries() {
	$user = $this->createUser();
	$user->save();

	$ancestor = $this->createProject($user);
	$parent = $this->createProject($user, $ancestor);
	$child = $this->createProject($user, $parent);

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withAncestorProjectPHIDs(array($ancestor->getPHID()))
	->execute();
	$this->assertEqual(2, count($projects));

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withParentProjectPHIDs(array($ancestor->getPHID()))
	->execute();
	$this->assertEqual(1, count($projects));
	$this->assertEqual(
	$parent->getPHID(),
	head($projects)->getPHID());

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withAncestorProjectPHIDs(array($ancestor->getPHID()))
	->withDepthBetween(2, null)
	->execute();
	$this->assertEqual(1, count($projects));
	$this->assertEqual(
	$child->getPHID(),
	head($projects)->getPHID());

	$parent2 = $this->createProject($user, $ancestor);
	$child2 = $this->createProject($user, $parent2);
	$grandchild2 = $this->createProject($user, $child2);

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withAncestorProjectPHIDs(array($ancestor->getPHID()))
	->execute();
	$this->assertEqual(5, count($projects));

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withParentProjectPHIDs(array($ancestor->getPHID()))
	->execute();
	$this->assertEqual(2, count($projects));

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withAncestorProjectPHIDs(array($ancestor->getPHID()))
	->withDepthBetween(2, null)
	->execute();
	$this->assertEqual(3, count($projects));

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withAncestorProjectPHIDs(array($ancestor->getPHID()))
	->withDepthBetween(3, null)
	->execute();
	$this->assertEqual(1, count($projects));

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withPHIDs(
	array(
	$child->getPHID(),
	$grandchild2->getPHID(),
	))
	->execute();
	$this->assertEqual(2, count($projects));
	}

	public function testMemberMaterialization() {
	$material_type = PhabricatorProjectMaterializedMemberEdgeType::EDGECONST;

	$user = $this->createUser();
	$user->save();

	$parent = $this->createProject($user);
	$child = $this->createProject($user, $parent);

	$this->joinProject($child, $user);

	$parent_material = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$parent->getPHID(),
	$material_type);

	$this->assertEqual(
	array($user->getPHID()),
	$parent_material);
	}

	public function testMilestones() {
	$user = $this->createUser();
	$user->save();

	$parent = $this->createProject($user);

	$m1 = $this->createProject($user, $parent, true);
	$m2 = $this->createProject($user, $parent, true);
	$m3 = $this->createProject($user, $parent, true);

	$this->assertEqual(1, $m1->getMilestoneNumber());
	$this->assertEqual(2, $m2->getMilestoneNumber());
	$this->assertEqual(3, $m3->getMilestoneNumber());
	}

	public function testMilestoneMembership() {
	$user = $this->createUser();
	$user->save();

	$parent = $this->createProject($user);
	$milestone = $this->createProject($user, $parent, true);

	$this->joinProject($parent, $user);

	$milestone = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withPHIDs(array($milestone->getPHID()))
	->executeOne();

	$this->assertTrue($milestone->isUserMember($user->getPHID()));

	$milestone = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withPHIDs(array($milestone->getPHID()))
	->needMembers(true)
	->executeOne();

	$this->assertEqual(
	array($user->getPHID()),
	$milestone->getMemberPHIDs());
	}

	public function testSameSlugAsName() {
	// It should be OK to type the primary hashtag into "additional hashtags",
	// even if the primary hashtag doesn't exist yet because you're creating
	// or renaming the project.

	$user = $this->createUser();
	$user->save();

	$project = $this->createProject($user);

	// In this first case, set the name and slugs at the same time.
	$name = 'slugproject';

	$xactions = array();
	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_NAME)
	->setNewValue($name);
	$this->applyTransactions($project, $user, $xactions);

	$xactions = array();
	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
	->setNewValue(array($name));
	$this->applyTransactions($project, $user, $xactions);

	$project = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withPHIDs(array($project->getPHID()))
	->needSlugs(true)
	->executeOne();

	$slugs = $project->getSlugs();
	$slugs = mpull($slugs, 'getSlug');

	$this->assertTrue(in_array($name, $slugs));

	// In this second case, set the name first and then the slugs separately.
	$name2 = 'slugproject2';
	$xactions = array();

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

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
	->setNewValue(array($name2));

	$this->applyTransactions($project, $user, $xactions);

	$project = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withPHIDs(array($project->getPHID()))
	->needSlugs(true)
	->executeOne();

	$slugs = $project->getSlugs();
	$slugs = mpull($slugs, 'getSlug');

	$this->assertTrue(in_array($name2, $slugs));
	}

	public function testDuplicateSlugs() {
	// Creating a project with multiple duplicate slugs should succeed.

	$user = $this->createUser();
	$user->save();

	$project = $this->createProject($user);

	$input = 'duplicate';

	$xactions = array();

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
	->setNewValue(array($input, $input));

	$this->applyTransactions($project, $user, $xactions);

	$project = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withPHIDs(array($project->getPHID()))
	->needSlugs(true)
	->executeOne();

	$slugs = $project->getSlugs();
	$slugs = mpull($slugs, 'getSlug');

	$this->assertTrue(in_array($input, $slugs));
	}

	public function testNormalizeSlugs() {
	// When a user creates a project with slug "XxX360n0sc0perXxX", normalize
	// it before writing it.

	$user = $this->createUser();
	$user->save();

	$project = $this->createProject($user);

	$input = 'NoRmAlIzE';
	$expect = 'normalize';

	$xactions = array();

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
	->setNewValue(array($input));

	$this->applyTransactions($project, $user, $xactions);

	$project = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withPHIDs(array($project->getPHID()))
	->needSlugs(true)
	->executeOne();

	$slugs = $project->getSlugs();
	$slugs = mpull($slugs, 'getSlug');

	$this->assertTrue(in_array($expect, $slugs));


	// If another user tries to add the same slug in denormalized form, it
	// should be caught and fail, even though the database version of the slug
	// is normalized.

	$project2 = $this->createProject($user);

	$xactions = array();

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
	->setNewValue(array($input));

	$caught = null;
	try {
	$this->applyTransactions($project2, $user, $xactions);
	} catch (PhabricatorApplicationTransactionValidationException $ex) {
	$caught = $ex;
	}

	$this->assertTrue((bool)$caught);
	}

	public function testProjectMembersVisibility() {
	// This is primarily testing that you can create a project and set the
	// visibility or edit policy to "Project Members" immediately.

	$user1 = $this->createUser();
	$user1->save();

	$user2 = $this->createUser();
	$user2->save();

	$project = PhabricatorProject::initializeNewProject($user1);
	$name = pht('Test Project %d', mt_rand());

	$xactions = array();

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

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
	->setNewValue(
	id(new PhabricatorProjectMembersPolicyRule())
	->getObjectPolicyFullKey());

	$edge_type = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $edge_type)
	->setNewValue(
	array(
	'=' => array($user1->getPHID() => $user1->getPHID()),
	));

	$this->applyTransactions($project, $user1, $xactions);

	$this->assertTrue((bool)$this->refreshProject($project, $user1));
	$this->assertFalse((bool)$this->refreshProject($project, $user2));

	$this->leaveProject($project, $user1);

	$this->assertFalse((bool)$this->refreshProject($project, $user1));
	}

	public function testParentProject() {
	$user = $this->createUser();
	$user->save();

	$parent = $this->createProject($user);
	$child = $this->createProject($user, $parent);

	$this->assertTrue(true);

	$child = $this->refreshProject($child, $user);

	$this->assertEqual(
	$parent->getPHID(),
	$child->getParentProject()->getPHID());

	$this->assertEqual(1, (int)$child->getProjectDepth());

	$this->assertFalse(
	$child->isUserMember($user->getPHID()));

	$this->assertFalse(
	$child->getParentProject()->isUserMember($user->getPHID()));

	$this->joinProject($child, $user);

	$child = $this->refreshProject($child, $user);

	$this->assertTrue(
	$child->isUserMember($user->getPHID()));

	$this->assertTrue(
	$child->getParentProject()->isUserMember($user->getPHID()));


	// Test that hiding a parent hides the child.

	$user2 = $this->createUser();
	$user2->save();

	// Second user can see the project for now.
	$this->assertTrue((bool)$this->refreshProject($child, $user2));

	// Hide the parent.
	$this->setViewPolicy($parent, $user, $user->getPHID());

	// First user (who can see the parent because they are a member of
	// the child) can see the project.
	$this->assertTrue((bool)$this->refreshProject($child, $user));

	// Second user can not, because they can't see the parent.
	$this->assertFalse((bool)$this->refreshProject($child, $user2));
	}

	public function testSlugMaps() {
	// When querying by slugs, slugs should be normalized and the mapping
	// should be reported correctly.
	$user = $this->createUser();
	$user->save();

	$name = 'queryslugproject';
	$name2 = 'QUERYslugPROJECT';
	$slug = 'queryslugextra';
	$slug2 = 'QuErYSlUgExTrA';

	$project = PhabricatorProject::initializeNewProject($user);

	$xactions = array();

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

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
	->setNewValue(array($slug));

	$this->applyTransactions($project, $user, $xactions);

	$project_query = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withSlugs(array($name));
	$project_query->execute();
	$map = $project_query->getSlugMap();

	$this->assertEqual(
	array(
	$name => $project->getPHID(),
	),
	ipull($map, 'projectPHID'));

	$project_query = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withSlugs(array($slug));
	$project_query->execute();
	$map = $project_query->getSlugMap();

	$this->assertEqual(
	array(
	$slug => $project->getPHID(),
	),
	ipull($map, 'projectPHID'));

	$project_query = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withSlugs(array($name, $slug, $name2, $slug2));
	$project_query->execute();
	$map = $project_query->getSlugMap();

	$expect = array(
	$name => $project->getPHID(),
	$slug => $project->getPHID(),
	$name2 => $project->getPHID(),
	$slug2 => $project->getPHID(),
	);

	$actual = ipull($map, 'projectPHID');

	ksort($expect);
	ksort($actual);

	$this->assertEqual($expect, $actual);

	$expect = array(
	$name => $name,
	$slug => $slug,
	$name2 => $name,
	$slug2 => $slug,
	);

	$actual = ipull($map, 'slug');

	ksort($expect);
	ksort($actual);

	$this->assertEqual($expect, $actual);
	}

	public function testJoinLeaveProject() {
	$user = $this->createUser();
	$user->save();

	$proj = $this->createProjectWithNewAuthor();

	$proj = $this->refreshProject($proj, $user, true);
	$this->assertTrue(
	(bool)$proj,
	pht(
	'Assumption that projects are default visible '.
	'to any user when created.'));

	$this->assertFalse(
	$proj->isUserMember($user->getPHID()),
	pht('Arbitrary user not member of project.'));

	// Join the project.
	$this->joinProject($proj, $user);

	$proj = $this->refreshProject($proj, $user, true);
	$this->assertTrue((bool)$proj);

	$this->assertTrue(
	$proj->isUserMember($user->getPHID()),
	pht('Join works.'));


	// Join the project again.
	$this->joinProject($proj, $user);

	$proj = $this->refreshProject($proj, $user, true);
	$this->assertTrue((bool)$proj);

	$this->assertTrue(
	$proj->isUserMember($user->getPHID()),
	pht('Joining an already-joined project is a no-op.'));


	// Leave the project.
	$this->leaveProject($proj, $user);

	$proj = $this->refreshProject($proj, $user, true);
	$this->assertTrue((bool)$proj);

	$this->assertFalse(
	$proj->isUserMember($user->getPHID()),
	pht('Leave works.'));


	// Leave the project again.
	$this->leaveProject($proj, $user);

	$proj = $this->refreshProject($proj, $user, true);
	$this->assertTrue((bool)$proj);

	$this->assertFalse(
	$proj->isUserMember($user->getPHID()),
	pht('Leaving an already-left project is a no-op.'));


	// If a user can't edit or join a project, joining fails.
	$proj->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
	$proj->setJoinPolicy(PhabricatorPolicies::POLICY_NOONE);
	$proj->save();

	$proj = $this->refreshProject($proj, $user, true);
	$caught = null;
	try {
	$this->joinProject($proj, $user);
	} catch (Exception $ex) {
	$caught = $ex;
	}
	$this->assertTrue($ex instanceof Exception);


	// If a user can edit a project, they can join.
	$proj->setEditPolicy(PhabricatorPolicies::POLICY_USER);
	$proj->setJoinPolicy(PhabricatorPolicies::POLICY_NOONE);
	$proj->save();

	$proj = $this->refreshProject($proj, $user, true);
	$this->joinProject($proj, $user);
	$proj = $this->refreshProject($proj, $user, true);
	$this->assertTrue(
	$proj->isUserMember($user->getPHID()),
	pht('Join allowed with edit permission.'));
	$this->leaveProject($proj, $user);


	// If a user can join a project, they can join, even if they can't edit.
	$proj->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
	$proj->setJoinPolicy(PhabricatorPolicies::POLICY_USER);
	$proj->save();

	$proj = $this->refreshProject($proj, $user, true);
	$this->joinProject($proj, $user);
	$proj = $this->refreshProject($proj, $user, true);
	$this->assertTrue(
	$proj->isUserMember($user->getPHID()),
	pht('Join allowed with join permission.'));


	// A user can leave a project even if they can't edit it or join.
	$proj->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
	$proj->setJoinPolicy(PhabricatorPolicies::POLICY_NOONE);
	$proj->save();

	$proj = $this->refreshProject($proj, $user, true);
	$this->leaveProject($proj, $user);
	$proj = $this->refreshProject($proj, $user, true);
	$this->assertFalse(
	$proj->isUserMember($user->getPHID()),
	pht('Leave allowed without any permission.'));
	}


	public function testComplexConstraints() {
	$user = $this->createUser();
	$user->save();

	$engineering = $this->createProject($user);
	$engineering_scan = $this->createProject($user, $engineering);
	$engineering_warp = $this->createProject($user, $engineering);

	$exploration = $this->createProject($user);
	$exploration_diplomacy = $this->createProject($user, $exploration);

	$task_engineering = $this->newTask(
	$user,
	array($engineering),
	pht('Engineering Only'));

	$task_exploration = $this->newTask(
	$user,
	array($exploration),
	pht('Exploration Only'));

	$task_warp_explore = $this->newTask(
	$user,
	array($engineering_warp, $exploration),
	pht('Warp to New Planet'));

	$task_diplomacy_scan = $this->newTask(
	$user,
	array($engineering_scan, $exploration_diplomacy),
	pht('Scan Diplomat'));

	$task_diplomacy = $this->newTask(
	$user,
	array($exploration_diplomacy),
	pht('Diplomatic Meeting'));

	$task_warp_scan = $this->newTask(
	$user,
	array($engineering_scan, $engineering_warp),
	pht('Scan Warp Drives'));

	$this->assertQueryByProjects(
	$user,
	array(
	$task_engineering,
	$task_warp_explore,
	$task_diplomacy_scan,
	$task_warp_scan,
	),
	array($engineering),
	pht('All Engineering'));

	$this->assertQueryByProjects(
	$user,
	array(
	$task_diplomacy_scan,
	$task_warp_scan,
	),
	array($engineering_scan),
	pht('All Scan'));

	$this->assertQueryByProjects(
	$user,
	array(
	$task_warp_explore,
	$task_diplomacy_scan,
	),
	array($engineering, $exploration),
	pht('Engineering + Exploration'));

	// This is testing that a query for "Parent" and "Parent > Child" works
	// properly.
	$this->assertQueryByProjects(
	$user,
	array(
	$task_diplomacy_scan,
	$task_warp_scan,
	),
	array($engineering, $engineering_scan),
	pht('Engineering + Scan'));
	}

	public function testTagAncestryConflicts() {
	$user = $this->createUser();
	$user->save();

	$stonework = $this->createProject($user);
	$stonework_masonry = $this->createProject($user, $stonework);
	$stonework_sculpting = $this->createProject($user, $stonework);

	$task = $this->newTask($user, array());
	$this->assertEqual(array(), $this->getTaskProjects($task));

	$this->addProjectTags($user, $task, array($stonework->getPHID()));
	$this->assertEqual(
	array(
	$stonework->getPHID(),
	),
	$this->getTaskProjects($task));

	// Adding a descendant should remove the parent.
	$this->addProjectTags($user, $task, array($stonework_masonry->getPHID()));
	$this->assertEqual(
	array(
	$stonework_masonry->getPHID(),
	),
	$this->getTaskProjects($task));

	// Adding an ancestor should remove the descendant.
	$this->addProjectTags($user, $task, array($stonework->getPHID()));
	$this->assertEqual(
	array(
	$stonework->getPHID(),
	),
	$this->getTaskProjects($task));

	// Adding two tags in the same hierarchy which are not mutual ancestors
	// should remove the ancestor but otherwise work fine.
	$this->addProjectTags(
	$user,
	$task,
	array(
	$stonework_masonry->getPHID(),
	$stonework_sculpting->getPHID(),
	));

	$expect = array(
	$stonework_masonry->getPHID(),
	$stonework_sculpting->getPHID(),
	);
	sort($expect);

	$this->assertEqual($expect, $this->getTaskProjects($task));
	}

	public function testTagMilestoneConflicts() {
	$user = $this->createUser();
	$user->save();

	$stonework = $this->createProject($user);
	$stonework_1 = $this->createProject($user, $stonework, true);
	$stonework_2 = $this->createProject($user, $stonework, true);

	$task = $this->newTask($user, array());
	$this->assertEqual(array(), $this->getTaskProjects($task));

	$this->addProjectTags($user, $task, array($stonework->getPHID()));
	$this->assertEqual(
	array(
	$stonework->getPHID(),
	),
	$this->getTaskProjects($task));

	// Adding a milesone should remove the parent.
	$this->addProjectTags($user, $task, array($stonework_1->getPHID()));
	$this->assertEqual(
	array(
	$stonework_1->getPHID(),
	),
	$this->getTaskProjects($task));

	// Adding the parent should remove the milestone.
	$this->addProjectTags($user, $task, array($stonework->getPHID()));
	$this->assertEqual(
	array(
	$stonework->getPHID(),
	),
	$this->getTaskProjects($task));

	// First, add one milestone.
	$this->addProjectTags($user, $task, array($stonework_1->getPHID()));
	// Now, adding a second milestone should remove the first milestone.
	$this->addProjectTags($user, $task, array($stonework_2->getPHID()));
	$this->assertEqual(
	array(
	$stonework_2->getPHID(),
	),
	$this->getTaskProjects($task));
	}

	+ public function testBoardMoves() {
	+ $user = $this->createUser();
	+ $user->save();
	+
	+ $board = $this->createProject($user);
	+
	+ $backlog = $this->addColumn($user, $board, 0);
	+ $column = $this->addColumn($user, $board, 1);
	+
	+ // New tasks should appear in the backlog.
	+ $task1 = $this->newTask($user, array($board));
	+ $expect = array(
	+ $backlog->getPHID(),
	+ );
	+ $this->assertColumns($expect, $user, $board, $task1);
	+
	+ // Moving a task should move it to the destination column.
	+ $this->moveToColumn($user, $board, $task1, $backlog, $column);
	+ $expect = array(
	+ $column->getPHID(),
	+ );
	+ $this->assertColumns($expect, $user, $board, $task1);
	+
	+ // Same thing again, with a new task.
	+ $task2 = $this->newTask($user, array($board));
	+ $expect = array(
	+ $backlog->getPHID(),
	+ );
	+ $this->assertColumns($expect, $user, $board, $task2);
	+
	+ // Move it, too.
	+ $this->moveToColumn($user, $board, $task2, $backlog, $column);
	+ $expect = array(
	+ $column->getPHID(),
	+ );
	+ $this->assertColumns($expect, $user, $board, $task2);
	+
	+ // Now the stuff should be in the column, in order, with the more recently
	+ // moved task on top.
	+ $expect = array(
	+ $task2->getPHID(),
	+ $task1->getPHID(),
	+ );
	+ $this->assertTasksInColumn($expect, $user, $board, $column);
	+
	+ // Move the second task after the first task.
	+ $options = array(
	+ 'afterPHID' => $task1->getPHID(),
	+ );
	+ $this->moveToColumn($user, $board, $task2, $column, $column, $options);
	+ $expect = array(
	+ $task1->getPHID(),
	+ $task2->getPHID(),
	+ );
	+ $this->assertTasksInColumn($expect, $user, $board, $column);
	+
	+ // Move the second task before the first task.
	+ $options = array(
	+ 'beforePHID' => $task1->getPHID(),
	+ );
	+ $this->moveToColumn($user, $board, $task2, $column, $column, $options);
	+ $expect = array(
	+ $task2->getPHID(),
	+ $task1->getPHID(),
	+ );
	+ $this->assertTasksInColumn($expect, $user, $board, $column);
	+
	+ }
	+
	+ private function moveToColumn(
	+ PhabricatorUser $viewer,
	+ PhabricatorProject $board,
	+ ManiphestTask $task,
	+ PhabricatorProjectColumn $src,
	+ PhabricatorProjectColumn $dst,
	+ $options = null) {
	+
	+ $xactions = array();
	+
	+ if (!$options) {
	+ $options = array();
	+ }
	+
	+ $xactions[] = id(new ManiphestTransaction())
	+ ->setTransactionType(ManiphestTransaction::TYPE_PROJECT_COLUMN)
	+ ->setOldValue(
	+ array(
	+ 'projectPHID' => $board->getPHID(),
	+ 'columnPHIDs' => array($src->getPHID()),
	+ ))
	+ ->setNewValue(
	+ array(
	+ 'projectPHID' => $board->getPHID(),
	+ 'columnPHIDs' => array($dst->getPHID()),
	+ ) + $options);
	+
	+ $editor = id(new ManiphestTransactionEditor())
	+ ->setActor($viewer)
	+ ->setContentSource(PhabricatorContentSource::newConsoleSource())
	+ ->setContinueOnNoEffect(true)
	+ ->applyTransactions($task, $xactions);
	+ }
	+
	+ private function assertColumns(
	+ array $expect,
	+ PhabricatorUser $viewer,
	+ PhabricatorProject $board,
	+ ManiphestTask $task) {
	+
	+ $engine = id(new PhabricatorBoardLayoutEngine())
	+ ->setViewer($viewer)
	+ ->setBoardPHIDs(array($board->getPHID()))
	+ ->setObjectPHIDs(
	+ array(
	+ $task->getPHID(),
	+ ))
	+ ->executeLayout();
	+
	+ $columns = $engine->getObjectColumns($board->getPHID(), $task->getPHID());
	+ $column_phids = mpull($columns, 'getPHID');
	+ $column_phids = array_values($column_phids);
	+
	+ $this->assertEqual($expect, $column_phids);
	+ }
	+
	+ private function assertTasksInColumn(
	+ array $expect,
	+ PhabricatorUser $viewer,
	+ PhabricatorProject $board,
	+ PhabricatorProjectColumn $column) {
	+
	+ $engine = id(new PhabricatorBoardLayoutEngine())
	+ ->setViewer($viewer)
	+ ->setBoardPHIDs(array($board->getPHID()))
	+ ->setObjectPHIDs($expect)
	+ ->executeLayout();
	+
	+ $object_phids = $engine->getColumnObjectPHIDs(
	+ $board->getPHID(),
	+ $column->getPHID());
	+ $object_phids = array_values($object_phids);
	+
	+ $this->assertEqual($expect, $object_phids);
	+ }
	+
	+ private function addColumn(
	+ PhabricatorUser $viewer,
	+ PhabricatorProject $project,
	+ $sequence) {
	+
	+ $project->setHasWorkboard(1)->save();
	+
	+ return PhabricatorProjectColumn::initializeNewColumn($viewer)
	+ ->setSequence(0)
	+ ->setProperty('isDefault', ($sequence == 0))
	+ ->setProjectPHID($project->getPHID())
	+ ->save();
	+ }
	+
	private function getTaskProjects(ManiphestTask $task) {
	$project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$task->getPHID(),
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);

	sort($project_phids);

	return $project_phids;
	}

	private function attemptProjectEdit(
	PhabricatorProject $proj,
	PhabricatorUser $user,
	$skip_refresh = false) {

	$proj = $this->refreshProject($proj, $user, true);

	$new_name = $proj->getName().' '.mt_rand();

	$xaction = new PhabricatorProjectTransaction();
	$xaction->setTransactionType(PhabricatorProjectTransaction::TYPE_NAME);
	$xaction->setNewValue($new_name);

	$this->applyTransactions($proj, $user, array($xaction));

	return true;
	}


	private function addProjectTags(
	PhabricatorUser $viewer,
	ManiphestTask $task,
	array $phids) {

	$xactions = array();

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue(
	'edge:type',
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST)
	->setNewValue(
	array(
	'+' => array_fuse($phids),
	));

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

	private function newTask(
	PhabricatorUser $viewer,
	array $projects,
	$name = null) {

	$task = ManiphestTask::initializeNewTask($viewer);

	if (!strlen($name)) {
	$name = pht('Test Task');
	}

	$xactions = array();

	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(ManiphestTransaction::TYPE_TITLE)
	->setNewValue($name);

	if ($projects) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue(
	'edge:type',
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST)
	->setNewValue(
	array(
	'=' => array_fuse(mpull($projects, 'getPHID')),
	));
	}

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

	return $task;
	}

	private function assertQueryByProjects(
	PhabricatorUser $viewer,
	array $expect,
	array $projects,
	$label = null) {

	$datasource = id(new PhabricatorProjectLogicalDatasource())
	->setViewer($viewer);

	$project_phids = mpull($projects, 'getPHID');
	$constraints = $datasource->evaluateTokens($project_phids);

	$query = id(new ManiphestTaskQuery())
	->setViewer($viewer);

	$query->withEdgeLogicConstraints(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	$constraints);

	$tasks = $query->execute();

	$expect_phids = mpull($expect, 'getTitle', 'getPHID');
	ksort($expect_phids);

	$actual_phids = mpull($tasks, 'getTitle', 'getPHID');
	ksort($actual_phids);

	$this->assertEqual($expect_phids, $actual_phids, $label);
	}

	private function refreshProject(
	PhabricatorProject $project,
	PhabricatorUser $viewer,
	$need_members = false,
	$need_watchers = false) {

	$results = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->needMembers($need_members)
	->needWatchers($need_watchers)
	->withIDs(array($project->getID()))
	->execute();

	if ($results) {
	return head($results);
	} else {
	return null;
	}
	}

	private function createProject(
	PhabricatorUser $user,
	PhabricatorProject $parent = null,
	$is_milestone = false) {

	$project = PhabricatorProject::initializeNewProject($user);


	$name = pht('Test Project %d', mt_rand());

	$xactions = array();

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

	if ($parent) {
	if ($is_milestone) {
	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_MILESTONE)
	->setNewValue($parent->getPHID());
	} else {
	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_PARENT)
	->setNewValue($parent->getPHID());
	}
	}

	$this->applyTransactions($project, $user, $xactions);

	return $project;
	}

	private function setViewPolicy(
	PhabricatorProject $project,
	PhabricatorUser $user,
	$policy) {

	$xactions = array();

	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
	->setNewValue($policy);

	$this->applyTransactions($project, $user, $xactions);

	return $project;
	}

	private function createProjectWithNewAuthor() {
	$author = $this->createUser();
	$author->save();

	$project = $this->createProject($author);

	return $project;
	}

	private function createUser() {
	$rand = mt_rand();

	$user = new PhabricatorUser();
	$user->setUsername('unittestuser'.$rand);
	$user->setRealName(pht('Unit Test User %d', $rand));

	return $user;
	}

	private function joinProject(
	PhabricatorProject $project,
	PhabricatorUser $user) {
	return $this->joinOrLeaveProject($project, $user, '+');
	}

	private function leaveProject(
	PhabricatorProject $project,
	PhabricatorUser $user) {
	return $this->joinOrLeaveProject($project, $user, '-');
	}

	private function watchProject(
	PhabricatorProject $project,
	PhabricatorUser $user) {
	return $this->watchOrUnwatchProject($project, $user, '+');
	}

	private function unwatchProject(
	PhabricatorProject $project,
	PhabricatorUser $user) {
	return $this->watchOrUnwatchProject($project, $user, '-');
	}

	private function joinOrLeaveProject(
	PhabricatorProject $project,
	PhabricatorUser $user,
	$operation) {
	return $this->applyProjectEdgeTransaction(
	$project,
	$user,
	$operation,
	PhabricatorProjectProjectHasMemberEdgeType::EDGECONST);
	}

	private function watchOrUnwatchProject(
	PhabricatorProject $project,
	PhabricatorUser $user,
	$operation) {
	return $this->applyProjectEdgeTransaction(
	$project,
	$user,
	$operation,
	PhabricatorObjectHasWatcherEdgeType::EDGECONST);
	}

	private function applyProjectEdgeTransaction(
	PhabricatorProject $project,
	PhabricatorUser $user,
	$operation,
	$edge_type) {

	$spec = array(
	$operation => array($user->getPHID() => $user->getPHID()),
	);

	$xactions = array();
	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $edge_type)
	->setNewValue($spec);

	$this->applyTransactions($project, $user, $xactions);

	return $project;
	}

	private function applyTransactions(
	PhabricatorProject $project,
	PhabricatorUser $user,
	array $xactions) {

	$editor = id(new PhabricatorProjectTransactionEditor())
	->setActor($user)
	->setContentSource(PhabricatorContentSource::newConsoleSource())
	->setContinueOnNoEffect(true)
	->applyTransactions($project, $xactions);
	}


	}
	diff --git a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	index 8a6143c81d..e578131c83 100644
	--- a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	+++ b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
	@@ -1,412 +1,412 @@
	<?php

	final class PhabricatorBoardLayoutEngine extends Phobject {

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

	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 = $board_phids;
	+ $this->boardPHIDs = array_fuse($board_phids);
	return $this;
	}

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

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

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

	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 getColumnObjectPHIDs($board_phid, $column_phid) {
	$columns = idx($this->boardLayout, $board_phid, array());
	$positions = idx($columns, $column_phid, array());
	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');

	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, 'getSequence');
	$columns = mpull($columns, null, 'getPHID');

	$this->columnMap = $columns;
	$columns = mgroup($columns, 'getProjectPHID');

	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) {

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

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

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

	$object_phids = $this->getObjectPHIDs();
	foreach ($object_phids as $object_phid) {
	$positions = idx($position_groups, $object_phid, array());

	// Remove any positions in columns which no longer exist.
	foreach ($positions as $key => $position) {
	$column_phid = $position->getColumnPHID();
	if (empty($columns[$column_phid])) {
	$this->remQueue[] = $position;
	unset($positions[$key]);
	}
	}

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

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 10, 3:19 PM (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 140446
Default Alt Text: (50 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions