No OneTemporary
Actions

Size

46 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 4b0742e5d7..f6b74801e6 100644
	--- a/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php
	+++ b/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php
	@@ -1,691 +1,755 @@
	<?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 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 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));
	}

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

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

	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) {
	$xactions[] = id(new PhabricatorProjectTransaction())
	->setTransactionType(PhabricatorProjectTransaction::TYPE_PARENT)
	->setNewValue($parent->getPHID());
	}

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

	$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/editor/PhabricatorProjectTransactionEditor.php b/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
	index ad87e77967..ff9b23e477 100644
	--- a/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
	+++ b/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
	@@ -1,657 +1,663 @@
	<?php

	final class PhabricatorProjectTransactionEditor
	extends PhabricatorApplicationTransactionEditor {

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

	public function getEditorObjectsDescription() {
	return pht('Projects');
	}

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

	$types[] = PhabricatorTransactions::TYPE_EDGE;
	$types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
	$types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
	$types[] = PhabricatorTransactions::TYPE_JOIN_POLICY;

	$types[] = PhabricatorProjectTransaction::TYPE_NAME;
	$types[] = PhabricatorProjectTransaction::TYPE_SLUGS;
	$types[] = PhabricatorProjectTransaction::TYPE_STATUS;
	$types[] = PhabricatorProjectTransaction::TYPE_IMAGE;
	$types[] = PhabricatorProjectTransaction::TYPE_ICON;
	$types[] = PhabricatorProjectTransaction::TYPE_COLOR;
	$types[] = PhabricatorProjectTransaction::TYPE_LOCKED;
	$types[] = PhabricatorProjectTransaction::TYPE_PARENT;
	$types[] = PhabricatorProjectTransaction::TYPE_MILESTONE;

	return $types;
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectTransaction::TYPE_NAME:
	return $object->getName();
	case PhabricatorProjectTransaction::TYPE_SLUGS:
	$slugs = $object->getSlugs();
	$slugs = mpull($slugs, 'getSlug', 'getSlug');
	unset($slugs[$object->getPrimarySlug()]);
	return array_keys($slugs);
	case PhabricatorProjectTransaction::TYPE_STATUS:
	return $object->getStatus();
	case PhabricatorProjectTransaction::TYPE_IMAGE:
	return $object->getProfileImagePHID();
	case PhabricatorProjectTransaction::TYPE_ICON:
	return $object->getIcon();
	case PhabricatorProjectTransaction::TYPE_COLOR:
	return $object->getColor();
	case PhabricatorProjectTransaction::TYPE_LOCKED:
	return (int)$object->getIsMembershipLocked();
	case PhabricatorProjectTransaction::TYPE_PARENT:
	case PhabricatorProjectTransaction::TYPE_MILESTONE:
	return null;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectTransaction::TYPE_NAME:
	case PhabricatorProjectTransaction::TYPE_STATUS:
	case PhabricatorProjectTransaction::TYPE_IMAGE:
	case PhabricatorProjectTransaction::TYPE_ICON:
	case PhabricatorProjectTransaction::TYPE_COLOR:
	case PhabricatorProjectTransaction::TYPE_LOCKED:
	case PhabricatorProjectTransaction::TYPE_PARENT:
	return $xaction->getNewValue();
	case PhabricatorProjectTransaction::TYPE_SLUGS:
	return $this->normalizeSlugs($xaction->getNewValue());
	case PhabricatorProjectTransaction::TYPE_MILESTONE:
	$current = queryfx_one(
	$object->establishConnection('w'),
	'SELECT MAX(milestoneNumber) n
	FROM %T
	WHERE parentProjectPHID = %s',
	$object->getTableName(),
	$object->getParentProject()->getPHID());
	if (!$current) {
	$number = 1;
	} else {
	$number = (int)$current['n'] + 1;
	}
	return $number;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectTransaction::TYPE_NAME:
	$name = $xaction->getNewValue();
	$object->setName($name);
	$object->setPrimarySlug(PhabricatorSlug::normalizeProjectSlug($name));
	return;
	case PhabricatorProjectTransaction::TYPE_SLUGS:
	return;
	case PhabricatorProjectTransaction::TYPE_STATUS:
	$object->setStatus($xaction->getNewValue());
	return;
	case PhabricatorProjectTransaction::TYPE_IMAGE:
	$object->setProfileImagePHID($xaction->getNewValue());
	return;
	case PhabricatorProjectTransaction::TYPE_ICON:
	$object->setIcon($xaction->getNewValue());
	return;
	case PhabricatorProjectTransaction::TYPE_COLOR:
	$object->setColor($xaction->getNewValue());
	return;
	case PhabricatorProjectTransaction::TYPE_LOCKED:
	$object->setIsMembershipLocked($xaction->getNewValue());
	return;
	case PhabricatorProjectTransaction::TYPE_PARENT:
	$object->setParentProjectPHID($xaction->getNewValue());
	return;
	case PhabricatorProjectTransaction::TYPE_MILESTONE:
	$object->setMilestoneNumber($xaction->getNewValue());
	return;
	}

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

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectTransaction::TYPE_NAME:
	// First, add the old name as a secondary slug; this is helpful
	// for renames and generally a good thing to do.
	if ($old !== null) {
	- $this->addSlug($object, $old);
	+ $this->addSlug($object, $old, false);
	}
	- $this->addSlug($object, $new);
	+ $this->addSlug($object, $new, false);

	return;
	case PhabricatorProjectTransaction::TYPE_SLUGS:
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();
	$add = array_diff($new, $old);
	$rem = array_diff($old, $new);

	- if ($add) {
	- $add_slug_template = id(new PhabricatorProjectSlug())
	- ->setProjectPHID($object->getPHID());
	- foreach ($add as $add_slug_str) {
	- $add_slug = id(clone $add_slug_template)
	- ->setSlug($add_slug_str)
	- ->save();
	- }
	- }
	- if ($rem) {
	- $rem_slugs = id(new PhabricatorProjectSlug())
	- ->loadAllWhere('slug IN (%Ls)', $rem);
	- foreach ($rem_slugs as $rem_slug) {
	- $rem_slug->delete();
	- }
	+ foreach ($add as $slug) {
	+ $this->addSlug($object, $slug, true);
	}

	+ $this->removeSlugs($object, $rem);
	return;
	case PhabricatorProjectTransaction::TYPE_STATUS:
	case PhabricatorProjectTransaction::TYPE_IMAGE:
	case PhabricatorProjectTransaction::TYPE_ICON:
	case PhabricatorProjectTransaction::TYPE_COLOR:
	case PhabricatorProjectTransaction::TYPE_LOCKED:
	case PhabricatorProjectTransaction::TYPE_PARENT:
	case PhabricatorProjectTransaction::TYPE_MILESTONE:
	return;
	}

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

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_EDGE:
	$edge_type = $xaction->getMetadataValue('edge:type');
	switch ($edge_type) {
	case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
	case PhabricatorObjectHasWatcherEdgeType::EDGECONST:
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	// When adding members or watchers, we add subscriptions.
	$add = array_keys(array_diff_key($new, $old));

	// When removing members, we remove their subscription too.
	// When unwatching, we leave subscriptions, since it's fine to be
	// subscribed to a project but not be a member of it.
	$edge_const = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;
	if ($edge_type == $edge_const) {
	$rem = array_keys(array_diff_key($old, $new));
	} else {
	$rem = array();
	}

	// NOTE: The subscribe is "explicit" because there's no implicit
	// unsubscribe, so Join -> Leave -> Join doesn't resubscribe you
	// if we use an implicit subscribe, even though you never willfully
	// unsubscribed. Not sure if adding implicit unsubscribe (which
	// would not write the unsubscribe row) is justified to deal with
	// this, which is a fairly weird edge case and pretty arguable both
	// ways.

	// Subscriptions caused by watches should also clearly be explicit,
	// and that case is unambiguous.

	id(new PhabricatorSubscriptionsEditor())
	->setActor($this->requireActor())
	->setObject($object)
	->subscribeExplicit($add)
	->unsubscribe($rem)
	->save();

	if ($rem) {
	// When removing members, also remove any watches on the project.
	$edge_editor = new PhabricatorEdgeEditor();
	foreach ($rem as $rem_phid) {
	$edge_editor->removeEdge(
	$object->getPHID(),
	PhabricatorObjectHasWatcherEdgeType::EDGECONST,
	$rem_phid);
	}
	$edge_editor->save();
	}
	break;
	}
	break;
	}

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

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

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

	switch ($type) {
	case PhabricatorProjectTransaction::TYPE_NAME:
	$missing = $this->validateIsEmptyTextField(
	$object->getName(),
	$xactions);

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

	$error->setIsMissingFieldError(true);
	$errors[] = $error;
	}

	if (!$xactions) {
	break;
	}

	$name = last($xactions)->getNewValue();
	$name_used_already = id(new PhabricatorProjectQuery())
	->setViewer($this->getActor())
	->withNames(array($name))
	->executeOne();
	if ($name_used_already &&
	($name_used_already->getPHID() != $object->getPHID())) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Duplicate'),
	pht('Project name is already used.'),
	nonempty(last($xactions), null));
	$errors[] = $error;
	}

	$slug = PhabricatorSlug::normalizeProjectSlug($name);

	$slug_used_already = id(new PhabricatorProjectSlug())
	->loadOneWhere('slug = %s', $slug);
	if ($slug_used_already &&
	$slug_used_already->getProjectPHID() != $object->getPHID()) {
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Duplicate'),
	pht('Project name can not be used due to hashtag collision.'),
	nonempty(last($xactions), null));
	$errors[] = $error;
	}
	break;
	case PhabricatorProjectTransaction::TYPE_SLUGS:
	if (!$xactions) {
	break;
	}

	$slug_xaction = last($xactions);

	$new = $slug_xaction->getNewValue();
	$new = $this->normalizeSlugs($new);

	if ($new) {
	$slugs_used_already = id(new PhabricatorProjectSlug())
	->loadAllWhere('slug IN (%Ls)', $new);
	} else {
	// The project doesn't have any extra slugs.
	$slugs_used_already = array();
	}

	$slugs_used_already = mgroup($slugs_used_already, 'getProjectPHID');
	foreach ($slugs_used_already as $project_phid => $used_slugs) {
	- $used_slug_strs = mpull($used_slugs, 'getSlug');
	if ($project_phid == $object->getPHID()) {
	- if (in_array($object->getPrimarySlug(), $used_slug_strs)) {
	- $error = new PhabricatorApplicationTransactionValidationError(
	- $type,
	- pht('Invalid'),
	- pht(
	- 'Project hashtag "%s" is already the primary hashtag.',
	- $object->getPrimarySlug()),
	- $slug_xaction);
	- $errors[] = $error;
	- }
	continue;
	}

	+ $used_slug_strs = mpull($used_slugs, 'getSlug');
	+
	$error = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'%s project hashtag(s) are already used by other projects: %s.',
	phutil_count($used_slug_strs),
	implode(', ', $used_slug_strs)),
	$slug_xaction);
	$errors[] = $error;
	}

	break;
	case PhabricatorProjectTransaction::TYPE_PARENT:
	if (!$xactions) {
	break;
	}

	$xaction = last($xactions);

	if (!$this->getIsNewObject()) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'You can only set a parent project when creating a project '.
	'for the first time.'),
	$xaction);
	break;
	}

	$parent_phid = $xaction->getNewValue();

	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->requireActor())
	->withPHIDs(array($parent_phid))
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->execute();
	if (!$projects) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'Parent project PHID ("%s") must be the PHID of a valid, '.
	'visible project which you have permission to edit.',
	$parent_phid),
	$xaction);
	break;
	}

	$project = head($projects);

	if ($project->isMilestone()) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'Parent project PHID ("%s") must not be a milestone. '.
	'Milestones may not have subprojects.',
	$parent_phid),
	$xaction);
	break;
	}

	$limit = PhabricatorProject::getProjectDepthLimit();
	if ($project->getProjectDepth() >= ($limit - 1)) {
	$errors[] = new PhabricatorApplicationTransactionValidationError(
	$type,
	pht('Invalid'),
	pht(
	'You can not create a subproject under this parent because '.
	'it would nest projects too deeply. The maximum nesting '.
	'depth of projects is %s.',
	new PhutilNumber($limit)),
	$xaction);
	break;
	}

	$object->attachParentProject($project);
	break;
	}

	return $errors;
	}


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

	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectTransaction::TYPE_NAME:
	case PhabricatorProjectTransaction::TYPE_STATUS:
	case PhabricatorProjectTransaction::TYPE_IMAGE:
	case PhabricatorProjectTransaction::TYPE_ICON:
	case PhabricatorProjectTransaction::TYPE_COLOR:
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	return;
	case PhabricatorProjectTransaction::TYPE_LOCKED:
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	newv($this->getEditorApplicationClass(), array()),
	ProjectCanLockProjectsCapability::CAPABILITY);
	return;
	case PhabricatorTransactions::TYPE_EDGE:
	switch ($xaction->getMetadataValue('edge:type')) {
	case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	$add = array_keys(array_diff_key($new, $old));
	$rem = array_keys(array_diff_key($old, $new));

	$actor_phid = $this->requireActor()->getPHID();

	$is_join = (($add === array($actor_phid)) && !$rem);
	$is_leave = (($rem === array($actor_phid)) && !$add);

	if ($is_join) {
	// You need CAN_JOIN to join a project.
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_JOIN);
	} else if ($is_leave) {
	// You usually don't need any capabilities to leave a project.
	if ($object->getIsMembershipLocked()) {
	// you must be able to edit though to leave locked projects
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	}
	} else {
	// You need CAN_EDIT to change members other than yourself.
	PhabricatorPolicyFilter::requireCapability(
	$this->requireActor(),
	$object,
	PhabricatorPolicyCapability::CAN_EDIT);
	}
	return;
	}
	break;
	}

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

	protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
	$member_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
	$object->getPHID(),
	PhabricatorProjectProjectHasMemberEdgeType::EDGECONST);
	$object->attachMemberPHIDs($member_phids);

	return $object;
	}

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

	protected function getMailSubjectPrefix() {
	return pht('[Project]');
	}

	protected function getMailTo(PhabricatorLiskDAO $object) {
	return $object->getMemberPHIDs();
	}

	protected function getMailCC(PhabricatorLiskDAO $object) {
	$all = parent::getMailCC($object);
	return array_diff($all, $object->getMemberPHIDs());
	}

	public function getMailTagsMap() {
	return array(
	PhabricatorProjectTransaction::MAILTAG_METADATA =>
	pht('Project name, hashtags, icon, image, or color changes.'),
	PhabricatorProjectTransaction::MAILTAG_MEMBERS =>
	pht('Project membership changes.'),
	PhabricatorProjectTransaction::MAILTAG_WATCHERS =>
	pht('Project watcher list changes.'),
	PhabricatorProjectTransaction::MAILTAG_SUBSCRIBERS =>
	pht('Project subscribers change.'),
	PhabricatorProjectTransaction::MAILTAG_OTHER =>
	pht('Other project activity not listed above occurs.'),
	);
	}

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

	protected function buildMailTemplate(PhabricatorLiskDAO $object) {
	$id = $object->getID();
	$name = $object->getName();

	return id(new PhabricatorMetaMTAMail())
	->setSubject("{$name}")
	->addHeader('Thread-Topic', "Project {$id}");
	}

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

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

	$uri = '/project/profile/'.$object->getID().'/';
	$body->addLinkSection(
	pht('PROJECT DETAIL'),
	PhabricatorEnv::getProductionURI($uri));

	return $body;
	}

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

	protected function supportsSearch() {
	return true;
	}

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

	switch ($xaction->getTransactionType()) {
	case PhabricatorProjectTransaction::TYPE_IMAGE:
	$new = $xaction->getNewValue();
	if ($new) {
	return array($new);
	}
	break;
	}

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

	- private function addSlug(
	- PhabricatorLiskDAO $object,
	- $name) {
	-
	- $slug = PhabricatorSlug::normalizeProjectSlug($name);
	-
	- $slug_object = id(new PhabricatorProjectSlug())->loadOneWhere(
	- 'slug = %s',
	- $slug);
	-
	- if ($slug_object) {
	- return;
	- }
	-
	- $new_slug = id(new PhabricatorProjectSlug())
	- ->setSlug($slug)
	- ->setProjectPHID($object->getPHID())
	- ->save();
	- }
	-
	-
	protected function applyFinalEffects(
	PhabricatorLiskDAO $object,
	array $xactions) {

	$materialize = false;
	foreach ($xactions as $xaction) {
	switch ($xaction->getTransactionType()) {
	case PhabricatorTransactions::TYPE_EDGE:
	switch ($xaction->getMetadataValue('edge:type')) {
	case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
	$materialize = true;
	break;
	}
	break;
	case PhabricatorProjectTransaction::TYPE_PARENT:
	$materialize = true;
	break;
	}
	}

	if ($materialize) {
	id(new PhabricatorProjectsMembershipIndexEngineExtension())
	->rematerialize($object);
	}

	return parent::applyFinalEffects($object, $xactions);
	}

	+ private function addSlug(PhabricatorProject $project, $slug, $force) {
	+ $slug = PhabricatorSlug::normalizeProjectSlug($slug);
	+ $table = new PhabricatorProjectSlug();
	+ $project_phid = $project->getPHID();
	+
	+ if ($force) {
	+ // If we have the `$force` flag set, we only want to ignore an existing
	+ // slug if it's for the same project. We'll error on collisions with
	+ // other projects.
	+ $current = $table->loadOneWhere(
	+ 'slug = %s AND projectPHID = %s',
	+ $slug,
	+ $project_phid);
	+ } else {
	+ // Without the `$force` flag, we'll just return without doing anything
	+ // if any other project already has the slug.
	+ $current = $table->loadOneWhere(
	+ 'slug = %s',
	+ $slug);
	+ }
	+
	+ if ($current) {
	+ return;
	+ }
	+
	+ return id(new PhabricatorProjectSlug())
	+ ->setSlug($slug)
	+ ->setProjectPHID($project_phid)
	+ ->save();
	+ }
	+
	+ private function removeSlugs(PhabricatorProject $project, array $slugs) {
	+ $slugs = $this->normalizeSlugs($slugs);
	+
	+ if (!$slugs) {
	+ return;
	+ }
	+
	+ $objects = id(new PhabricatorProjectSlug())->loadAllWhere(
	+ 'projectPHID = %s AND slug IN (%Ls)',
	+ $project->getPHID(),
	+ $slugs);
	+
	+ foreach ($objects as $object) {
	+ $object->delete();
	+ }
	+ }
	+
	private function normalizeSlugs(array $slugs) {
	foreach ($slugs as $key => $slug) {
	$slugs[$key] = PhabricatorSlug::normalizeProjectSlug($slug);
	}

	$slugs = array_unique($slugs);
	$slugs = array_values($slugs);

	return $slugs;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Sep 7, 10:40 AM (22 h, 14 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 223161
Default Alt Text: (46 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions