No OneTemporary
Actions

Size

64 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/doorkeeper/DiffusionDoorkeeperCommitFeedStoryPublisher.php b/src/applications/diffusion/doorkeeper/DiffusionDoorkeeperCommitFeedStoryPublisher.php
	index 35fdbce886..75be3898cc 100644
	--- a/src/applications/diffusion/doorkeeper/DiffusionDoorkeeperCommitFeedStoryPublisher.php
	+++ b/src/applications/diffusion/doorkeeper/DiffusionDoorkeeperCommitFeedStoryPublisher.php
	@@ -1,196 +1,201 @@
	<?php

	final class DiffusionDoorkeeperCommitFeedStoryPublisher
	extends DoorkeeperFeedStoryPublisher {

	private $auditRequests;
	private $activePHIDs;
	private $passivePHIDs;

	private function getAuditRequests() {
	return $this->auditRequests;
	}

	public function canPublishStory(PhabricatorFeedStory $story, $object) {
	return ($object instanceof PhabricatorRepositoryCommit);
	}

	public function isStoryAboutObjectCreation($object) {
	// TODO: Although creation stories exist, they currently don't have a
	// primary object PHID set, so they'll never make it here because they
	// won't pass `canPublishStory()`.
	return false;
	}

	public function isStoryAboutObjectClosure($object) {
	// TODO: This isn't quite accurate, but pretty close: check if this story
	// is a close (which clearly is about object closure) or is an "Accept" and
	// the commit is fully audited (which is almost certainly a closure).
	// After ApplicationTransactions, we could annotate feed stories more
	// explicitly.

	$story = $this->getFeedStory();
	$action = $story->getStoryData()->getValue('action');

	if ($action == PhabricatorAuditActionConstants::CLOSE) {
	return true;
	}

	$fully_audited = PhabricatorAuditCommitStatusConstants::FULLY_AUDITED;
	if (($action == PhabricatorAuditActionConstants::ACCEPT) &&
	$object->getAuditStatus() == $fully_audited) {
	return true;
	}

	return false;
	}

	public function willPublishStory($commit) {
	$requests = id(new PhabricatorAuditQuery())
	->withCommitPHIDs(array($commit->getPHID()))
	->execute();

	// TODO: This is messy and should be generalized, but we don't have a good
	// query for it yet. Since we run in the daemons, just do the easiest thing
	// we can for the moment. Figure out who all of the "active" (need to
	// audit) and "passive" (no action necessary) user are.

	$auditor_phids = mpull($requests, 'getAuditorPHID');
	$objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($auditor_phids)
	->execute();

	$active = array();
	$passive = array();

	foreach ($requests as $request) {
	$status = $request->getAuditStatus();
	if ($status == PhabricatorAuditStatusConstants::CC) {
	// We handle these specially below.
	continue;
	}

	$object = idx($objects, $request->getAuditorPHID());
	if (!$object) {
	continue;
	}

	$request_phids = array();
	if ($object instanceof PhabricatorUser) {
	$request_phids = array($object->getPHID());
	} else if ($object instanceof PhabricatorOwnersPackage) {
	$request_phids = PhabricatorOwnersOwner::loadAffiliatedUserPHIDs(
	array($object->getID()));
	} else if ($object instanceof PhabricatorProject) {
	- $request_phids = $object->loadMemberPHIDs();
	+ $project = id(new PhabricatorProjectQuery())
	+ ->setViewer($this->getViewer())
	+ ->withIDs(array($object->getID()))
	+ ->needMembers(true)
	+ ->executeOne();
	+ $request_phids = $project->getMemberPHIDs();
	} else {
	// Dunno what this is.
	$request_phids = array();
	}

	switch ($status) {
	case PhabricatorAuditStatusConstants::AUDIT_REQUIRED:
	case PhabricatorAuditStatusConstants::AUDIT_REQUESTED:
	case PhabricatorAuditStatusConstants::CONCERNED:
	$active += array_fuse($request_phids);
	break;
	default:
	$passive += array_fuse($request_phids);
	break;
	}
	}



	// Remove "Active" users from the "Passive" list.
	$passive = array_diff_key($passive, $active);

	$this->activePHIDs = $active;
	$this->passivePHIDs = $passive;
	$this->auditRequests = $requests;

	return $commit;
	}

	public function getOwnerPHID($object) {
	return $object->getAuthorPHID();
	}

	public function getActiveUserPHIDs($object) {
	return $this->activePHIDs;
	}

	public function getPassiveUserPHIDs($object) {
	return $this->passivePHIDs;
	}

	public function getCCUserPHIDs($object) {
	$ccs = array();
	foreach ($this->getAuditRequests() as $request) {
	if ($request->getAuditStatus() == PhabricatorAuditStatusConstants::CC) {
	$ccs[] = $request->getAuditorPHID();
	}
	}
	return $ccs;
	}

	public function getObjectTitle($object) {
	$prefix = $this->getTitlePrefix($object);

	$repository = $object->getRepository();
	$name = $repository->formatCommitName($object->getCommitIdentifier());

	$title = $object->getSummary();

	return ltrim("{$prefix} {$name}: {$title}");
	}

	public function getObjectURI($object) {
	$repository = $object->getRepository();
	$name = $repository->formatCommitName($object->getCommitIdentifier());
	return PhabricatorEnv::getProductionURI('/'.$name);
	}

	public function getObjectDescription($object) {
	$data = $object->loadCommitData();
	if ($data) {
	return $data->getCommitMessage();
	}
	return null;
	}

	public function isObjectClosed($object) {
	switch ($object->getAuditStatus()) {
	case PhabricatorAuditCommitStatusConstants::NEEDS_AUDIT:
	case PhabricatorAuditCommitStatusConstants::CONCERN_RAISED:
	case PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED:
	return false;
	default:
	return true;
	}
	}

	public function getResponsibilityTitle($object) {
	$prefix = $this->getTitlePrefix($object);
	return pht('%s Audit', $prefix);
	}

	public function getStoryText($object) {
	$implied_context = $this->getRenderWithImpliedContext();

	$story = $this->getFeedStory();
	if ($story instanceof PhabricatorFeedStoryAudit) {
	$text = $story->renderForAsanaBridge($implied_context);
	} else {
	$text = $story->renderText();
	}
	return $text;
	}

	private function getTitlePrefix(PhabricatorRepositoryCommit $commit) {
	$prefix_key = 'metamta.diffusion.subject-prefix';
	return PhabricatorEnv::getEnvConfig($prefix_key);
	}

	}
	diff --git a/src/applications/doorkeeper/worker/DoorkeeperFeedWorkerAsana.php b/src/applications/doorkeeper/worker/DoorkeeperFeedWorkerAsana.php
	index 80df37905a..2a7aeb0aa8 100644
	--- a/src/applications/doorkeeper/worker/DoorkeeperFeedWorkerAsana.php
	+++ b/src/applications/doorkeeper/worker/DoorkeeperFeedWorkerAsana.php
	@@ -1,648 +1,652 @@
	<?php

	/**
	* Publishes tasks representing work that needs to be done into Asana, and
	* updates the tasks as the corresponding Phabricator objects are updated.
	*/
	final class DoorkeeperFeedWorkerAsana extends DoorkeeperFeedWorker {

	private $provider;


	/* -( Publishing Stories )------------------------------------------------- */


	/**
	* This worker is enabled when an Asana workspace ID is configured with
	* `asana.workspace-id`.
	*/
	public function isEnabled() {
	return (bool)$this->getWorkspaceID();
	}


	/**
	* Publish stories into Asana using the Asana API.
	*/
	protected function publishFeedStory() {
	$story = $this->getFeedStory();
	$data = $story->getStoryData();

	$viewer = $this->getViewer();
	$provider = $this->getProvider();
	$workspace_id = $this->getWorkspaceID();

	$object = $this->getStoryObject();
	$src_phid = $object->getPHID();

	$publisher = $this->getPublisher();

	// Figure out all the users related to the object. Users go into one of
	// four buckets:
	//
	// - Owner: the owner of the object. This user becomes the assigned owner
	// of the parent task.
	// - Active: users who are responsible for the object and need to act on
	// it. For example, reviewers of a "needs review" revision.
	// - Passive: users who are responsible for the object, but do not need
	// to act on it right now. For example, reviewers of a "needs revision"
	// revision.
	// - Follow: users who are following the object; generally CCs.

	$owner_phid = $publisher->getOwnerPHID($object);
	$active_phids = $publisher->getActiveUserPHIDs($object);
	$passive_phids = $publisher->getPassiveUserPHIDs($object);
	$follow_phids = $publisher->getCCUserPHIDs($object);

	$all_phids = array();
	$all_phids = array_merge(
	array($owner_phid),
	$active_phids,
	$passive_phids,
	$follow_phids);
	$all_phids = array_unique(array_filter($all_phids));

	$phid_aid_map = $this->lookupAsanaUserIDs($all_phids);
	if (!$phid_aid_map) {
	throw new PhabricatorWorkerPermanentFailureException(
	'No related users have linked Asana accounts.');
	}

	$owner_asana_id = idx($phid_aid_map, $owner_phid);
	$all_asana_ids = array_select_keys($phid_aid_map, $all_phids);
	$all_asana_ids = array_values($all_asana_ids);

	// Even if the actor isn't a reviewer, etc., try to use their account so
	// we can post in the correct voice. If we miss, we'll try all the other
	// related users.

	$try_users = array_merge(
	array($data->getAuthorPHID()),
	array_keys($phid_aid_map));
	$try_users = array_filter($try_users);

	$access_info = $this->findAnyValidAsanaAccessToken($try_users);
	list($possessed_user, $possessed_asana_id, $oauth_token) = $access_info;

	if (!$oauth_token) {
	throw new PhabricatorWorkerPermanentFailureException(
	'Unable to find any Asana user with valid credentials to '.
	'pull an OAuth token out of.');
	}

	$etype_main = PhabricatorEdgeConfig::TYPE_PHOB_HAS_ASANATASK;
	$etype_sub = PhabricatorEdgeConfig::TYPE_PHOB_HAS_ASANASUBTASK;

	$equery = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(array($src_phid))
	->withEdgeTypes(
	array(
	$etype_main,
	$etype_sub,
	))
	->needEdgeData(true);

	$edges = $equery->execute();

	$main_edge = head($edges[$src_phid][$etype_main]);

	$main_data = $this->getAsanaTaskData($object) + array(
	'assignee' => $owner_asana_id,
	);

	$extra_data = array();
	if ($main_edge) {
	$extra_data = $main_edge['data'];

	$refs = id(new DoorkeeperImportEngine())
	->setViewer($possessed_user)
	->withPHIDs(array($main_edge['dst']))
	->execute();

	$parent_ref = head($refs);
	if (!$parent_ref) {
	throw new PhabricatorWorkerPermanentFailureException(
	'DoorkeeperExternalObject could not be loaded.');
	}

	if ($parent_ref->getSyncFailed()) {
	throw new Exception(
	'Synchronization of parent task from Asana failed!');
	} else if (!$parent_ref->getIsVisible()) {
	$this->log("Skipping main task update, object is no longer visible.\n");
	$extra_data['gone'] = true;
	} else {
	$edge_cursor = idx($main_edge['data'], 'cursor', 0);

	// TODO: This probably breaks, very rarely, on 32-bit systems.
	if ($edge_cursor <= $story->getChronologicalKey()) {
	$this->log("Updating main task.\n");
	$task_id = $parent_ref->getObjectID();

	$this->makeAsanaAPICall(
	$oauth_token,
	"tasks/".$parent_ref->getObjectID(),
	'PUT',
	$main_data);
	} else {
	$this->log(
	"Skipping main task update, cursor is ahead of the story.\n");
	}
	}
	} else {
	// If there are no followers (CCs), and no active or passive users
	// (reviewers or auditors), and we haven't synchronized the object before,
	// don't synchronize the object.
	if (!$active_phids && !$passive_phids && !$follow_phids) {
	$this->log("Object has no followers or active/passive users.\n");
	return;
	}

	$parent = $this->makeAsanaAPICall(
	$oauth_token,
	'tasks',
	'POST',
	array(
	'workspace' => $workspace_id,
	// NOTE: We initially create parent tasks in the "Later" state but
	// don't update it afterward, even if the corresponding object
	// becomes actionable. The expectation is that users will prioritize
	// tasks in responses to notifications of state changes, and that
	// we should not overwrite their choices.
	'assignee_status' => 'later',
	) + $main_data);

	$parent_ref = $this->newRefFromResult(
	DoorkeeperBridgeAsana::OBJTYPE_TASK,
	$parent);


	$extra_data = array(
	'workspace' => $workspace_id,
	);
	}

	// Synchronize main task followers.

	$task_id = $parent_ref->getObjectID();

	// Reviewers are added as followers of the parent task silently, because
	// they receive a notification when they are assigned as the owner of their
	// subtask, so the follow notification is redundant / non-actionable.
	$silent_followers = array_select_keys($phid_aid_map, $active_phids) +
	array_select_keys($phid_aid_map, $passive_phids);
	$silent_followers = array_values($silent_followers);

	// CCs are added as followers of the parent task with normal notifications,
	// since they won't get a secondary subtask notification.
	$noisy_followers = array_select_keys($phid_aid_map, $follow_phids);
	$noisy_followers = array_values($noisy_followers);

	// To synchronize follower data, just add all the followers. The task might
	// have additional followers, but we can't really tell how they got there:
	// were they CC'd and then unsubscribed, or did they manually follow the
	// task? Assume the latter since it's easier and less destructive and the
	// former is rare. To be fully consistent, we should enumerate followers
	// and remove unknown followers, but that's a fair amount of work for little
	// benefit, and creates a wider window for race conditions.

	// Add the silent followers first so that a user who is both a reviewer and
	// a CC gets silently added and then implicitly skipped by then noisy add.
	// They will get a subtask notification.
	- $this->addFollowers($oauth_token, $task_id, $silent_followers, true);
	- $this->addFollowers($oauth_token, $task_id, $noisy_followers);
	+
	+ // We only do this if the task still exists.
	+ if (empty($extra_data['gone'])) {
	+ $this->addFollowers($oauth_token, $task_id, $silent_followers, true);
	+ $this->addFollowers($oauth_token, $task_id, $noisy_followers);
	+ }

	$dst_phid = $parent_ref->getExternalObject()->getPHID();

	// Update the main edge.

	$edge_data = array(
	'cursor' => $story->getChronologicalKey(),
	) + $extra_data;

	$edge_options = array(
	'data' => $edge_data,
	);

	id(new PhabricatorEdgeEditor())
	->setActor($viewer)
	->addEdge($src_phid, $etype_main, $dst_phid, $edge_options)
	->save();

	if (!$parent_ref->getIsVisible()) {
	throw new PhabricatorWorkerPermanentFailureException(
	'DoorkeeperExternalObject has no visible object on the other side; '.
	'this likely indicates the Asana task has been deleted.');
	}

	// Now, handle the subtasks.

	$sub_editor = id(new PhabricatorEdgeEditor())
	->setActor($viewer);

	// First, find all the object references in Phabricator for tasks that we
	// know about and import their objects from Asana.
	$sub_edges = $edges[$src_phid][$etype_sub];
	$sub_refs = array();
	$subtask_data = $this->getAsanaSubtaskData($object);
	$have_phids = array();

	if ($sub_edges) {
	$refs = id(new DoorkeeperImportEngine())
	->setViewer($possessed_user)
	->withPHIDs(array_keys($sub_edges))
	->execute();

	foreach ($refs as $ref) {
	if ($ref->getSyncFailed()) {
	throw new Exception(
	'Synchronization of child task from Asana failed!');
	}
	if (!$ref->getIsVisible()) {
	$ref->getExternalObject()->delete();
	continue;
	}
	$have_phids[$ref->getExternalObject()->getPHID()] = $ref;
	}
	}

	// Remove any edges in Phabricator which don't have valid tasks in Asana.
	// These are likely tasks which have been deleted. We're going to respawn
	// them.
	foreach ($sub_edges as $sub_phid => $sub_edge) {
	if (isset($have_phids[$sub_phid])) {
	continue;
	}

	$this->log(
	"Removing subtask edge to %s, foreign object is not visible.\n",
	$sub_phid);
	$sub_editor->removeEdge($src_phid, $etype_sub, $sub_phid);
	unset($sub_edges[$sub_phid]);
	}


	// For each active or passive user, we're looking for an existing, valid
	// task. If we find one we're going to update it; if we don't, we'll
	// create one. We ignore extra subtasks that we didn't create (we gain
	// nothing by deleting them and might be nuking something important) and
	// ignore subtasks which have been moved across workspaces or replanted
	// under new parents (this stuff is too edge-casey to bother checking for
	// and complicated to fix, as it needs extra API calls). However, we do
	// clean up subtasks we created whose owners are no longer associated
	// with the object.

	$subtask_states = array_fill_keys($active_phids, false) +
	array_fill_keys($passive_phids, true);

	// Continue with only those users who have Asana credentials.

	$subtask_states = array_select_keys(
	$subtask_states,
	array_keys($phid_aid_map));

	$need_subtasks = $subtask_states;

	$user_to_ref_map = array();
	$nuke_refs = array();
	foreach ($sub_edges as $sub_phid => $sub_edge) {
	$user_phid = idx($sub_edge['data'], 'userPHID');

	if (isset($need_subtasks[$user_phid])) {
	unset($need_subtasks[$user_phid]);
	$user_to_ref_map[$user_phid] = $have_phids[$sub_phid];
	} else {
	// This user isn't associated with the object anymore, so get rid
	// of their task and edge.
	$nuke_refs[$sub_phid] = $have_phids[$sub_phid];
	}
	}

	// These are tasks we know about but which are no longer relevant -- for
	// example, because a user has been removed as a reviewer. Remove them and
	// their edges.

	foreach ($nuke_refs as $sub_phid => $ref) {
	$sub_editor->removeEdge($src_phid, $etype_sub, $sub_phid);
	$this->makeAsanaAPICall(
	$oauth_token,
	'tasks/'.$ref->getObjectID(),
	'DELETE',
	array());
	$ref->getExternalObject()->delete();
	}

	// For each user that we don't have a subtask for, create a new subtask.
	foreach ($need_subtasks as $user_phid => $is_completed) {
	$subtask = $this->makeAsanaAPICall(
	$oauth_token,
	'tasks',
	'POST',
	$subtask_data + array(
	'assignee' => $phid_aid_map[$user_phid],
	'completed' => $is_completed,
	'parent' => $parent_ref->getObjectID(),
	));

	$subtask_ref = $this->newRefFromResult(
	DoorkeeperBridgeAsana::OBJTYPE_TASK,
	$subtask);

	$user_to_ref_map[$user_phid] = $subtask_ref;

	// We don't need to synchronize this subtask's state because we just
	// set it when we created it.
	unset($subtask_states[$user_phid]);

	// Add an edge to track this subtask.
	$sub_editor->addEdge(
	$src_phid,
	$etype_sub,
	$subtask_ref->getExternalObject()->getPHID(),
	array(
	'data' => array(
	'userPHID' => $user_phid,
	),
	));
	}

	// Synchronize all the previously-existing subtasks.

	foreach ($subtask_states as $user_phid => $is_completed) {
	$this->makeAsanaAPICall(
	$oauth_token,
	'tasks/'.$user_to_ref_map[$user_phid]->getObjectID(),
	'PUT',
	$subtask_data + array(
	'assignee' => $phid_aid_map[$user_phid],
	'completed' => $is_completed,
	));
	}

	foreach ($user_to_ref_map as $user_phid => $ref) {
	// For each subtask, if the acting user isn't the same user as the subtask
	// owner, remove the acting user as a follower. Currently, the acting user
	// will be added as a follower only when they create the task, but this
	// may change in the future (e.g., closing the task may also mark them
	// as a follower). Wipe every subtask to be sure. The intent here is to
	// leave only the owner as a follower so that the acting user doesn't
	// receive notifications about changes to subtask state. Note that
	// removing followers is silent in all cases in Asana and never produces
	// any kind of notification, so this isn't self-defeating.
	if ($user_phid != $possessed_user->getPHID()) {
	$this->makeAsanaAPICall(
	$oauth_token,
	'tasks/'.$ref->getObjectID().'/removeFollowers',
	'POST',
	array(
	'followers' => array($possessed_asana_id),
	));
	}
	}

	// Update edges on our side.

	$sub_editor->save();

	// Don't publish the "create" story, since pushing the object into Asana
	// naturally generates a notification which effectively serves the same
	// purpose as the "create" story. Similarly, "close" stories generate a
	// close notification.
	if (!$publisher->isStoryAboutObjectCreation($object) &&
	!$publisher->isStoryAboutObjectClosure($object)) {
	// Post the feed story itself to the main Asana task. We do this last
	// because everything else is idempotent, so this is the only effect we
	// can't safely run more than once.

	$text = $publisher
	->setRenderWithImpliedContext(true)
	->getStoryText($object);

	$this->makeAsanaAPICall(
	$oauth_token,
	'tasks/'.$parent_ref->getObjectID().'/stories',
	'POST',
	array(
	'text' => $text,
	));
	}
	}


	/* -( Internals )---------------------------------------------------------- */

	private function getWorkspaceID() {
	return PhabricatorEnv::getEnvConfig('asana.workspace-id');
	}

	private function getProvider() {
	if (!$this->provider) {
	$provider = PhabricatorAuthProviderOAuthAsana::getAsanaProvider();
	if (!$provider) {
	throw new PhabricatorWorkerPermanentFailureException(
	'No Asana provider configured.');
	}
	$this->provider = $provider;
	}
	return $this->provider;
	}

	private function getAsanaTaskData($object) {
	$publisher = $this->getPublisher();

	$title = $publisher->getObjectTitle($object);
	$uri = $publisher->getObjectURI($object);
	$description = $publisher->getObjectDescription($object);
	$is_completed = $publisher->isObjectClosed($object);

	$notes = array(
	$description,
	$uri,
	$this->getSynchronizationWarning(),
	);

	$notes = implode("\n\n", $notes);

	return array(
	'name' => $title,
	'notes' => $notes,
	'completed' => $is_completed,
	);
	}

	private function getAsanaSubtaskData($object) {
	$publisher = $this->getPublisher();

	$title = $publisher->getResponsibilityTitle($object);
	$uri = $publisher->getObjectURI($object);
	$description = $publisher->getObjectDescription($object);

	$notes = array(
	$description,
	$uri,
	$this->getSynchronizationWarning(),
	);

	$notes = implode("\n\n", $notes);

	return array(
	'name' => $title,
	'notes' => $notes,
	);
	}

	private function getSynchronizationWarning() {
	return
	"\xE2\x9A\xA0 DO NOT EDIT THIS TASK \xE2\x9A\xA0\n".
	"\xE2\x98\xA0 Your changes will not be reflected in Phabricator.\n".
	"\xE2\x98\xA0 Your changes will be destroyed the next time state ".
	"is synchronized.";
	}

	private function lookupAsanaUserIDs($all_phids) {
	$phid_map = array();

	$all_phids = array_unique(array_filter($all_phids));
	if (!$all_phids) {
	return $phid_map;
	}

	$provider = PhabricatorAuthProviderOAuthAsana::getAsanaProvider();

	$accounts = id(new PhabricatorExternalAccountQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withUserPHIDs($all_phids)
	->withAccountTypes(array($provider->getProviderType()))
	->withAccountDomains(array($provider->getProviderDomain()))
	->execute();

	foreach ($accounts as $account) {
	$phid_map[$account->getUserPHID()] = $account->getAccountID();
	}

	// Put this back in input order.
	$phid_map = array_select_keys($phid_map, $all_phids);

	return $phid_map;
	}

	private function findAnyValidAsanaAccessToken(array $user_phids) {
	if (!$user_phids) {
	return array(null, null, null);
	}

	$provider = $this->getProvider();
	$viewer = $this->getViewer();

	$accounts = id(new PhabricatorExternalAccountQuery())
	->setViewer($viewer)
	->withUserPHIDs($user_phids)
	->withAccountTypes(array($provider->getProviderType()))
	->withAccountDomains(array($provider->getProviderDomain()))
	->execute();

	// Reorder accounts in the original order.
	// TODO: This needs to be adjusted if/when we allow you to link multiple
	// accounts.
	$accounts = mpull($accounts, null, 'getUserPHID');
	$accounts = array_select_keys($accounts, $user_phids);

	$workspace_id = $this->getWorkspaceID();

	foreach ($accounts as $account) {
	// Get a token if possible.
	$token = $provider->getOAuthAccessToken($account);
	if (!$token) {
	continue;
	}

	// Verify we can actually make a call with the token, and that the user
	// has access to the workspace in question.
	try {
	id(new PhutilAsanaFuture())
	->setAccessToken($token)
	->setRawAsanaQuery("workspaces/{$workspace_id}")
	->resolve();
	} catch (Exception $ex) {
	// This token didn't make it through; try the next account.
	continue;
	}

	$user = id(new PhabricatorPeopleQuery())
	->setViewer($viewer)
	->withPHIDs(array($account->getUserPHID()))
	->executeOne();
	if ($user) {
	return array($user, $account->getAccountID(), $token);
	}
	}

	return array(null, null, null);
	}

	private function makeAsanaAPICall($token, $action, $method, array $params) {
	foreach ($params as $key => $value) {
	if ($value === null) {
	unset($params[$key]);
	} else if (is_array($value)) {
	unset($params[$key]);
	foreach ($value as $skey => $svalue) {
	$params[$key.'['.$skey.']'] = $svalue;
	}
	}
	}

	return id(new PhutilAsanaFuture())
	->setAccessToken($token)
	->setMethod($method)
	->setRawAsanaQuery($action, $params)
	->resolve();
	}

	private function newRefFromResult($type, $result) {
	$ref = id(new DoorkeeperObjectRef())
	->setApplicationType(DoorkeeperBridgeAsana::APPTYPE_ASANA)
	->setApplicationDomain(DoorkeeperBridgeAsana::APPDOMAIN_ASANA)
	->setObjectType($type)
	->setObjectID($result['id'])
	->setIsVisible(true);

	$xobj = $ref->newExternalObject();
	$ref->attachExternalObject($xobj);

	$bridge = new DoorkeeperBridgeAsana();
	$bridge->fillObjectFromData($xobj, $result);

	$xobj->save();

	return $ref;
	}

	private function addFollowers(
	$oauth_token,
	$task_id,
	array $followers,
	$silent = false) {

	if (!$followers) {
	return;
	}

	$data = array(
	'followers' => $followers,
	);

	// NOTE: This uses a currently-undocumented API feature to suppress the
	// follow notifications.
	if ($silent) {
	$data['silent'] = true;
	}

	$this->makeAsanaAPICall(
	$oauth_token,
	"tasks/{$task_id}/addFollowers",
	'POST',
	$data);
	}

	}
	diff --git a/src/applications/herald/adapter/HeraldCommitAdapter.php b/src/applications/herald/adapter/HeraldCommitAdapter.php
	index fe4424e457..c1199c9f2c 100644
	--- a/src/applications/herald/adapter/HeraldCommitAdapter.php
	+++ b/src/applications/herald/adapter/HeraldCommitAdapter.php
	@@ -1,428 +1,430 @@
	<?php

	/**
	* @group herald
	*/
	final class HeraldCommitAdapter extends HeraldAdapter {

	const FIELD_NEED_AUDIT_FOR_PACKAGE = 'need-audit-for-package';
	const FIELD_DIFFERENTIAL_REVISION = 'differential-revision';
	const FIELD_DIFFERENTIAL_REVIEWERS = 'differential-reviewers';
	const FIELD_DIFFERENTIAL_CCS = 'differential-ccs';
	const FIELD_REPOSITORY_AUTOCLOSE_BRANCH = 'repository-autoclose-branch';

	protected $diff;
	protected $revision;

	protected $repository;
	protected $commit;
	protected $commitData;

	protected $emailPHIDs = array();
	protected $addCCPHIDs = array();
	protected $auditMap = array();

	protected $affectedPaths;
	protected $affectedRevision;
	protected $affectedPackages;
	protected $auditNeededPackages;

	public function getAdapterApplicationClass() {
	return 'PhabricatorApplicationDiffusion';
	}

	public function getObject() {
	return $this->commit;
	}

	public function getAdapterContentType() {
	return 'commit';
	}

	public function getAdapterContentName() {
	return pht('Commits');
	}

	public function getFieldNameMap() {
	return array(
	self::FIELD_NEED_AUDIT_FOR_PACKAGE =>
	pht('Affected packages that need audit'),
	self::FIELD_DIFFERENTIAL_REVISION => pht('Differential revision'),
	self::FIELD_DIFFERENTIAL_REVIEWERS => pht('Differential reviewers'),
	self::FIELD_DIFFERENTIAL_CCS => pht('Differential CCs'),
	self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH => pht('On autoclose branch'),
	) + parent::getFieldNameMap();
	}

	public function getFields() {
	return array_merge(
	array(
	self::FIELD_BODY,
	self::FIELD_AUTHOR,
	self::FIELD_COMMITTER,
	self::FIELD_REVIEWER,
	self::FIELD_REPOSITORY,
	self::FIELD_DIFF_FILE,
	self::FIELD_DIFF_CONTENT,
	self::FIELD_DIFF_ADDED_CONTENT,
	self::FIELD_DIFF_REMOVED_CONTENT,
	self::FIELD_RULE,
	self::FIELD_AFFECTED_PACKAGE,
	self::FIELD_AFFECTED_PACKAGE_OWNER,
	self::FIELD_NEED_AUDIT_FOR_PACKAGE,
	self::FIELD_DIFFERENTIAL_REVISION,
	self::FIELD_DIFFERENTIAL_REVIEWERS,
	self::FIELD_DIFFERENTIAL_CCS,
	self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH,
	),
	parent::getFields());
	}

	public function getConditionsForField($field) {
	switch ($field) {
	case self::FIELD_DIFFERENTIAL_REVIEWERS:
	return array(
	self::CONDITION_EXISTS,
	self::CONDITION_NOT_EXISTS,
	self::CONDITION_INCLUDE_ALL,
	self::CONDITION_INCLUDE_ANY,
	self::CONDITION_INCLUDE_NONE,
	);
	case self::FIELD_DIFFERENTIAL_CCS:
	return array(
	self::CONDITION_INCLUDE_ALL,
	self::CONDITION_INCLUDE_ANY,
	self::CONDITION_INCLUDE_NONE,
	);
	case self::FIELD_DIFFERENTIAL_REVISION:
	return array(
	self::CONDITION_EXISTS,
	self::CONDITION_NOT_EXISTS,
	);
	case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
	return array(
	self::CONDITION_INCLUDE_ANY,
	self::CONDITION_INCLUDE_NONE,
	);
	case self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH:
	return array(
	self::CONDITION_UNCONDITIONALLY,
	);
	}
	return parent::getConditionsForField($field);
	}

	public function getActions($rule_type) {
	switch ($rule_type) {
	case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
	return array(
	self::ACTION_ADD_CC,
	self::ACTION_EMAIL,
	self::ACTION_AUDIT,
	self::ACTION_NOTHING,
	);
	case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
	return array(
	self::ACTION_ADD_CC,
	self::ACTION_EMAIL,
	self::ACTION_FLAG,
	self::ACTION_AUDIT,
	self::ACTION_NOTHING,
	);
	}
	}

	public function getValueTypeForFieldAndCondition($field, $condition) {
	switch ($field) {
	case self::FIELD_DIFFERENTIAL_CCS:
	return self::VALUE_EMAIL;
	case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
	return self::VALUE_OWNERS_PACKAGE;
	}

	return parent::getValueTypeForFieldAndCondition($field, $condition);
	}

	public static function newLegacyAdapter(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	PhabricatorRepositoryCommitData $commit_data) {

	$object = new HeraldCommitAdapter();

	+ $commit->attachRepository($repository);
	+
	$object->repository = $repository;
	$object->commit = $commit;
	$object->commitData = $commit_data;

	return $object;
	}

	public function getPHID() {
	return $this->commit->getPHID();
	}

	public function getEmailPHIDs() {
	return array_keys($this->emailPHIDs);
	}

	public function getAddCCMap() {
	return $this->addCCPHIDs;
	}

	public function getAuditMap() {
	return $this->auditMap;
	}

	public function getHeraldName() {
	return
	'r'.
	$this->repository->getCallsign().
	$this->commit->getCommitIdentifier();
	}

	public function loadAffectedPaths() {
	if ($this->affectedPaths === null) {
	$result = PhabricatorOwnerPathQuery::loadAffectedPaths(
	$this->repository,
	$this->commit,
	PhabricatorUser::getOmnipotentUser());
	$this->affectedPaths = $result;
	}
	return $this->affectedPaths;
	}

	public function loadAffectedPackages() {
	if ($this->affectedPackages === null) {
	$packages = PhabricatorOwnersPackage::loadAffectedPackages(
	$this->repository,
	$this->loadAffectedPaths());
	$this->affectedPackages = $packages;
	}
	return $this->affectedPackages;
	}

	public function loadAuditNeededPackage() {
	if ($this->auditNeededPackages === null) {
	$status_arr = array(
	PhabricatorAuditStatusConstants::AUDIT_REQUIRED,
	PhabricatorAuditStatusConstants::CONCERNED,
	);
	$requests = id(new PhabricatorRepositoryAuditRequest())
	->loadAllWhere(
	"commitPHID = %s AND auditStatus IN (%Ls)",
	$this->commit->getPHID(),
	$status_arr);

	$packages = mpull($requests, 'getAuditorPHID');
	$this->auditNeededPackages = $packages;
	}
	return $this->auditNeededPackages;
	}

	public function loadDifferentialRevision() {
	if ($this->affectedRevision === null) {
	$this->affectedRevision = false;
	$data = $this->commitData;
	$revision_id = $data->getCommitDetail('differential.revisionID');
	if ($revision_id) {
	// NOTE: The Herald rule owner might not actually have access to
	// the revision, and can control which revision a commit is
	// associated with by putting text in the commit message. However,
	// the rules they can write against revisions don't actually expose
	// anything interesting, so it seems reasonable to load unconditionally
	// here.

	$revision = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->needRelationships(true)
	->needReviewerStatus(true)
	->executeOne();
	if ($revision) {
	$this->affectedRevision = $revision;
	}
	}
	}
	return $this->affectedRevision;
	}

	private function loadCommitDiff() {
	$drequest = DiffusionRequest::newFromDictionary(
	array(
	'user' => PhabricatorUser::getOmnipotentUser(),
	'repository' => $this->repository,
	'commit' => $this->commit->getCommitIdentifier(),
	));

	$raw = DiffusionQuery::callConduitWithDiffusionRequest(
	PhabricatorUser::getOmnipotentUser(),
	$drequest,
	'diffusion.rawdiffquery',
	array(
	'commit' => $this->commit->getCommitIdentifier(),
	'timeout' => 60 * 60 * 15,
	'linesOfContext' => 0));

	$parser = new ArcanistDiffParser();
	$changes = $parser->parseDiff($raw);

	$diff = DifferentialDiff::newFromRawChanges($changes);
	return $diff;
	}

	private function loadChangesets() {
	try {
	$diff = $this->loadCommitDiff();
	} catch (Exception $ex) {
	return array(
	'<<< Failed to load diff, this may mean the change was '.
	'unimaginably enormous. >>>');
	}
	return $diff->getChangesets();
	}

	public function getHeraldField($field) {
	$data = $this->commitData;
	switch ($field) {
	case self::FIELD_BODY:
	return $data->getCommitMessage();
	case self::FIELD_AUTHOR:
	return $data->getCommitDetail('authorPHID');
	case self::FIELD_COMMITTER:
	return $data->getCommitDetail('committerPHID');
	case self::FIELD_REVIEWER:
	return $data->getCommitDetail('reviewerPHID');
	case self::FIELD_DIFF_FILE:
	return $this->loadAffectedPaths();
	case self::FIELD_REPOSITORY:
	return $this->repository->getPHID();
	case self::FIELD_DIFF_CONTENT:
	$dict = array();
	$lines = array();
	$changes = $this->loadChangesets();
	foreach ($changes as $change) {
	$lines = array();
	foreach ($change->getHunks() as $hunk) {
	$lines[] = $hunk->makeChanges();
	}
	$dict[$change->getFilename()] = implode("\n", $lines);
	}
	return $dict;
	case self::FIELD_DIFF_ADDED_CONTENT:
	$dict = array();
	$lines = array();
	$changes = $this->loadChangesets();
	foreach ($changes as $change) {
	$lines = array();
	foreach ($change->getHunks() as $hunk) {
	$lines[] = implode('', $hunk->getAddedLines());
	}
	$dict[$change->getFilename()] = implode("\n", $lines);
	}
	return $dict;
	case self::FIELD_DIFF_REMOVED_CONTENT:
	$dict = array();
	$lines = array();
	$changes = $this->loadChangesets();
	foreach ($changes as $change) {
	$lines = array();
	foreach ($change->getHunks() as $hunk) {
	$lines[] = implode('', $hunk->getRemovedLines());
	}
	$dict[$change->getFilename()] = implode("\n", $lines);
	}
	return $dict;
	case self::FIELD_AFFECTED_PACKAGE:
	$packages = $this->loadAffectedPackages();
	return mpull($packages, 'getPHID');
	case self::FIELD_AFFECTED_PACKAGE_OWNER:
	$packages = $this->loadAffectedPackages();
	$owners = PhabricatorOwnersOwner::loadAllForPackages($packages);
	return mpull($owners, 'getUserPHID');
	case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
	return $this->loadAuditNeededPackage();
	case self::FIELD_DIFFERENTIAL_REVISION:
	$revision = $this->loadDifferentialRevision();
	if (!$revision) {
	return null;
	}
	return $revision->getID();
	case self::FIELD_DIFFERENTIAL_REVIEWERS:
	$revision = $this->loadDifferentialRevision();
	if (!$revision) {
	return array();
	}
	return $revision->getReviewers();
	case self::FIELD_DIFFERENTIAL_CCS:
	$revision = $this->loadDifferentialRevision();
	if (!$revision) {
	return array();
	}
	return $revision->getCCPHIDs();
	case self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH:
	return $this->repository->shouldAutocloseCommit(
	$this->commit,
	$this->commitData);
	}

	return parent::getHeraldField($field);
	}

	public function applyHeraldEffects(array $effects) {
	assert_instances_of($effects, 'HeraldEffect');

	$result = array();
	foreach ($effects as $effect) {
	$action = $effect->getAction();
	switch ($action) {
	case self::ACTION_NOTHING:
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Great success at doing nothing.'));
	break;
	case self::ACTION_EMAIL:
	foreach ($effect->getTarget() as $phid) {
	$this->emailPHIDs[$phid] = true;
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Added address to email targets.'));
	break;
	case self::ACTION_ADD_CC:
	foreach ($effect->getTarget() as $phid) {
	if (empty($this->addCCPHIDs[$phid])) {
	$this->addCCPHIDs[$phid] = array();
	}
	$this->addCCPHIDs[$phid][] = $effect->getRuleID();
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Added address to CC.'));
	break;
	case self::ACTION_AUDIT:
	foreach ($effect->getTarget() as $phid) {
	if (empty($this->auditMap[$phid])) {
	$this->auditMap[$phid] = array();
	}
	$this->auditMap[$phid][] = $effect->getRuleID();
	}
	$result[] = new HeraldApplyTranscript(
	$effect,
	true,
	pht('Triggered an audit.'));
	break;
	case self::ACTION_FLAG:
	$result[] = parent::applyFlagEffect(
	$effect,
	$this->commit->getPHID());
	break;
	default:
	throw new Exception("No rules to handle action '{$action}'.");
	}
	}
	return $result;
	}
	}
	diff --git a/src/applications/project/controller/PhabricatorProjectMembersEditController.php b/src/applications/project/controller/PhabricatorProjectMembersEditController.php
	index d5ae0b064e..98067f435c 100644
	--- a/src/applications/project/controller/PhabricatorProjectMembersEditController.php
	+++ b/src/applications/project/controller/PhabricatorProjectMembersEditController.php
	@@ -1,175 +1,176 @@
	<?php

	final class PhabricatorProjectMembersEditController
	extends PhabricatorProjectController {

	private $id;

	public function willProcessRequest(array $data) {
	$this->id = $data['id'];
	}

	public function processRequest() {
	$request = $this->getRequest();
	$user = $request->getUser();

	$project = id(new PhabricatorProjectQuery())
	->setViewer($user)
	->withIDs(array($this->id))
	+ ->needMembers(true)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$project) {
	return new Aphront404Response();
	}
	$profile = $project->loadProfile();
	if (empty($profile)) {
	$profile = new PhabricatorProjectProfile();
	}

	- $member_phids = $project->loadMemberPHIDs();
	+ $member_phids = $project->getMemberPHIDs();

	$errors = array();
	if ($request->isFormPost()) {
	$changed_something = false;
	$member_map = array_fill_keys($member_phids, true);

	$remove = $request->getStr('remove');
	if ($remove) {
	if (isset($member_map[$remove])) {
	unset($member_map[$remove]);
	$changed_something = true;
	}
	} else {
	$new_members = $request->getArr('phids');
	foreach ($new_members as $member) {
	if (empty($member_map[$member])) {
	$member_map[$member] = true;
	$changed_something = true;
	}
	}
	}

	$xactions = array();
	if ($changed_something) {
	$xaction = new PhabricatorProjectTransaction();
	$xaction->setTransactionType(
	PhabricatorProjectTransactionType::TYPE_MEMBERS);
	$xaction->setNewValue(array_keys($member_map));
	$xactions[] = $xaction;
	}

	if ($xactions) {
	$editor = new PhabricatorProjectEditor($project);
	$editor->setActor($user);
	$editor->applyTransactions($xactions);
	}

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

	$member_phids = array_reverse($member_phids);
	$handles = $this->loadViewerHandles($member_phids);

	$state = array();
	foreach ($handles as $handle) {
	$state[] = array(
	'phid' => $handle->getPHID(),
	'name' => $handle->getFullName(),
	);
	}

	$header_name = pht('Edit Members');
	$title = pht('Edit Members');

	$list = $this->renderMemberList($handles);

	$form = new AphrontFormView();
	$form
	->setUser($user)
	->appendChild(
	id(new AphrontFormTokenizerControl())
	->setName('phids')
	->setLabel(pht('Add Members'))
	->setDatasource('/typeahead/common/users/'))
	->appendChild(
	id(new AphrontFormSubmitControl())
	->addCancelButton('/project/view/'.$project->getID().'/')
	->setValue(pht('Add Members')));
	$faux_form = id(new AphrontFormView())
	->setUser($user)
	->appendChild(
	id(new AphrontFormInsetView())
	->appendChild($list));

	$box = id(new PHUIObjectBoxView())
	->setHeaderText(pht('Current Members (%d)', count($handles)))
	->setForm($faux_form);

	$form_box = id(new PHUIObjectBoxView())
	->setHeaderText($title)
	->setForm($form);

	$crumbs = $this->buildApplicationCrumbs($this->buildSideNavView());
	$crumbs->addCrumb(
	id(new PhabricatorCrumbView())
	->setName($project->getName())
	->setHref('/project/view/'.$project->getID().'/'));
	$crumbs->addCrumb(
	id(new PhabricatorCrumbView())
	->setName(pht('Edit Members'))
	->setHref($this->getApplicationURI()));

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$form_box,
	$box,
	),
	array(
	'title' => $title,
	'device' => true,
	));
	}

	private function renderMemberList(array $handles) {
	$request = $this->getRequest();
	$user = $request->getUser();
	$list = id(new PhabricatorObjectListView())
	->setHandles($handles);

	foreach ($handles as $handle) {
	$hidden_input = phutil_tag(
	'input',
	array(
	'type' => 'hidden',
	'name' => 'remove',
	'value' => $handle->getPHID(),
	),
	'');

	$button = javelin_tag(
	'button',
	array(
	'class' => 'grey',
	),
	pht('Remove'));

	$list->addButton(
	$handle,
	phabricator_form(
	$user,
	array(
	'method' => 'POST',
	'action' => $request->getRequestURI(),
	),
	array($hidden_input, $button)));
	}

	return $list;
	}
	}
	diff --git a/src/applications/project/editor/PhabricatorProjectEditor.php b/src/applications/project/editor/PhabricatorProjectEditor.php
	index 0e45ba7151..f3b3f2a5a9 100644
	--- a/src/applications/project/editor/PhabricatorProjectEditor.php
	+++ b/src/applications/project/editor/PhabricatorProjectEditor.php
	@@ -1,416 +1,415 @@
	<?php

	final class PhabricatorProjectEditor extends PhabricatorEditor {

	private $project;
	private $projectName;

	private $addEdges = array();
	private $remEdges = array();

	private $shouldArchive = false;

	private function setShouldArchive($should_archive) {
	$this->shouldArchive = $should_archive;
	return $this;
	}
	private function shouldArchive() {
	return $this->shouldArchive;
	}

	public static function applyJoinProject(
	PhabricatorProject $project,
	PhabricatorUser $user) {

	$members = $project->getMemberPHIDs();
	$members[] = $user->getPHID();

	self::applyOneTransaction(
	$project,
	$user,
	PhabricatorProjectTransactionType::TYPE_MEMBERS,
	$members);
	}

	public static function applyLeaveProject(
	PhabricatorProject $project,
	PhabricatorUser $user) {

	$members = array_fill_keys($project->getMemberPHIDs(), true);
	unset($members[$user->getPHID()]);
	$members = array_keys($members);

	self::applyOneTransaction(
	$project,
	$user,
	PhabricatorProjectTransactionType::TYPE_MEMBERS,
	$members);
	}

	private static function applyOneTransaction(
	PhabricatorProject $project,
	PhabricatorUser $user,
	$type,
	$new_value) {

	$xaction = new PhabricatorProjectTransaction();
	$xaction->setTransactionType($type);
	$xaction->setNewValue($new_value);

	$editor = new PhabricatorProjectEditor($project);
	$editor->setActor($user);
	$editor->applyTransactions(array($xaction));
	}


	public function __construct(PhabricatorProject $project) {
	$this->project = $project;
	}

	public function applyTransactions(array $transactions) {
	assert_instances_of($transactions, 'PhabricatorProjectTransaction');
	$actor = $this->requireActor();

	$project = $this->project;

	$is_new = !$project->getID();

	if ($is_new) {
	$project->setAuthorPHID($actor->getPHID());
	}

	foreach ($transactions as $key => $xaction) {
	$this->setTransactionOldValue($project, $xaction);
	if (!$this->transactionHasEffect($xaction)) {
	unset($transactions[$key]);
	continue;
	}
	}

	if (!$is_new) {
	// You must be able to view a project in order to edit it in any capacity.
	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$project,
	PhabricatorPolicyCapability::CAN_VIEW);

	$need_edit = false;
	$need_join = false;
	foreach ($transactions as $key => $xaction) {
	if ($this->getTransactionRequiresEditCapability($xaction)) {
	$need_edit = true;
	}
	if ($this->getTransactionRequiresJoinCapability($xaction)) {
	$need_join = true;
	}
	}

	if ($need_edit) {
	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);
	}

	if ($need_join) {
	PhabricatorPolicyFilter::requireCapability(
	$actor,
	$project,
	PhabricatorPolicyCapability::CAN_JOIN);
	}
	}

	if (!$transactions) {
	return $this;
	}

	foreach ($transactions as $xaction) {
	$this->applyTransactionEffect($project, $xaction);
	}

	try {
	$project->openTransaction();

	if ($this->shouldArchive()) {
	$project->setStatus(PhabricatorProjectStatus::STATUS_ARCHIVED);
	}
	$project->save();

	$edge_type = PhabricatorEdgeConfig::TYPE_PROJ_MEMBER;
	$editor = new PhabricatorEdgeEditor();
	$editor->setActor($actor);
	foreach ($this->remEdges as $phid) {
	$editor->removeEdge($project->getPHID(), $edge_type, $phid);
	}
	foreach ($this->addEdges as $phid) {
	$editor->addEdge($project->getPHID(), $edge_type, $phid);
	}
	$editor->save();

	foreach ($transactions as $xaction) {
	$xaction->setAuthorPHID($actor->getPHID());
	$xaction->setProjectID($project->getID());
	$xaction->save();
	}
	$project->saveTransaction();

	foreach ($transactions as $xaction) {
	$this->publishTransactionStory($project, $xaction);
	}

	} catch (AphrontQueryDuplicateKeyException $ex) {
	// We already validated the slug, but might race. Try again to see if
	// that's the issue. If it is, we'll throw a more specific exception. If
	// not, throw the original exception.
	$this->validateName($project);
	throw $ex;
	}

	id(new PhabricatorSearchIndexer())
	->indexDocumentByPHID($project->getPHID());

	return $this;
	}

	private function validateName(PhabricatorProject $project) {
	$slug = $project->getPhrictionSlug();
	$name = $project->getName();

	if ($slug == '/') {
	throw new PhabricatorProjectNameCollisionException(
	pht("Project names must be unique and contain some ".
	"letters or numbers."));
	}

	$id = $project->getID();
	$collision = id(new PhabricatorProject())->loadOneWhere(
	'(name = %s OR phrictionSlug = %s) AND id %Q %nd',
	$name,
	$slug,
	$id ? '!=' : 'IS NOT',
	$id ? $id : null);

	if ($collision) {
	$other_name = $collision->getName();
	$other_id = $collision->getID();
	throw new PhabricatorProjectNameCollisionException(
	pht("Project names must be unique. The name '%s' is too similar to ".
	"the name of another project, '%s' (Project ID: ".
	"%d). Choose a unique name.", $name, $other_name, $other_id));
	}
	}

	private function setTransactionOldValue(
	PhabricatorProject $project,
	PhabricatorProjectTransaction $xaction) {

	$type = $xaction->getTransactionType();
	switch ($type) {
	case PhabricatorProjectTransactionType::TYPE_NAME:
	$xaction->setOldValue($project->getName());
	break;
	case PhabricatorProjectTransactionType::TYPE_STATUS:
	$xaction->setOldValue($project->getStatus());
	break;
	case PhabricatorProjectTransactionType::TYPE_MEMBERS:
	- $member_phids = $project->loadMemberPHIDs();
	- $project->attachMemberPHIDs($member_phids);
	+ $member_phids = $project->getMemberPHIDs();

	$old_value = array_values($member_phids);
	$xaction->setOldValue($old_value);

	$new_value = $xaction->getNewValue();
	$new_value = array_filter($new_value);
	$new_value = array_unique($new_value);
	$new_value = array_values($new_value);
	$xaction->setNewValue($new_value);
	break;
	case PhabricatorProjectTransactionType::TYPE_CAN_VIEW:
	$xaction->setOldValue($project->getViewPolicy());
	break;
	case PhabricatorProjectTransactionType::TYPE_CAN_EDIT:
	$xaction->setOldValue($project->getEditPolicy());
	break;
	case PhabricatorProjectTransactionType::TYPE_CAN_JOIN:
	$xaction->setOldValue($project->getJoinPolicy());
	break;
	default:
	throw new Exception("Unknown transaction type '{$type}'!");
	}
	return $this;
	}

	private function applyTransactionEffect(
	PhabricatorProject $project,
	PhabricatorProjectTransaction $xaction) {

	$type = $xaction->getTransactionType();
	switch ($type) {
	case PhabricatorProjectTransactionType::TYPE_NAME:
	$old_slug = $project->getFullPhrictionSlug();
	$project->setName($xaction->getNewValue());
	$project->setPhrictionSlug($xaction->getNewValue());

	if ($xaction->getOldValue()) {
	$old_document = id(new PhrictionDocument())
	->loadOneWhere(
	'slug = %s',
	$old_slug);
	if ($old_document && $old_document->getStatus() ==
	PhrictionDocumentStatus::STATUS_EXISTS) {
	$content = id(new PhrictionContent())
	->load($old_document->getContentID());
	$from_editor = id(PhrictionDocumentEditor::newForSlug($old_slug))
	->setActor($this->getActor())
	->setTitle($content->getTitle())
	->setContent($content->getContent())
	->setDescription($content->getDescription());

	$target_editor = id(PhrictionDocumentEditor::newForSlug(
	$project->getFullPhrictionSlug()))
	->setActor($this->getActor())
	->setTitle($content->getTitle())
	->setContent($content->getContent())
	->setDescription($content->getDescription())
	->moveHere($old_document->getID(), $old_document->getPHID());

	$target_document = $target_editor->getDocument();
	$from_editor->moveAway($target_document->getID());
	}
	}
	$this->validateName($project);
	break;
	case PhabricatorProjectTransactionType::TYPE_STATUS:
	$project->setStatus($xaction->getNewValue());
	break;
	case PhabricatorProjectTransactionType::TYPE_MEMBERS:
	$old = array_fill_keys($xaction->getOldValue(), true);
	$new = array_fill_keys($xaction->getNewValue(), true);
	$this->addEdges = array_keys(array_diff_key($new, $old));
	$this->remEdges = array_keys(array_diff_key($old, $new));
	if ($new === array()) {
	$this->setShouldArchive(true);
	}
	break;
	case PhabricatorProjectTransactionType::TYPE_CAN_VIEW:
	$project->setViewPolicy($xaction->getNewValue());
	break;
	case PhabricatorProjectTransactionType::TYPE_CAN_EDIT:
	$project->setEditPolicy($xaction->getNewValue());

	// You can't edit away your ability to edit the project.
	PhabricatorPolicyFilter::mustRetainCapability(
	$this->getActor(),
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);
	break;
	case PhabricatorProjectTransactionType::TYPE_CAN_JOIN:
	$project->setJoinPolicy($xaction->getNewValue());
	break;
	default:
	throw new Exception("Unknown transaction type '{$type}'!");
	}
	}

	private function publishTransactionStory(
	PhabricatorProject $project,
	PhabricatorProjectTransaction $xaction) {

	$related_phids = array(
	$project->getPHID(),
	$xaction->getAuthorPHID(),
	);

	id(new PhabricatorFeedStoryPublisher())
	->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_PROJECT)
	->setStoryData(
	array(
	'projectPHID' => $project->getPHID(),
	'transactionID' => $xaction->getID(),
	'type' => $xaction->getTransactionType(),
	'old' => $xaction->getOldValue(),
	'new' => $xaction->getNewValue(),
	))
	->setStoryTime(time())
	->setStoryAuthorPHID($xaction->getAuthorPHID())
	->setRelatedPHIDs($related_phids)
	->publish();
	}

	private function transactionHasEffect(
	PhabricatorProjectTransaction $xaction) {
	return ($xaction->getOldValue() !== $xaction->getNewValue());
	}


	/**
	* All transactions except joining or leaving a project require edit
	* capability.
	*/
	private function getTransactionRequiresEditCapability(
	PhabricatorProjectTransaction $xaction) {
	return ($this->isJoinOrLeaveTransaction($xaction) === null);
	}


	/**
	* Joining a project requires the join capability. Anyone leave a project.
	*/
	private function getTransactionRequiresJoinCapability(
	PhabricatorProjectTransaction $xaction) {
	$type = $this->isJoinOrLeaveTransaction($xaction);
	return ($type == 'join');
	}


	/**
	* Returns 'join' if this transaction causes the acting user ONLY to join the
	* project.
	*
	* Returns 'leave' if this transaction causes the acting user ONLY to leave
	* the project.
	*
	* Returns null in all other cases.
	*/
	private function isJoinOrLeaveTransaction(
	PhabricatorProjectTransaction $xaction) {

	$type = $xaction->getTransactionType();
	if ($type != PhabricatorProjectTransactionType::TYPE_MEMBERS) {
	return null;
	}

	switch ($type) {
	case PhabricatorProjectTransactionType::TYPE_MEMBERS:
	$old = $xaction->getOldValue();
	$new = $xaction->getNewValue();

	$add = array_diff($new, $old);
	$rem = array_diff($old, $new);

	if (count($add) > 1) {
	return null;
	} else if (count($add) == 1) {
	if (reset($add) != $this->getActor()->getPHID()) {
	return null;
	} else {
	return 'join';
	}
	}

	if (count($rem) > 1) {
	return null;
	} else if (count($rem) == 1) {
	if (reset($rem) != $this->getActor()->getPHID()) {
	return null;
	} else {
	return 'leave';
	}
	}
	break;
	}

	return true;
	}

	}
	diff --git a/src/applications/project/storage/PhabricatorProject.php b/src/applications/project/storage/PhabricatorProject.php
	index 40074e801d..78cebb50cf 100644
	--- a/src/applications/project/storage/PhabricatorProject.php
	+++ b/src/applications/project/storage/PhabricatorProject.php
	@@ -1,142 +1,133 @@
	<?php

	final class PhabricatorProject extends PhabricatorProjectDAO
	implements PhabricatorPolicyInterface {

	protected $name;
	protected $phid;
	protected $status = PhabricatorProjectStatus::STATUS_ACTIVE;
	protected $authorPHID;
	protected $subprojectPHIDs = array();
	protected $phrictionSlug;

	protected $viewPolicy;
	protected $editPolicy;
	protected $joinPolicy;

	private $subprojectsNeedUpdate;
	private $memberPHIDs = self::ATTACHABLE;
	private $sparseMembers = self::ATTACHABLE;

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

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->getViewPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return $this->getEditPolicy();
	case PhabricatorPolicyCapability::CAN_JOIN:
	return $this->getJoinPolicy();
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	if ($this->isUserMember($viewer->getPHID())) {
	// Project members can always view a project.
	return true;
	}
	break;
	case PhabricatorPolicyCapability::CAN_EDIT:
	break;
	case PhabricatorPolicyCapability::CAN_JOIN:
	$can_edit = PhabricatorPolicyCapability::CAN_EDIT;
	if (PhabricatorPolicyFilter::hasCapability($viewer, $this, $can_edit)) {
	// Project editors can always join a project.
	return true;
	}
	break;
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return pht("Members of a project can always view it.");
	case PhabricatorPolicyCapability::CAN_JOIN:
	return pht("Users who can edit a project can always join it.");
	}
	return null;
	}

	public function isUserMember($user_phid) {
	return $this->assertAttachedKey($this->sparseMembers, $user_phid);
	}

	public function setIsUserMember($user_phid, $is_member) {
	if ($this->sparseMembers === self::ATTACHABLE) {
	$this->sparseMembers = array();
	}
	$this->sparseMembers[$user_phid] = $is_member;
	return $this;
	}

	public function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'subprojectPHIDs' => self::SERIALIZATION_JSON,
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorProjectPHIDTypeProject::TYPECONST);
	}

	public function loadProfile() {
	$profile = id(new PhabricatorProjectProfile())->loadOneWhere(
	'projectPHID = %s',
	$this->getPHID());
	return $profile;
	}

	public function attachMemberPHIDs(array $phids) {
	$this->memberPHIDs = $phids;
	return $this;
	}

	public function getMemberPHIDs() {
	return $this->assertAttached($this->memberPHIDs);
	}

	- public function loadMemberPHIDs() {
	- if (!$this->getPHID()) {
	- return array();
	- }
	- return PhabricatorEdgeQuery::loadDestinationPHIDs(
	- $this->getPHID(),
	- PhabricatorEdgeConfig::TYPE_PROJ_MEMBER);
	- }
	-
	public function setPhrictionSlug($slug) {

	// NOTE: We're doing a little magic here and stripping out '/' so that
	// project pages always appear at top level under projects/ even if the
	// display name is "Hack / Slash" or similar (it will become
	// 'hack_slash' instead of 'hack/slash').

	$slug = str_replace('/', ' ', $slug);
	$slug = PhabricatorSlug::normalize($slug);
	$this->phrictionSlug = $slug;
	return $this;
	}

	public function getFullPhrictionSlug() {
	$slug = $this->getPhrictionSlug();
	return 'projects/'.$slug;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 24, 12:06 AM (22 h, 50 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 182415
Default Alt Text: (64 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions