No OneTemporary
Actions

Size

45 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/storage/DifferentialRevision.php b/src/applications/differential/storage/DifferentialRevision.php
	index 1e69e5661a..c856436fd8 100644
	--- a/src/applications/differential/storage/DifferentialRevision.php
	+++ b/src/applications/differential/storage/DifferentialRevision.php
	@@ -1,961 +1,961 @@
	<?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);
	+ ->setModernRevisionStatus(DifferentialRevisionStatus::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 setModernRevisionStatus($status) {
	$status_object = DifferentialRevisionStatus::newForStatus($status);

	if ($status_object->getKey() != $status) {
	throw new Exception(
	pht(
	'Trying to set revision to invalid status "%s".',
	$status));
	}

	$legacy_status = $status_object->getLegacyKey();

	return $this->setStatus($legacy_status);
	}

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

	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 isNeedsRevision() {
	return $this->getStatusObject()->isNeedsRevision();
	}

	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.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('status')
	->setType('map<string, wild>')
	->setDescription(pht('Information about revision status.')),
	);
	}

	public function getFieldValuesForConduit() {
	$status = $this->getStatusObject();
	$status_info = array(
	'value' => $status->getKey(),
	'name' => $status->getDisplayName(),
	'closed' => $status->isClosedStatus(),
	'color.ansi' => $status->getANSIColor(),
	);

	return array(
	'title' => $this->getTitle(),
	'authorPHID' => $this->getAuthorPHID(),
	'status' => $status_info,
	);
	}

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


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


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

	}
	diff --git a/src/applications/differential/xaction/DifferentialRevisionAbandonTransaction.php b/src/applications/differential/xaction/DifferentialRevisionAbandonTransaction.php
	index 2f221bd8c6..b7b0e7f123 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionAbandonTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionAbandonTransaction.php
	@@ -1,87 +1,88 @@
	<?php

	final class DifferentialRevisionAbandonTransaction
	extends DifferentialRevisionActionTransaction {

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

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

	protected function getRevisionActionDescription() {
	return pht('This revision will be abandoned and closed.');
	}

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

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

	protected function getRevisionActionOrder() {
	return 500;
	}

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

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

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

	public function getCommandSummary() {
	return pht('Abandon a revision.');
	}

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

	public function applyInternalEffects($object, $value) {
	- $object->setStatus(ArcanistDifferentialRevisionStatus::ABANDONED);
	+ $status_abandoned = DifferentialRevisionStatus::ABANDONED;
	+ $object->setModernRevisionStatus($status_abandoned);
	}

	protected function validateAction($object, PhabricatorUser $viewer) {
	if ($object->isClosed()) {
	throw new Exception(
	pht(
	'You can not abandon this revision because it has already been '.
	'closed. Only open revisions can be abandoned.'));
	}

	$config_key = 'differential.always-allow-abandon';
	if (!PhabricatorEnv::getEnvConfig($config_key)) {
	if (!$this->isViewerRevisionAuthor($object, $viewer)) {
	throw new Exception(
	pht(
	'You can not abandon this revision because you are not the '.
	'author. You can only abandon revisions you own. You can change '.
	'this behavior by adjusting the "%s" setting in Config.',
	$config_key));
	}
	}
	}

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

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

	}
	diff --git a/src/applications/differential/xaction/DifferentialRevisionCloseTransaction.php b/src/applications/differential/xaction/DifferentialRevisionCloseTransaction.php
	index 203b84a191..8d01f48eff 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionCloseTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionCloseTransaction.php
	@@ -1,136 +1,136 @@
	<?php

	final class DifferentialRevisionCloseTransaction
	extends DifferentialRevisionActionTransaction {

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

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

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

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

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

	protected function getRevisionActionOrder() {
	return 300;
	}

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

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

	public function applyInternalEffects($object, $value) {
	$was_accepted = $object->isAccepted();

	- $status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
	- $object->setStatus($status_closed);
	+ $status_published = DifferentialRevisionStatus::PUBLISHED;
	+ $object->setModernRevisionStatus($status_published);

	$object->setProperty(
	DifferentialRevision::PROPERTY_CLOSED_FROM_ACCEPTED,
	$was_accepted);
	}

	protected function validateAction($object, PhabricatorUser $viewer) {
	if ($this->getEditor()->getIsCloseByCommit()) {
	// If we're closing a revision because we discovered a commit, we don't
	// care what state it was in.
	return;
	}

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

	if (!$object->isAccepted()) {
	throw new Exception(
	pht(
	'You can not close this revision because it has not been accepted. '.
	'Revisions must be accepted before they can be closed.'));
	}

	$config_key = 'differential.always-allow-close';
	if (!PhabricatorEnv::getEnvConfig($config_key)) {
	if (!$this->isViewerRevisionAuthor($object, $viewer)) {
	throw new Exception(
	pht(
	'You can not close this revision because you are not the '.
	'author. You can only close revisions you own. You can change '.
	'this behavior by adjusting the "%s" setting in Config.',
	$config_key));
	}
	}
	}

	public function getTitle() {
	if (!$this->getMetadataValue('isCommitClose')) {
	return pht(
	'%s closed this revision.',
	$this->renderAuthor());
	}

	$commit_phid = $this->getMetadataValue('commitPHID');
	$committer_phid = $this->getMetadataValue('committerPHID');
	$author_phid = $this->getMetadataValue('authorPHID');

	if ($committer_phid) {
	$committer_name = $this->renderHandle($committer_phid);
	} else {
	$committer_name = $this->getMetadataValue('committerName');
	}

	if ($author_phid) {
	$author_name = $this->renderHandle($author_phid);
	} else {
	$author_name = $this->getMetadatavalue('authorName');
	}

	$same_phid =
	strlen($committer_phid) &&
	strlen($author_phid) &&
	($committer_phid == $author_phid);

	$same_name =
	!strlen($committer_phid) &&
	!strlen($author_phid) &&
	($committer_name == $author_name);

	if ($same_name \|\| $same_phid) {
	return pht(
	'Closed by commit %s (authored by %s).',
	$this->renderHandle($commit_phid),
	$author_name);
	} else {
	return pht(
	'Closed by commit %s (authored by %s, committed by %s).',
	$this->renderHandle($commit_phid),
	$author_name,
	$committer_name);
	}
	}

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

	}
	diff --git a/src/applications/differential/xaction/DifferentialRevisionPlanChangesTransaction.php b/src/applications/differential/xaction/DifferentialRevisionPlanChangesTransaction.php
	index 043071dc96..6e584ceb36 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionPlanChangesTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionPlanChangesTransaction.php
	@@ -1,94 +1,94 @@
	<?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) {
	return $object->isChangePlanned();
	}

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

	protected function validateAction($object, PhabricatorUser $viewer) {
	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/DifferentialRevisionReclaimTransaction.php b/src/applications/differential/xaction/DifferentialRevisionReclaimTransaction.php
	index 1f2f6a8d6c..4767924445 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionReclaimTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionReclaimTransaction.php
	@@ -1,82 +1,83 @@
	<?php

	final class DifferentialRevisionReclaimTransaction
	extends DifferentialRevisionActionTransaction {

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

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

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

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

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

	protected function getRevisionActionOrder() {
	return 600;
	}

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

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

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

	public function getCommandSummary() {
	return pht('Reclaim a revision.');
	}

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

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

	protected function validateAction($object, PhabricatorUser $viewer) {
	if (!$object->isAbandoned()) {
	throw new Exception(
	pht(
	'You can not reclaim this revision because it has not been '.
	'abandoned. Only abandoned revisions can be reclaimed.'));
	}

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

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

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

	}
	diff --git a/src/applications/differential/xaction/DifferentialRevisionReopenTransaction.php b/src/applications/differential/xaction/DifferentialRevisionReopenTransaction.php
	index 7ba20772c7..1d28433429 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionReopenTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionReopenTransaction.php
	@@ -1,73 +1,74 @@
	<?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);
	+ $status_review = DifferentialRevisionStatus::NEEDS_REVIEW;
	+ $object->setModernRevisionStatus($status_review);
	}

	protected function validateAction($object, PhabricatorUser $viewer) {
	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 2dae24b6fa..d102b0c0c2 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionRequestReviewTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionRequestReviewTransaction.php
	@@ -1,76 +1,76 @@
	<?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) {
	return $object->isNeedsReview();
	}

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

	protected function validateAction($object, PhabricatorUser $viewer) {
	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());
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jul 23, 11:52 PM (22 h, 40 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 182406
Default Alt Text: (45 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions