No OneTemporary
Actions

Size

56 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/conduit/DifferentialUpdateRevisionConduitAPIMethod.php b/src/applications/differential/conduit/DifferentialUpdateRevisionConduitAPIMethod.php
	index 3ad5b07564..d9b0779211 100644
	--- a/src/applications/differential/conduit/DifferentialUpdateRevisionConduitAPIMethod.php
	+++ b/src/applications/differential/conduit/DifferentialUpdateRevisionConduitAPIMethod.php
	@@ -1,89 +1,89 @@
	<?php

	final class DifferentialUpdateRevisionConduitAPIMethod
	extends DifferentialConduitAPIMethod {

	public function getAPIMethodName() {
	return 'differential.updaterevision';
	}

	public function getMethodDescription() {
	return pht('Update a Differential revision.');
	}

	public function getMethodStatus() {
	return self::METHOD_STATUS_FROZEN;
	}

	public function getMethodStatusDescription() {
	return pht(
	'This method is frozen and will eventually be deprecated. New code '.
	'should use "differential.revision.edit" instead.');
	}

	protected function defineParamTypes() {
	return array(
	'id' => 'required revisionid',
	'diffid' => 'required diffid',
	'fields' => 'required dict',
	'message' => 'required string',
	);
	}

	protected function defineReturnType() {
	return 'nonempty dict';
	}

	protected function defineErrorTypes() {
	return array(
	'ERR_BAD_DIFF' => pht('Bad diff ID.'),
	'ERR_BAD_REVISION' => pht('Bad revision ID.'),
	'ERR_WRONG_USER' => pht('You are not the author of this revision.'),
	'ERR_CLOSED' => pht('This revision has already been closed.'),
	);
	}

	protected function execute(ConduitAPIRequest $request) {
	$viewer = $request->getUser();

	$diff = id(new DifferentialDiffQuery())
	->setViewer($viewer)
	->withIDs(array($request->getValue('diffid')))
	->executeOne();
	if (!$diff) {
	throw new ConduitException('ERR_BAD_DIFF');
	}

	$revision = id(new DifferentialRevisionQuery())
	->setViewer($request->getUser())
	->withIDs(array($request->getValue('id')))
	->needReviewers(true)
	->needActiveDiffs(true)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->executeOne();
	if (!$revision) {
	throw new ConduitException('ERR_BAD_REVISION');
	}

	- if ($revision->getStatus() == ArcanistDifferentialRevisionStatus::CLOSED) {
	+ if ($revision->isPublished()) {
	throw new ConduitException('ERR_CLOSED');
	}

	$this->applyFieldEdit(
	$request,
	$revision,
	$diff,
	$request->getValue('fields', array()),
	$request->getValue('message'));

	return array(
	'revisionid' => $revision->getID(),
	'uri' => PhabricatorEnv::getURI('/D'.$revision->getID()),
	);
	}

	}
	diff --git a/src/applications/differential/constants/DifferentialRevisionStatus.php b/src/applications/differential/constants/DifferentialRevisionStatus.php
	index 0b2abe51fe..caca7ed85b 100644
	--- a/src/applications/differential/constants/DifferentialRevisionStatus.php
	+++ b/src/applications/differential/constants/DifferentialRevisionStatus.php
	@@ -1,159 +1,167 @@
	<?php

	final class DifferentialRevisionStatus extends Phobject {

	const NEEDS_REVIEW = 'needs-review';
	const NEEDS_REVISION = 'needs-revision';
	const CHANGES_PLANNED = 'changes-planned';
	const ACCEPTED = 'accepted';
	const PUBLISHED = 'published';
	const ABANDONED = 'abandoned';

	private $key;
	private $spec = array();

	public function getIcon() {
	return idx($this->spec, 'icon');
	}

	public function getIconColor() {
	return idx($this->spec, 'color.icon', 'bluegrey');
	}

	public function getTagColor() {
	return idx($this->spec, 'color.tag', 'bluegrey');
	}

	public function getDisplayName() {
	return idx($this->spec, 'name');
	}

	public function isClosedStatus() {
	return idx($this->spec, 'closed');
	}

	public function isAbandoned() {
	return ($this->key === self::ABANDONED);
	}

	public function isAccepted() {
	return ($this->key === self::ACCEPTED);
	}

	public function isNeedsReview() {
	return ($this->key === self::NEEDS_REVIEW);
	}

	+ public function isPublished() {
	+ return ($this->key === self::PUBLISHED);
	+ }
	+
	+ public function isChangePlanned() {
	+ return ($this->key === self::CHANGES_PLANNED);
	+ }
	+
	public static function newForLegacyStatus($legacy_status) {
	$result = new self();

	$map = self::getMap();
	foreach ($map as $key => $spec) {
	if (!isset($spec['legacy'])) {
	continue;
	}

	if ($spec['legacy'] != $legacy_status) {
	continue;
	}

	$result->key = $key;
	$result->spec = $spec;
	break;
	}

	return $result;
	}

	private static function getMap() {
	$close_on_accept = PhabricatorEnv::getEnvConfig(
	'differential.close-on-accept');

	return array(
	self::NEEDS_REVIEW => array(
	'name' => pht('Needs Review'),
	'legacy' => 0,
	'icon' => 'fa-code',
	'closed' => false,
	'color.icon' => 'grey',
	'color.tag' => 'bluegrey',
	'color.ansi' => 'magenta',
	),
	self::NEEDS_REVISION => array(
	'name' => pht('Needs Revision'),
	'legacy' => 1,
	'icon' => 'fa-refresh',
	'closed' => false,
	'color.icon' => 'red',
	'color.tag' => 'red',
	'color.ansi' => 'red',
	),
	self::CHANGES_PLANNED => array(
	'name' => pht('Changes Planned'),
	'legacy' => 5,
	'icon' => 'fa-headphones',
	'closed' => false,
	'color.icon' => 'red',
	'color.tag' => 'red',
	'color.ansi' => 'red',
	),
	self::ACCEPTED => array(
	'name' => pht('Accepted'),
	'legacy' => 2,
	'icon' => 'fa-check',
	'closed' => $close_on_accept,
	'color.icon' => 'green',
	'color.tag' => 'green',
	'color.ansi' => 'green',
	),
	self::PUBLISHED => array(
	'name' => pht('Closed'),
	'legacy' => 3,
	'icon' => 'fa-check-square-o',
	'closed' => true,
	'color.icon' => 'black',
	'color.tag' => 'indigo',
	'color.ansi' => 'cyan',
	),
	self::ABANDONED => array(
	'name' => pht('Abandoned'),
	'legacy' => 4,
	'icon' => 'fa-plane',
	'closed' => true,
	'color.icon' => 'black',
	'color.tag' => 'indigo',
	'color.ansi' => null,
	),
	);
	}

	public static function getClosedStatuses() {
	$statuses = array(
	ArcanistDifferentialRevisionStatus::CLOSED,
	ArcanistDifferentialRevisionStatus::ABANDONED,
	);

	if (PhabricatorEnv::getEnvConfig('differential.close-on-accept')) {
	$statuses[] = ArcanistDifferentialRevisionStatus::ACCEPTED;
	}

	return $statuses;
	}

	public static function getOpenStatuses() {
	return array_diff(self::getAllStatuses(), self::getClosedStatuses());
	}

	public static function getAllStatuses() {
	return array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
	ArcanistDifferentialRevisionStatus::NEEDS_REVISION,
	ArcanistDifferentialRevisionStatus::CHANGES_PLANNED,
	ArcanistDifferentialRevisionStatus::ACCEPTED,
	ArcanistDifferentialRevisionStatus::CLOSED,
	ArcanistDifferentialRevisionStatus::ABANDONED,
	ArcanistDifferentialRevisionStatus::IN_PREPARATION,
	);
	}

	}
	diff --git a/src/applications/differential/storage/DifferentialRevision.php b/src/applications/differential/storage/DifferentialRevision.php
	index c2856f5d20..a6ce99080a 100644
	--- a/src/applications/differential/storage/DifferentialRevision.php
	+++ b/src/applications/differential/storage/DifferentialRevision.php
	@@ -1,917 +1,925 @@
	<?php

	final class DifferentialRevision extends DifferentialDAO
	implements
	PhabricatorTokenReceiverInterface,
	PhabricatorPolicyInterface,
	PhabricatorExtendedPolicyInterface,
	PhabricatorFlaggableInterface,
	PhrequentTrackableInterface,
	HarbormasterBuildableInterface,
	PhabricatorSubscribableInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorMentionableInterface,
	PhabricatorDestructibleInterface,
	PhabricatorProjectInterface,
	PhabricatorFulltextInterface,
	PhabricatorConduitResultInterface,
	PhabricatorDraftInterface {

	protected $title = '';
	protected $originalTitle;
	protected $status;

	protected $summary = '';
	protected $testPlan = '';

	protected $authorPHID;
	protected $lastReviewerPHID;

	protected $lineCount = 0;
	protected $attached = array();

	protected $mailKey;
	protected $branchName;
	protected $repositoryPHID;
	protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
	protected $editPolicy = PhabricatorPolicies::POLICY_USER;
	protected $properties = array();

	private $commits = self::ATTACHABLE;
	private $activeDiff = self::ATTACHABLE;
	private $diffIDs = self::ATTACHABLE;
	private $hashes = self::ATTACHABLE;
	private $repository = self::ATTACHABLE;

	private $reviewerStatus = self::ATTACHABLE;
	private $customFields = self::ATTACHABLE;
	private $drafts = array();
	private $flags = array();
	private $forceMap = array();

	const TABLE_COMMIT = 'differential_commit';

	const RELATION_REVIEWER = 'revw';
	const RELATION_SUBSCRIBED = 'subd';

	const PROPERTY_CLOSED_FROM_ACCEPTED = 'wasAcceptedBeforeClose';

	public static function initializeNewRevision(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorDifferentialApplication'))
	->executeOne();

	$view_policy = $app->getPolicy(
	DifferentialDefaultViewCapability::CAPABILITY);

	return id(new DifferentialRevision())
	->setViewPolicy($view_policy)
	->setAuthorPHID($actor->getPHID())
	->attachRepository(null)
	->attachActiveDiff(null)
	->attachReviewers(array())
	->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVIEW);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_SERIALIZATION => array(
	'attached' => self::SERIALIZATION_JSON,
	'unsubscribed' => self::SERIALIZATION_JSON,
	'properties' => self::SERIALIZATION_JSON,
	),
	self::CONFIG_COLUMN_SCHEMA => array(
	'title' => 'text255',
	'originalTitle' => 'text255',
	'status' => 'text32',
	'summary' => 'text',
	'testPlan' => 'text',
	'authorPHID' => 'phid?',
	'lastReviewerPHID' => 'phid?',
	'lineCount' => 'uint32?',
	'mailKey' => 'bytes40',
	'branchName' => 'text255?',
	'repositoryPHID' => 'phid?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'authorPHID' => array(
	'columns' => array('authorPHID', 'status'),
	),
	'repositoryPHID' => array(
	'columns' => array('repositoryPHID'),
	),
	// If you (or a project you are a member of) is reviewing a significant
	// fraction of the revisions on an install, the result set of open
	// revisions may be smaller than the result set of revisions where you
	// are a reviewer. In these cases, this key is better than keys on the
	// edge table.
	'key_status' => array(
	'columns' => array('status', 'phid'),
	),
	),
	) + parent::getConfiguration();
	}

	public function setProperty($key, $value) {
	$this->properties[$key] = $value;
	return $this;
	}

	public function getProperty($key, $default = null) {
	return idx($this->properties, $key, $default);
	}

	public function hasRevisionProperty($key) {
	return array_key_exists($key, $this->properties);
	}

	public function getMonogram() {
	$id = $this->getID();
	return "D{$id}";
	}

	public function getURI() {
	return '/'.$this->getMonogram();
	}

	public function setTitle($title) {
	$this->title = $title;
	if (!$this->getID()) {
	$this->originalTitle = $title;
	}
	return $this;
	}

	public function loadIDsByCommitPHIDs($phids) {
	if (!$phids) {
	return array();
	}
	$revision_ids = queryfx_all(
	$this->establishConnection('r'),
	'SELECT * FROM %T WHERE commitPHID IN (%Ls)',
	self::TABLE_COMMIT,
	$phids);
	return ipull($revision_ids, 'revisionID', 'commitPHID');
	}

	public function loadCommitPHIDs() {
	if (!$this->getID()) {
	return ($this->commits = array());
	}

	$commits = queryfx_all(
	$this->establishConnection('r'),
	'SELECT commitPHID FROM %T WHERE revisionID = %d',
	self::TABLE_COMMIT,
	$this->getID());
	$commits = ipull($commits, 'commitPHID');

	return ($this->commits = $commits);
	}

	public function getCommitPHIDs() {
	return $this->assertAttached($this->commits);
	}

	public function getActiveDiff() {
	// TODO: Because it's currently technically possible to create a revision
	// without an associated diff, we allow an attached-but-null active diff.
	// It would be good to get rid of this once we make diff-attaching
	// transactional.

	return $this->assertAttached($this->activeDiff);
	}

	public function attachActiveDiff($diff) {
	$this->activeDiff = $diff;
	return $this;
	}

	public function getDiffIDs() {
	return $this->assertAttached($this->diffIDs);
	}

	public function attachDiffIDs(array $ids) {
	rsort($ids);
	$this->diffIDs = array_values($ids);
	return $this;
	}

	public function attachCommitPHIDs(array $phids) {
	$this->commits = array_values($phids);
	return $this;
	}

	public function getAttachedPHIDs($type) {
	return array_keys(idx($this->attached, $type, array()));
	}

	public function setAttachedPHIDs($type, array $phids) {
	$this->attached[$type] = array_fill_keys($phids, array());
	return $this;
	}

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

	public function loadActiveDiff() {
	return id(new DifferentialDiff())->loadOneWhere(
	'revisionID = %d ORDER BY id DESC LIMIT 1',
	$this->getID());
	}

	public function save() {
	if (!$this->getMailKey()) {
	$this->mailKey = Filesystem::readRandomCharacters(40);
	}
	return parent::save();
	}

	public function getHashes() {
	return $this->assertAttached($this->hashes);
	}

	public function attachHashes(array $hashes) {
	$this->hashes = $hashes;
	return $this;
	}

	public function canReviewerForceAccept(
	PhabricatorUser $viewer,
	DifferentialReviewer $reviewer) {

	if (!$reviewer->isPackage()) {
	return false;
	}

	$map = $this->getReviewerForceAcceptMap($viewer);
	if (!$map) {
	return false;
	}

	if (isset($map[$reviewer->getReviewerPHID()])) {
	return true;
	}

	return false;
	}

	private function getReviewerForceAcceptMap(PhabricatorUser $viewer) {
	$fragment = $viewer->getCacheFragment();

	if (!array_key_exists($fragment, $this->forceMap)) {
	$map = $this->newReviewerForceAcceptMap($viewer);
	$this->forceMap[$fragment] = $map;
	}

	return $this->forceMap[$fragment];
	}

	private function newReviewerForceAcceptMap(PhabricatorUser $viewer) {
	$diff = $this->getActiveDiff();
	if (!$diff) {
	return null;
	}

	$repository_phid = $diff->getRepositoryPHID();
	if (!$repository_phid) {
	return null;
	}

	$paths = array();

	try {
	$changesets = $diff->getChangesets();
	} catch (Exception $ex) {
	$changesets = id(new DifferentialChangesetQuery())
	->setViewer($viewer)
	->withDiffs(array($diff))
	->execute();
	}

	foreach ($changesets as $changeset) {
	$paths[] = $changeset->getOwnersFilename();
	}

	if (!$paths) {
	return null;
	}

	$reviewer_phids = array();
	foreach ($this->getReviewers() as $reviewer) {
	if (!$reviewer->isPackage()) {
	continue;
	}

	$reviewer_phids[] = $reviewer->getReviewerPHID();
	}

	if (!$reviewer_phids) {
	return null;
	}

	// Load all the reviewing packages which have control over some of the
	// paths in the change. These are packages which the actor may be able
	// to force-accept on behalf of.
	$control_query = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withPHIDs($reviewer_phids)
	->withControl($repository_phid, $paths);
	$control_packages = $control_query->execute();
	if (!$control_packages) {
	return null;
	}

	// Load all the packages which have potential control over some of the
	// paths in the change and are owned by the actor. These are packages
	// which the actor may be able to use their authority over to gain the
	// ability to force-accept for other packages. This query doesn't apply
	// dominion rules yet, and we'll bypass those rules later on.
	$authority_query = id(new PhabricatorOwnersPackageQuery())
	->setViewer($viewer)
	->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
	->withAuthorityPHIDs(array($viewer->getPHID()))
	->withControl($repository_phid, $paths);
	$authority_packages = $authority_query->execute();
	if (!$authority_packages) {
	return null;
	}
	$authority_packages = mpull($authority_packages, null, 'getPHID');

	// Build a map from each path in the revision to the reviewer packages
	// which control it.
	$control_map = array();
	foreach ($paths as $path) {
	$control_packages = $control_query->getControllingPackagesForPath(
	$repository_phid,
	$path);

	// Remove packages which the viewer has authority over. We don't need
	// to check these for force-accept because they can just accept them
	// normally.
	$control_packages = mpull($control_packages, null, 'getPHID');
	foreach ($control_packages as $phid => $control_package) {
	if (isset($authority_packages[$phid])) {
	unset($control_packages[$phid]);
	}
	}

	if (!$control_packages) {
	continue;
	}

	$control_map[$path] = $control_packages;
	}

	if (!$control_map) {
	return null;
	}

	// From here on out, we only care about paths which we have at least one
	// controlling package for.
	$paths = array_keys($control_map);

	// Now, build a map from each path to the packages which would control it
	// if there were no dominion rules.
	$authority_map = array();
	foreach ($paths as $path) {
	$authority_packages = $authority_query->getControllingPackagesForPath(
	$repository_phid,
	$path,
	$ignore_dominion = true);

	$authority_map[$path] = mpull($authority_packages, null, 'getPHID');
	}

	// For each path, find the most general package that the viewer has
	// authority over. For example, we'll prefer a package that owns "/" to a
	// package that owns "/src/".
	$force_map = array();
	foreach ($authority_map as $path => $package_map) {
	$path_fragments = PhabricatorOwnersPackage::splitPath($path);
	$fragment_count = count($path_fragments);

	// Find the package that we have authority over which has the most
	// general match for this path.
	$best_match = null;
	$best_package = null;
	foreach ($package_map as $package_phid => $package) {
	$package_paths = $package->getPathsForRepository($repository_phid);
	foreach ($package_paths as $package_path) {

	// NOTE: A strength of 0 means "no match". A strength of 1 means
	// that we matched "/", so we can not possibly find another stronger
	// match.

	$strength = $package_path->getPathMatchStrength(
	$path_fragments,
	$fragment_count);
	if (!$strength) {
	continue;
	}

	if ($strength < $best_match \|\| !$best_package) {
	$best_match = $strength;
	$best_package = $package;
	if ($strength == 1) {
	break 2;
	}
	}
	}
	}

	if ($best_package) {
	$force_map[$path] = array(
	'strength' => $best_match,
	'package' => $best_package,
	);
	}
	}

	// For each path which the viewer owns a package for, find other packages
	// which that authority can be used to force-accept. Once we find a way to
	// force-accept a package, we don't need to keep loooking.
	$has_control = array();
	foreach ($force_map as $path => $spec) {
	$path_fragments = PhabricatorOwnersPackage::splitPath($path);
	$fragment_count = count($path_fragments);

	$authority_strength = $spec['strength'];

	$control_packages = $control_map[$path];
	foreach ($control_packages as $control_phid => $control_package) {
	if (isset($has_control[$control_phid])) {
	continue;
	}

	$control_paths = $control_package->getPathsForRepository(
	$repository_phid);
	foreach ($control_paths as $control_path) {
	$strength = $control_path->getPathMatchStrength(
	$path_fragments,
	$fragment_count);

	if (!$strength) {
	continue;
	}

	if ($strength > $authority_strength) {
	$authority = $spec['package'];
	$has_control[$control_phid] = array(
	'authority' => $authority,
	'phid' => $authority->getPHID(),
	);
	break;
	}
	}
	}
	}

	// Return a map from packages which may be force accepted to the packages
	// which permit that forced acceptance.
	return ipull($has_control, 'phid');
	}


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


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

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

	public function hasAutomaticCapability($capability, PhabricatorUser $user) {
	// A revision's author (which effectively means "owner" after we added
	// commandeering) can always view and edit it.
	$author_phid = $this->getAuthorPHID();
	if ($author_phid) {
	if ($user->getPHID() == $author_phid) {
	return true;
	}
	}

	return false;
	}

	public function describeAutomaticCapability($capability) {
	$description = array(
	pht('The owner of a revision can always view and edit it.'),
	);

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$description[] = pht(
	'If a revision belongs to a repository, other users must be able '.
	'to view the repository in order to view the revision.');
	break;
	}

	return $description;
	}


	/* -( PhabricatorExtendedPolicyInterface )--------------------------------- */


	public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
	$extended = array();

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	$repository_phid = $this->getRepositoryPHID();
	$repository = $this->getRepository();

	// Try to use the object if we have it, since it will save us some
	// data fetching later on. In some cases, we might not have it.
	$repository_ref = nonempty($repository, $repository_phid);
	if ($repository_ref) {
	$extended[] = array(
	$repository_ref,
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}
	break;
	}

	return $extended;
	}


	/* -( PhabricatorTokenReceiverInterface )---------------------------------- */


	public function getUsersToNotifyOfTokenGiven() {
	return array(
	$this->getAuthorPHID(),
	);
	}

	public function getReviewers() {
	return $this->assertAttached($this->reviewerStatus);
	}

	public function attachReviewers(array $reviewers) {
	assert_instances_of($reviewers, 'DifferentialReviewer');
	$reviewers = mpull($reviewers, null, 'getReviewerPHID');
	$this->reviewerStatus = $reviewers;
	return $this;
	}

	public function getReviewerPHIDs() {
	$reviewers = $this->getReviewers();
	return mpull($reviewers, 'getReviewerPHID');
	}

	public function getReviewerPHIDsForEdit() {
	$reviewers = $this->getReviewers();

	$status_blocking = DifferentialReviewerStatus::STATUS_BLOCKING;

	$value = array();
	foreach ($reviewers as $reviewer) {
	$phid = $reviewer->getReviewerPHID();
	if ($reviewer->getReviewerStatus() == $status_blocking) {
	$value[] = 'blocking('.$phid.')';
	} else {
	$value[] = $phid;
	}
	}

	return $value;
	}

	public function getRepository() {
	return $this->assertAttached($this->repository);
	}

	public function attachRepository(PhabricatorRepository $repository = null) {
	$this->repository = $repository;
	return $this;
	}

	public function isClosed() {
	return $this->getStatusObject()->isClosedStatus();
	}

	public function isAbandoned() {
	return $this->getStatusObject()->isAbandoned();
	}

	public function isAccepted() {
	return $this->getStatusObject()->isAccepted();
	}

	public function isNeedsReview() {
	return $this->getStatusObject()->isNeedsReview();
	}

	+ public function isChangePlanned() {
	+ return $this->getStatusObject()->isChangePlanned();
	+ }
	+
	+ public function isPublished() {
	+ return $this->getStatusObject()->isPublished();
	+ }
	+
	public function getStatusIcon() {
	return $this->getStatusObject()->getIcon();
	}

	public function getStatusDisplayName() {
	return $this->getStatusObject()->getDisplayName();
	}

	public function getStatusIconColor() {
	return $this->getStatusObject()->getIconColor();
	}

	public function getStatusObject() {
	$status = $this->getStatus();
	return DifferentialRevisionStatus::newForLegacyStatus($status);
	}

	public function getFlag(PhabricatorUser $viewer) {
	return $this->assertAttachedKey($this->flags, $viewer->getPHID());
	}

	public function attachFlag(
	PhabricatorUser $viewer,
	PhabricatorFlag $flag = null) {
	$this->flags[$viewer->getPHID()] = $flag;
	return $this;
	}

	public function getHasDraft(PhabricatorUser $viewer) {
	return $this->assertAttachedKey($this->drafts, $viewer->getCacheFragment());
	}

	public function attachHasDraft(PhabricatorUser $viewer, $has_draft) {
	$this->drafts[$viewer->getCacheFragment()] = $has_draft;
	return $this;
	}


	/* -( HarbormasterBuildableInterface )------------------------------------- */


	public function getHarbormasterBuildableDisplayPHID() {
	return $this->getHarbormasterContainerPHID();
	}

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

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

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

	public function getBuildVariables() {
	return array();
	}

	public function getAvailableBuildVariables() {
	return array();
	}


	/* -( PhabricatorSubscribableInterface )----------------------------------- */


	public function isAutomaticallySubscribed($phid) {
	if ($phid == $this->getAuthorPHID()) {
	return true;
	}

	// TODO: This only happens when adding or removing CCs, and is safe from a
	// policy perspective, but the subscription pathway should have some
	// opportunity to load this data properly. For now, this is the only case
	// where implicit subscription is not an intrinsic property of the object.
	if ($this->reviewerStatus == self::ATTACHABLE) {
	$reviewers = id(new DifferentialRevisionQuery())
	->setViewer(PhabricatorUser::getOmnipotentUser())
	->withPHIDs(array($this->getPHID()))
	->needReviewers(true)
	->executeOne()
	->getReviewers();
	} else {
	$reviewers = $this->getReviewers();
	}

	foreach ($reviewers as $reviewer) {
	if ($reviewer->getReviewerPHID() == $phid) {
	return true;
	}
	}

	return false;
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('differential.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'DifferentialCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new DifferentialTransactionEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new DifferentialTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {
	$viewer = $request->getViewer();

	$render_data = $timeline->getRenderData();
	$left = $request->getInt('left', idx($render_data, 'left'));
	$right = $request->getInt('right', idx($render_data, 'right'));

	$diffs = id(new DifferentialDiffQuery())
	->setViewer($request->getUser())
	->withIDs(array($left, $right))
	->execute();
	$diffs = mpull($diffs, null, 'getID');
	$left_diff = $diffs[$left];
	$right_diff = $diffs[$right];

	$old_ids = $request->getStr('old', idx($render_data, 'old'));
	$new_ids = $request->getStr('new', idx($render_data, 'new'));
	$old_ids = array_filter(explode(',', $old_ids));
	$new_ids = array_filter(explode(',', $new_ids));

	$type_inline = DifferentialTransaction::TYPE_INLINE;
	$changeset_ids = array_merge($old_ids, $new_ids);
	$inlines = array();
	foreach ($timeline->getTransactions() as $xaction) {
	if ($xaction->getTransactionType() == $type_inline) {
	$inlines[] = $xaction->getComment();
	$changeset_ids[] = $xaction->getComment()->getChangesetID();
	}
	}

	if ($changeset_ids) {
	$changesets = id(new DifferentialChangesetQuery())
	->setViewer($request->getUser())
	->withIDs($changeset_ids)
	->execute();
	$changesets = mpull($changesets, null, 'getID');
	} else {
	$changesets = array();
	}

	foreach ($inlines as $key => $inline) {
	$inlines[$key] = DifferentialInlineComment::newFromModernComment(
	$inline);
	}

	$query = id(new DifferentialInlineCommentQuery())
	->needHidden(true)
	->setViewer($viewer);

	// NOTE: This is a bit sketchy: this method adjusts the inlines as a
	// side effect, which means it will ultimately adjust the transaction
	// comments and affect timeline rendering.
	$query->adjustInlinesForChangesets(
	$inlines,
	array_select_keys($changesets, $old_ids),
	array_select_keys($changesets, $new_ids),
	$this);

	return $timeline
	->setChangesets($changesets)
	->setRevision($this)
	->setLeftDiff($left_diff)
	->setRightDiff($right_diff);
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$diffs = id(new DifferentialDiffQuery())
	->setViewer($engine->getViewer())
	->withRevisionIDs(array($this->getID()))
	->execute();
	foreach ($diffs as $diff) {
	$engine->destroyObject($diff);
	}

	$conn_w = $this->establishConnection('w');

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	self::TABLE_COMMIT,
	$this->getID());

	// we have to do paths a little differentally as they do not have
	// an id or phid column for delete() to act on
	$dummy_path = new DifferentialAffectedPath();
	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE revisionID = %d',
	$dummy_path->getTableName(),
	$this->getID());

	$this->delete();
	$this->saveTransaction();
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new DifferentialRevisionFulltextEngine();
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('title')
	->setType('string')
	->setDescription(pht('The revision title.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('authorPHID')
	->setType('phid')
	->setDescription(pht('Revision author PHID.')),
	);
	}

	public function getFieldValuesForConduit() {
	return array(
	'title' => $this->getTitle(),
	'authorPHID' => $this->getAuthorPHID(),
	);
	}

	public function getConduitSearchAttachments() {
	return array(
	id(new DifferentialReviewersSearchEngineAttachment())
	->setAttachmentKey('reviewers'),
	);
	}


	/* -( PhabricatorDraftInterface )------------------------------------------ */


	public function newDraftEngine() {
	return new DifferentialRevisionDraftEngine();
	}

	}
	diff --git a/src/applications/differential/xaction/DifferentialRevisionPlanChangesTransaction.php b/src/applications/differential/xaction/DifferentialRevisionPlanChangesTransaction.php
	index e7cdaa2455..58152bdb67 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionPlanChangesTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionPlanChangesTransaction.php
	@@ -1,97 +1,95 @@
	<?php

	final class DifferentialRevisionPlanChangesTransaction
	extends DifferentialRevisionActionTransaction {

	const TRANSACTIONTYPE = 'differential.revision.plan';
	const ACTIONKEY = 'plan-changes';

	protected function getRevisionActionLabel() {
	return pht('Plan Changes');
	}

	protected function getRevisionActionDescription() {
	return pht(
	'This revision will be removed from review queues until it is revised.');
	}

	public function getIcon() {
	return 'fa-headphones';
	}

	public function getColor() {
	return 'red';
	}

	protected function getRevisionActionOrder() {
	return 200;
	}

	public function getActionName() {
	return pht('Planned Changes');
	}

	public function getCommandKeyword() {
	return 'planchanges';
	}

	public function getCommandAliases() {
	return array(
	'rethink',
	);
	}

	public function getCommandSummary() {
	return pht('Plan changes to a revision.');
	}

	public function generateOldValue($object) {
	$status_planned = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;
	return ($object->getStatus() == $status_planned);
	}

	public function applyInternalEffects($object, $value) {
	$status_planned = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;
	$object->setStatus($status_planned);
	}

	protected function validateAction($object, PhabricatorUser $viewer) {
	- $status_planned = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;
	-
	- if ($object->getStatus() == $status_planned) {
	+ if ($object->isChangePlanned()) {
	throw new Exception(
	pht(
	'You can not request review of this revision because this '.
	'revision is already under review and the action would have '.
	'no effect.'));
	}

	if ($object->isClosed()) {
	throw new Exception(
	pht(
	'You can not plan changes to this this revision because it has '.
	'already been closed.'));
	}

	if (!$this->isViewerRevisionAuthor($object, $viewer)) {
	throw new Exception(
	pht(
	'You can not plan changes to this revision because you do not '.
	'own it. Only the author of a revision can plan changes to it.'));
	}
	}

	public function getTitle() {
	return pht(
	'%s planned changes to this revision.',
	$this->renderAuthor());
	}

	public function getTitleForFeed() {
	return pht(
	'%s planned changes to %s.',
	$this->renderAuthor(),
	$this->renderObject());
	}

	}
	diff --git a/src/applications/differential/xaction/DifferentialRevisionReopenTransaction.php b/src/applications/differential/xaction/DifferentialRevisionReopenTransaction.php
	index 84015b9286..e2b217603a 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionReopenTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionReopenTransaction.php
	@@ -1,76 +1,73 @@
	<?php

	final class DifferentialRevisionReopenTransaction
	extends DifferentialRevisionActionTransaction {

	const TRANSACTIONTYPE = 'differential.revision.reopen';
	const ACTIONKEY = 'reopen';

	protected function getRevisionActionLabel() {
	return pht('Reopen Revision');
	}

	protected function getRevisionActionDescription() {
	return pht('This revision will be reopened for review.');
	}

	public function getIcon() {
	return 'fa-bullhorn';
	}

	public function getColor() {
	return 'sky';
	}

	protected function getRevisionActionOrder() {
	return 400;
	}

	public function getActionName() {
	return pht('Reopened');
	}

	public function generateOldValue($object) {
	return !$object->isClosed();
	}

	public function applyInternalEffects($object, $value) {
	$object->setStatus(ArcanistDifferentialRevisionStatus::NEEDS_REVIEW);
	}

	protected function validateAction($object, PhabricatorUser $viewer) {
	- // Note that we're testing for "Closed", exactly, not just any closed
	- // status.
	- $status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	- if ($object->getStatus() != $status_closed) {
	+ if ($object->isPublished()) {
	throw new Exception(
	pht(
	'You can not reopen this revision because it is not closed. '.
	'Only closed revisions can be reopened.'));
	}

	$config_key = 'differential.allow-reopen';
	if (!PhabricatorEnv::getEnvConfig($config_key)) {
	throw new Exception(
	pht(
	'You can not reopen this revision because configuration prevents '.
	'any revision from being reopened. You can change this behavior '.
	'by adjusting the "%s" setting in Config.',
	$config_key));
	}
	}

	public function getTitle() {
	return pht(
	'%s reopened this revision.',
	$this->renderAuthor());
	}

	public function getTitleForFeed() {
	return pht(
	'%s reopened %s.',
	$this->renderAuthor(),
	$this->renderObject());
	}

	}
	diff --git a/src/applications/differential/xaction/DifferentialRevisionRequestReviewTransaction.php b/src/applications/differential/xaction/DifferentialRevisionRequestReviewTransaction.php
	index 32fcb3271e..65b96d6d8e 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionRequestReviewTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionRequestReviewTransaction.php
	@@ -1,78 +1,77 @@
	<?php

	final class DifferentialRevisionRequestReviewTransaction
	extends DifferentialRevisionActionTransaction {

	const TRANSACTIONTYPE = 'differential.revision.request';
	const ACTIONKEY = 'request-review';

	protected function getRevisionActionLabel() {
	return pht('Request Review');
	}

	protected function getRevisionActionDescription() {
	return pht('This revision will be returned to reviewers for feedback.');
	}

	public function getColor() {
	return 'sky';
	}

	protected function getRevisionActionOrder() {
	return 200;
	}

	public function getActionName() {
	return pht('Requested Review');
	}

	public function generateOldValue($object) {
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	return ($object->getStatus() == $status_review);
	}

	public function applyInternalEffects($object, $value) {
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	$object->setStatus($status_review);
	}

	protected function validateAction($object, PhabricatorUser $viewer) {
	- $status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
	- if ($object->getStatus() == $status_review) {
	+ if ($object->isNeedsReview()) {
	throw new Exception(
	pht(
	'You can not request review of this revision because this '.
	'revision is already under review and the action would have '.
	'no effect.'));
	}

	if ($object->isClosed()) {
	throw new Exception(
	pht(
	'You can not request review of this revision because it has '.
	'already been closed. You can only request review of open '.
	'revisions.'));
	}

	if (!$this->isViewerRevisionAuthor($object, $viewer)) {
	throw new Exception(
	pht(
	'You can not request review of this revision because you are not '.
	'the author of the revision.'));
	}
	}

	public function getTitle() {
	return pht(
	'%s requested review of this revision.',
	$this->renderAuthor());
	}

	public function getTitleForFeed() {
	return pht(
	'%s requested review of %s.',
	$this->renderAuthor(),
	$this->renderObject());
	}

	}
	diff --git a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	index f7e3a735a4..ab11a83b38 100644
	--- a/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	+++ b/src/applications/repository/worker/commitmessageparser/PhabricatorRepositoryCommitMessageParserWorker.php
	@@ -1,418 +1,415 @@
	<?php

	abstract class PhabricatorRepositoryCommitMessageParserWorker
	extends PhabricatorRepositoryCommitParserWorker {

	protected function getImportStepFlag() {
	return PhabricatorRepositoryCommit::IMPORTED_MESSAGE;
	}

	abstract protected function getFollowupTaskClass();

	final protected function parseCommit(
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit) {

	if (!$this->shouldSkipImportStep()) {
	$viewer = PhabricatorUser::getOmnipotentUser();

	$refs_raw = DiffusionQuery::callConduitWithDiffusionRequest(
	$viewer,
	DiffusionRequest::newFromDictionary(
	array(
	'repository' => $repository,
	'user' => $viewer,
	)),
	'diffusion.querycommits',
	array(
	'repositoryPHID' => $repository->getPHID(),
	'phids' => array($commit->getPHID()),
	'bypassCache' => true,
	'needMessages' => true,
	));

	if (empty($refs_raw['data'])) {
	throw new Exception(
	pht(
	'Unable to retrieve details for commit "%s"!',
	$commit->getPHID()));
	}

	$ref = DiffusionCommitRef::newFromConduitResult(head($refs_raw['data']));
	$this->updateCommitData($ref);
	}

	if ($this->shouldQueueFollowupTasks()) {
	$this->queueTask(
	$this->getFollowupTaskClass(),
	array(
	'commitID' => $commit->getID(),
	),
	array(
	// We queue followup tasks at default priority so that the queue
	// finishes work it has started before starting more work. If
	// followups are queued at the same priority level, we do all
	// message parses first, then all change parses, etc. This makes
	// progress uneven. See T11677 for discussion.
	'priority' => PhabricatorWorker::PRIORITY_DEFAULT,
	));
	}
	}

	final protected function updateCommitData(DiffusionCommitRef $ref) {
	$commit = $this->commit;
	$author = $ref->getAuthor();
	$message = $ref->getMessage();
	$committer = $ref->getCommitter();
	$hashes = $ref->getHashes();

	$data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
	'commitID = %d',
	$commit->getID());
	if (!$data) {
	$data = new PhabricatorRepositoryCommitData();
	}
	$data->setCommitID($commit->getID());
	$data->setAuthorName(id(new PhutilUTF8StringTruncator())
	->setMaximumBytes(255)
	->truncateString((string)$author));

	$data->setCommitDetail('authorEpoch', $ref->getAuthorEpoch());
	$data->setCommitDetail('authorName', $ref->getAuthorName());
	$data->setCommitDetail('authorEmail', $ref->getAuthorEmail());

	$data->setCommitDetail(
	'authorPHID',
	$this->resolveUserPHID($commit, $author));

	$data->setCommitMessage($message);

	if (strlen($committer)) {
	$data->setCommitDetail('committer', $committer);

	$data->setCommitDetail('committerName', $ref->getCommitterName());
	$data->setCommitDetail('committerEmail', $ref->getCommitterEmail());

	$data->setCommitDetail(
	'committerPHID',
	$this->resolveUserPHID($commit, $committer));
	}

	$repository = $this->repository;

	$author_phid = $data->getCommitDetail('authorPHID');
	$committer_phid = $data->getCommitDetail('committerPHID');

	$user = new PhabricatorUser();
	if ($author_phid) {
	$user = $user->loadOneWhere(
	'phid = %s',
	$author_phid);
	}

	$differential_app = 'PhabricatorDifferentialApplication';
	$revision_id = null;
	$low_level_query = null;
	if (PhabricatorApplication::isClassInstalled($differential_app)) {
	$low_level_query = id(new DiffusionLowLevelCommitFieldsQuery())
	->setRepository($repository)
	->withCommitRef($ref);
	$field_values = $low_level_query->execute();
	$revision_id = idx($field_values, 'revisionID');

	if (!empty($field_values['reviewedByPHIDs'])) {
	$data->setCommitDetail(
	'reviewerPHID',
	reset($field_values['reviewedByPHIDs']));
	}

	$data->setCommitDetail('differential.revisionID', $revision_id);
	}

	if ($author_phid != $commit->getAuthorPHID()) {
	$commit->setAuthorPHID($author_phid);
	}

	$commit->setSummary($data->getSummary());
	$commit->save();

	// Figure out if we're going to try to "autoclose" related objects (e.g.,
	// close linked tasks and related revisions) and, if not, record why we
	// aren't. Autoclose can be disabled for various reasons at the repository
	// or commit levels.

	$force_autoclose = idx($this->getTaskData(), 'forceAutoclose', false);
	if ($force_autoclose) {
	$autoclose_reason = PhabricatorRepository::BECAUSE_AUTOCLOSE_FORCED;
	} else {
	$autoclose_reason = $repository->shouldSkipAutocloseCommit($commit);
	}
	$data->setCommitDetail('autocloseReason', $autoclose_reason);
	$should_autoclose = $force_autoclose \|\|
	$repository->shouldAutocloseCommit($commit);


	// When updating related objects, we'll act under an omnipotent user to
	// ensure we can see them, but take actions as either the committer or
	// author (if we recognize their accounts) or the Diffusion application
	// (if we do not).

	$actor = PhabricatorUser::getOmnipotentUser();
	$acting_as_phid = nonempty(
	$committer_phid,
	$author_phid,
	id(new PhabricatorDiffusionApplication())->getPHID());

	$acting_user = $this->loadActingUser($actor, $acting_as_phid);

	$conn_w = id(new DifferentialRevision())->establishConnection('w');

	// NOTE: The `differential_commit` table has a unique ID on `commitPHID`,
	// preventing more than one revision from being associated with a commit.
	// Generally this is good and desirable, but with the advent of hash
	// tracking we may end up in a situation where we match several different
	// revisions. We just kind of ignore this and pick one, we might want to
	// revisit this and do something differently. (If we match several revisions
	// someone probably did something very silly, though.)

	$revision = null;
	if ($revision_id) {
	$revision_query = id(new DifferentialRevisionQuery())
	->withIDs(array($revision_id))
	->setViewer($actor)
	->needReviewers(true)
	->needActiveDiffs(true);

	$revision = $revision_query->executeOne();

	if ($revision) {
	if (!$data->getCommitDetail('precommitRevisionStatus')) {
	$data->setCommitDetail(
	'precommitRevisionStatus',
	$revision->getStatus());
	}
	$commit_drev = DiffusionCommitHasRevisionEdgeType::EDGECONST;
	id(new PhabricatorEdgeEditor())
	->addEdge($commit->getPHID(), $commit_drev, $revision->getPHID())
	->save();

	queryfx(
	$conn_w,
	'INSERT IGNORE INTO %T (revisionID, commitPHID) VALUES (%d, %s)',
	DifferentialRevision::TABLE_COMMIT,
	$revision->getID(),
	$commit->getPHID());

	- $status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	- $should_close = ($revision->getStatus() != $status_closed) &&
	- $should_autoclose;
	-
	+ $should_close = !$revision->isPublished() && $should_autoclose;
	if ($should_close) {
	$commit_close_xaction = id(new DifferentialTransaction())
	->setTransactionType(DifferentialTransaction::TYPE_ACTION)
	->setNewValue(DifferentialAction::ACTION_CLOSE)
	->setMetadataValue('isCommitClose', true);

	$commit_close_xaction->setMetadataValue(
	'commitPHID',
	$commit->getPHID());
	$commit_close_xaction->setMetadataValue(
	'committerPHID',
	$committer_phid);
	$commit_close_xaction->setMetadataValue(
	'committerName',
	$data->getCommitDetail('committer'));
	$commit_close_xaction->setMetadataValue(
	'authorPHID',
	$author_phid);
	$commit_close_xaction->setMetadataValue(
	'authorName',
	$data->getAuthorName());

	if ($low_level_query) {
	$commit_close_xaction->setMetadataValue(
	'revisionMatchData',
	$low_level_query->getRevisionMatchData());
	$data->setCommitDetail(
	'revisionMatchData',
	$low_level_query->getRevisionMatchData());
	}

	$extraction_engine = id(new DifferentialDiffExtractionEngine())
	->setViewer($actor)
	->setAuthorPHID($acting_as_phid);

	$content_source = $this->newContentSource();

	$update_data = $extraction_engine->updateRevisionWithCommit(
	$revision,
	$commit,
	array(
	$commit_close_xaction,
	),
	$content_source);

	foreach ($update_data as $key => $value) {
	$data->setCommitDetail($key, $value);
	}
	}
	}
	}

	if ($should_autoclose) {
	$this->closeTasks(
	$actor,
	$acting_as_phid,
	$repository,
	$commit,
	$message,
	$acting_user);
	}

	$data->save();

	$commit->writeImportStatusFlag(
	PhabricatorRepositoryCommit::IMPORTED_MESSAGE);
	}

	private function resolveUserPHID(
	PhabricatorRepositoryCommit $commit,
	$user_name) {

	return id(new DiffusionResolveUserQuery())
	->withCommit($commit)
	->withName($user_name)
	->execute();
	}

	private function closeTasks(
	PhabricatorUser $actor,
	$acting_as,
	PhabricatorRepository $repository,
	PhabricatorRepositoryCommit $commit,
	$message,
	PhabricatorUser $acting_user = null) {

	// If we we were able to identify an author for the commit, we try to act
	// as that user when loading tasks marked with "Fixes Txxx". This prevents
	// mistakes where a user accidentally writes the wrong task IDs and affects
	// tasks they can't see (and thus can't undo the status changes for).

	// This is just a guard rail, not a security measure. An attacker can still
	// forge another user's identity trivially by forging author or committer
	// emails. We also let commits with unrecognized authors act on any task to
	// make behavior less confusing for new installs.

	if (!$acting_user) {
	$acting_user = $actor;
	}

	$maniphest = 'PhabricatorManiphestApplication';
	if (!PhabricatorApplication::isClassInstalled($maniphest)) {
	return;
	}

	$prefixes = ManiphestTaskStatus::getStatusPrefixMap();
	$suffixes = ManiphestTaskStatus::getStatusSuffixMap();

	$matches = id(new ManiphestCustomFieldStatusParser())
	->parseCorpus($message);

	$task_statuses = array();
	foreach ($matches as $match) {
	$prefix = phutil_utf8_strtolower($match['prefix']);
	$suffix = phutil_utf8_strtolower($match['suffix']);

	$status = idx($suffixes, $suffix);
	if (!$status) {
	$status = idx($prefixes, $prefix);
	}

	foreach ($match['monograms'] as $task_monogram) {
	$task_id = (int)trim($task_monogram, 'tT');
	$task_statuses[$task_id] = $status;
	}
	}

	if (!$task_statuses) {
	return;
	}

	$tasks = id(new ManiphestTaskQuery())
	->setViewer($acting_user)
	->withIDs(array_keys($task_statuses))
	->needProjectPHIDs(true)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->execute();

	foreach ($tasks as $task_id => $task) {
	$xactions = array();

	$edge_type = ManiphestTaskHasCommitEdgeType::EDGECONST;
	$edge_xaction = id(new ManiphestTransaction())
	->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
	->setMetadataValue('edge:type', $edge_type)
	->setNewValue(
	array(
	'+' => array(
	$commit->getPHID() => $commit->getPHID(),
	),
	));

	$status = $task_statuses[$task_id];
	if ($status) {
	if ($task->getStatus() != $status) {
	$xactions[] = id(new ManiphestTransaction())
	->setTransactionType(
	ManiphestTaskStatusTransaction::TRANSACTIONTYPE)
	->setMetadataValue('commitPHID', $commit->getPHID())
	->setNewValue($status);

	$edge_xaction->setMetadataValue('commitPHID', $commit->getPHID());
	}
	}

	$xactions[] = $edge_xaction;

	$content_source = $this->newContentSource();

	$editor = id(new ManiphestTransactionEditor())
	->setActor($actor)
	->setActingAsPHID($acting_as)
	->setContinueOnNoEffect(true)
	->setContinueOnMissingFields(true)
	->setUnmentionablePHIDMap(
	array($commit->getPHID() => $commit->getPHID()))
	->setContentSource($content_source);

	$editor->applyTransactions($task, $xactions);
	}
	}

	private function loadActingUser(PhabricatorUser $viewer, $user_phid) {
	if (!$user_phid) {
	return null;
	}

	$user_type = PhabricatorPeopleUserPHIDType::TYPECONST;
	if (phid_get_type($user_phid) != $user_type) {
	return null;
	}

	$user = id(new PhabricatorPeopleQuery())
	->setViewer($viewer)
	->withPHIDs(array($user_phid))
	->executeOne();
	if (!$user) {
	return null;
	}

	return $user;
	}


	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 24, 7:14 AM (13 h, 5 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 182605
Default Alt Text: (56 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions