No OneTemporary
Actions

Size

62 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/resources/sql/autopatches/20170811.differential.02.modernstatus.sql b/resources/sql/autopatches/20170811.differential.02.modernstatus.sql
	new file mode 100644
	index 0000000000..a305206411
	--- /dev/null
	+++ b/resources/sql/autopatches/20170811.differential.02.modernstatus.sql
	@@ -0,0 +1,17 @@
	+UPDATE {$NAMESPACE}_differential.differential_revision
	+ SET status = "needs-review" WHERE status = "0";
	+
	+UPDATE {$NAMESPACE}_differential.differential_revision
	+ SET status = "needs-revision" WHERE status = "1";
	+
	+UPDATE {$NAMESPACE}_differential.differential_revision
	+ SET status = "accepted" WHERE status = "2";
	+
	+UPDATE {$NAMESPACE}_differential.differential_revision
	+ SET status = "published" WHERE status = "3";
	+
	+UPDATE {$NAMESPACE}_differential.differential_revision
	+ SET status = "abandoned" WHERE status = "4";
	+
	+UPDATE {$NAMESPACE}_differential.differential_revision
	+ SET status = "changes-planned" WHERE status = "5";
	diff --git a/src/applications/differential/constants/DifferentialLegacyQuery.php b/src/applications/differential/constants/DifferentialLegacyQuery.php
	index ca254918e0..26d2c4aee2 100644
	--- a/src/applications/differential/constants/DifferentialLegacyQuery.php
	+++ b/src/applications/differential/constants/DifferentialLegacyQuery.php
	@@ -1,90 +1,75 @@
	<?php

	final class DifferentialLegacyQuery
	extends Phobject {

	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_ACCEPTED = 'status-accepted';
	const STATUS_NEEDS_REVIEW = 'status-needs-review';
	const STATUS_NEEDS_REVISION = 'status-needs-revision';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_ABANDONED = 'status-abandoned';

	public static function getAllConstants() {
	return array_keys(self::getMap());
	}

	public static function getModernValues($status) {
	if ($status === self::STATUS_ANY) {
	return null;
	}

	$map = self::getMap();
	if (!isset($map[$status])) {
	throw new Exception(
	pht(
	'Unknown revision status filter constant "%s".',
	$status));
	}

	return $map[$status];
	}

	- public static function getLegacyValues(array $modern_values) {
	- $values = array();
	- foreach ($modern_values as $status_constant) {
	- $status_object = DifferentialRevisionStatus::newForStatus(
	- $status_constant);
	-
	- $legacy_key = $status_object->getLegacyKey();
	- if ($legacy_key !== null) {
	- $values[] = $legacy_key;
	- }
	- }
	-
	- return $values;
	- }
	-
	private static function getMap() {
	$all = array(
	DifferentialRevisionStatus::NEEDS_REVIEW,
	DifferentialRevisionStatus::NEEDS_REVISION,
	DifferentialRevisionStatus::CHANGES_PLANNED,
	DifferentialRevisionStatus::ACCEPTED,
	DifferentialRevisionStatus::PUBLISHED,
	DifferentialRevisionStatus::ABANDONED,
	);

	$open = array();
	$closed = array();

	foreach ($all as $status) {
	$status_object = DifferentialRevisionStatus::newForStatus($status);
	if ($status_object->isClosedStatus()) {
	$closed[] = $status_object->getKey();
	} else {
	$open[] = $status_object->getKey();
	}
	}

	return array(
	self::STATUS_ANY => $all,
	self::STATUS_OPEN => $open,
	self::STATUS_ACCEPTED => array(
	DifferentialRevisionStatus::ACCEPTED,
	),
	self::STATUS_NEEDS_REVIEW => array(
	DifferentialRevisionStatus::NEEDS_REVIEW,
	),
	self::STATUS_NEEDS_REVISION => array(
	DifferentialRevisionStatus::NEEDS_REVISION,
	),
	self::STATUS_CLOSED => $closed,
	self::STATUS_ABANDONED => array(
	DifferentialRevisionStatus::ABANDONED,
	),
	);
	}

	}
	diff --git a/src/applications/differential/query/DifferentialRevisionQuery.php b/src/applications/differential/query/DifferentialRevisionQuery.php
	index 39bba8112d..8e6e23776a 100644
	--- a/src/applications/differential/query/DifferentialRevisionQuery.php
	+++ b/src/applications/differential/query/DifferentialRevisionQuery.php
	@@ -1,1004 +1,1004 @@
	<?php

	/**
	* @task config Query Configuration
	* @task exec Query Execution
	* @task internal Internals
	*/
	final class DifferentialRevisionQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $pathIDs = array();

	private $authors = array();
	private $draftAuthors = array();
	private $ccs = array();
	private $reviewers = array();
	private $revIDs = array();
	private $commitHashes = array();
	private $commitPHIDs = array();
	private $phids = array();
	private $responsibles = array();
	private $branches = array();
	private $repositoryPHIDs;
	private $updatedEpochMin;
	private $updatedEpochMax;
	private $statuses;
	private $isOpen;

	const ORDER_MODIFIED = 'order-modified';
	const ORDER_CREATED = 'order-created';

	private $needActiveDiffs = false;
	private $needDiffIDs = false;
	private $needCommitPHIDs = false;
	private $needHashes = false;
	private $needReviewers = false;
	private $needReviewerAuthority;
	private $needDrafts;
	private $needFlags;

	private $buildingGlobalOrder;


	/* -( Query Configuration )------------------------------------------------ */


	/**
	* Filter results to revisions which affect a Diffusion path ID in a given
	* repository. You can call this multiple times to select revisions for
	* several paths.
	*
	* @param int Diffusion repository ID.
	* @param int Diffusion path ID.
	* @return this
	* @task config
	*/
	public function withPath($repository_id, $path_id) {
	$this->pathIDs[] = array(
	'repositoryID' => $repository_id,
	'pathID' => $path_id,
	);
	return $this;
	}

	/**
	* Filter results to revisions authored by one of the given PHIDs. Calling
	* this function will clear anything set by previous calls to
	* @{method:withAuthors}.
	*
	* @param array List of PHIDs of authors
	* @return this
	* @task config
	*/
	public function withAuthors(array $author_phids) {
	$this->authors = $author_phids;
	return $this;
	}

	/**
	* Filter results to revisions which CC one of the listed people. Calling this
	* function will clear anything set by previous calls to @{method:withCCs}.
	*
	* @param array List of PHIDs of subscribers.
	* @return this
	* @task config
	*/
	public function withCCs(array $cc_phids) {
	$this->ccs = $cc_phids;
	return $this;
	}

	/**
	* Filter results to revisions that have one of the provided PHIDs as
	* reviewers. Calling this function will clear anything set by previous calls
	* to @{method:withReviewers}.
	*
	* @param array List of PHIDs of reviewers
	* @return this
	* @task config
	*/
	public function withReviewers(array $reviewer_phids) {
	$this->reviewers = $reviewer_phids;
	return $this;
	}

	/**
	* Filter results to revisions that have one of the provided commit hashes.
	* Calling this function will clear anything set by previous calls to
	* @{method:withCommitHashes}.
	*
	* @param array List of pairs <Class
	* ArcanistDifferentialRevisionHash::HASH_$type constant,
	* hash>
	* @return this
	* @task config
	*/
	public function withCommitHashes(array $commit_hashes) {
	$this->commitHashes = $commit_hashes;
	return $this;
	}

	/**
	* Filter results to revisions that have one of the provided PHIDs as
	* commits. Calling this function will clear anything set by previous calls
	* to @{method:withCommitPHIDs}.
	*
	* @param array List of PHIDs of commits
	* @return this
	* @task config
	*/
	public function withCommitPHIDs(array $commit_phids) {
	$this->commitPHIDs = $commit_phids;
	return $this;
	}

	public function withStatuses(array $statuses) {
	$this->statuses = $statuses;
	return $this;
	}

	public function withIsOpen($is_open) {
	$this->isOpen = $is_open;
	return $this;
	}


	/**
	* Filter results to revisions on given branches.
	*
	* @param list List of branch names.
	* @return this
	* @task config
	*/
	public function withBranches(array $branches) {
	$this->branches = $branches;
	return $this;
	}


	/**
	* Filter results to only return revisions whose ids are in the given set.
	*
	* @param array List of revision ids
	* @return this
	* @task config
	*/
	public function withIDs(array $ids) {
	$this->revIDs = $ids;
	return $this;
	}


	/**
	* Filter results to only return revisions whose PHIDs are in the given set.
	*
	* @param array List of revision PHIDs
	* @return this
	* @task config
	*/
	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}


	/**
	* Given a set of users, filter results to return only revisions they are
	* responsible for (i.e., they are either authors or reviewers).
	*
	* @param array List of user PHIDs.
	* @return this
	* @task config
	*/
	public function withResponsibleUsers(array $responsible_phids) {
	$this->responsibles = $responsible_phids;
	return $this;
	}


	public function withRepositoryPHIDs(array $repository_phids) {
	$this->repositoryPHIDs = $repository_phids;
	return $this;
	}

	public function withUpdatedEpochBetween($min, $max) {
	$this->updatedEpochMin = $min;
	$this->updatedEpochMax = $max;
	return $this;
	}


	/**
	* Set whether or not the query should load the active diff for each
	* revision.
	*
	* @param bool True to load and attach diffs.
	* @return this
	* @task config
	*/
	public function needActiveDiffs($need_active_diffs) {
	$this->needActiveDiffs = $need_active_diffs;
	return $this;
	}


	/**
	* Set whether or not the query should load the associated commit PHIDs for
	* each revision.
	*
	* @param bool True to load and attach diffs.
	* @return this
	* @task config
	*/
	public function needCommitPHIDs($need_commit_phids) {
	$this->needCommitPHIDs = $need_commit_phids;
	return $this;
	}


	/**
	* Set whether or not the query should load associated diff IDs for each
	* revision.
	*
	* @param bool True to load and attach diff IDs.
	* @return this
	* @task config
	*/
	public function needDiffIDs($need_diff_ids) {
	$this->needDiffIDs = $need_diff_ids;
	return $this;
	}


	/**
	* Set whether or not the query should load associated commit hashes for each
	* revision.
	*
	* @param bool True to load and attach commit hashes.
	* @return this
	* @task config
	*/
	public function needHashes($need_hashes) {
	$this->needHashes = $need_hashes;
	return $this;
	}


	/**
	* Set whether or not the query should load associated reviewers.
	*
	* @param bool True to load and attach reviewers.
	* @return this
	* @task config
	*/
	public function needReviewers($need_reviewers) {
	$this->needReviewers = $need_reviewers;
	return $this;
	}


	/**
	* Request information about the viewer's authority to act on behalf of each
	* reviewer. In particular, they have authority to act on behalf of projects
	* they are a member of.
	*
	* @param bool True to load and attach authority.
	* @return this
	* @task config
	*/
	public function needReviewerAuthority($need_reviewer_authority) {
	$this->needReviewerAuthority = $need_reviewer_authority;
	return $this;
	}

	public function needFlags($need_flags) {
	$this->needFlags = $need_flags;
	return $this;
	}

	public function needDrafts($need_drafts) {
	$this->needDrafts = $need_drafts;
	return $this;
	}


	/* -( Query Execution )---------------------------------------------------- */


	public function newResultObject() {
	return new DifferentialRevision();
	}


	/**
	* Execute the query as configured, returning matching
	* @{class:DifferentialRevision} objects.
	*
	* @return list List of matching DifferentialRevision objects.
	* @task exec
	*/
	protected function loadPage() {
	$data = $this->loadData();

	$table = $this->newResultObject();
	return $table->loadAllFromArray($data);
	}

	protected function willFilterPage(array $revisions) {
	$viewer = $this->getViewer();

	$repository_phids = mpull($revisions, 'getRepositoryPHID');
	$repository_phids = array_filter($repository_phids);

	$repositories = array();
	if ($repository_phids) {
	$repositories = id(new PhabricatorRepositoryQuery())
	->setViewer($this->getViewer())
	->withPHIDs($repository_phids)
	->execute();
	$repositories = mpull($repositories, null, 'getPHID');
	}

	// If a revision is associated with a repository:
	//
	// - the viewer must be able to see the repository; or
	// - the viewer must have an automatic view capability.
	//
	// In the latter case, we'll load the revision but not load the repository.

	$can_view = PhabricatorPolicyCapability::CAN_VIEW;
	foreach ($revisions as $key => $revision) {
	$repo_phid = $revision->getRepositoryPHID();
	if (!$repo_phid) {
	// The revision has no associated repository. Attach `null` and move on.
	$revision->attachRepository(null);
	continue;
	}

	$repository = idx($repositories, $repo_phid);
	if ($repository) {
	// The revision has an associated repository, and the viewer can see
	// it. Attach it and move on.
	$revision->attachRepository($repository);
	continue;
	}

	if ($revision->hasAutomaticCapability($can_view, $viewer)) {
	// The revision has an associated repository which the viewer can not
	// see, but the viewer has an automatic capability on this revision.
	// Load the revision without attaching a repository.
	$revision->attachRepository(null);
	continue;
	}

	if ($this->getViewer()->isOmnipotent()) {
	// The viewer is omnipotent. Allow the revision to load even without
	// a repository.
	$revision->attachRepository(null);
	continue;
	}

	// The revision has an associated repository, and the viewer can't see
	// it, and the viewer has no special capabilities. Filter out this
	// revision.
	$this->didRejectResult($revision);
	unset($revisions[$key]);
	}

	if (!$revisions) {
	return array();
	}

	$table = new DifferentialRevision();
	$conn_r = $table->establishConnection('r');

	if ($this->needCommitPHIDs) {
	$this->loadCommitPHIDs($conn_r, $revisions);
	}

	$need_active = $this->needActiveDiffs;
	$need_ids = $need_active \|\| $this->needDiffIDs;

	if ($need_ids) {
	$this->loadDiffIDs($conn_r, $revisions);
	}

	if ($need_active) {
	$this->loadActiveDiffs($conn_r, $revisions);
	}

	if ($this->needHashes) {
	$this->loadHashes($conn_r, $revisions);
	}

	if ($this->needReviewers \|\| $this->needReviewerAuthority) {
	$this->loadReviewers($conn_r, $revisions);
	}

	return $revisions;
	}

	protected function didFilterPage(array $revisions) {
	$viewer = $this->getViewer();

	if ($this->needFlags) {
	$flags = id(new PhabricatorFlagQuery())
	->setViewer($viewer)
	->withOwnerPHIDs(array($viewer->getPHID()))
	->withObjectPHIDs(mpull($revisions, 'getPHID'))
	->execute();
	$flags = mpull($flags, null, 'getObjectPHID');
	foreach ($revisions as $revision) {
	$revision->attachFlag(
	$viewer,
	idx($flags, $revision->getPHID()));
	}
	}

	if ($this->needDrafts) {
	PhabricatorDraftEngine::attachDrafts(
	$viewer,
	$revisions);
	}

	return $revisions;
	}

	private function loadData() {
	$table = $this->newResultObject();
	$conn_r = $table->establishConnection('r');

	$selects = array();

	// NOTE: If the query includes "responsiblePHIDs", we execute it as a
	// UNION of revisions they own and revisions they're reviewing. This has
	// much better performance than doing it with JOIN/WHERE.
	if ($this->responsibles) {
	$basic_authors = $this->authors;
	$basic_reviewers = $this->reviewers;

	try {
	// Build the query where the responsible users are authors.
	$this->authors = array_merge($basic_authors, $this->responsibles);

	$this->reviewers = $basic_reviewers;
	$selects[] = $this->buildSelectStatement($conn_r);

	// Build the query where the responsible users are reviewers, or
	// projects they are members of are reviewers.
	$this->authors = $basic_authors;
	$this->reviewers = array_merge($basic_reviewers, $this->responsibles);
	$selects[] = $this->buildSelectStatement($conn_r);

	// Put everything back like it was.
	$this->authors = $basic_authors;
	$this->reviewers = $basic_reviewers;
	} catch (Exception $ex) {
	$this->authors = $basic_authors;
	$this->reviewers = $basic_reviewers;
	throw $ex;
	}
	} else {
	$selects[] = $this->buildSelectStatement($conn_r);
	}

	if (count($selects) > 1) {
	$this->buildingGlobalOrder = true;
	$query = qsprintf(
	$conn_r,
	'%Q %Q %Q',
	implode(' UNION DISTINCT ', $selects),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));
	} else {
	$query = head($selects);
	}

	return queryfx_all($conn_r, '%Q', $query);
	}

	private function buildSelectStatement(AphrontDatabaseConnection $conn_r) {
	$table = new DifferentialRevision();

	$select = $this->buildSelectClause($conn_r);

	$from = qsprintf(
	$conn_r,
	'FROM %T r',
	$table->getTableName());

	$joins = $this->buildJoinsClause($conn_r);
	$where = $this->buildWhereClause($conn_r);
	$group_by = $this->buildGroupClause($conn_r);
	$having = $this->buildHavingClause($conn_r);

	$this->buildingGlobalOrder = false;
	$order_by = $this->buildOrderClause($conn_r);

	$limit = $this->buildLimitClause($conn_r);

	return qsprintf(
	$conn_r,
	'(%Q %Q %Q %Q %Q %Q %Q %Q)',
	$select,
	$from,
	$joins,
	$where,
	$group_by,
	$having,
	$order_by,
	$limit);
	}


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


	/**
	* @task internal
	*/
	private function buildJoinsClause($conn_r) {
	$joins = array();
	if ($this->pathIDs) {
	$path_table = new DifferentialAffectedPath();
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T p ON p.revisionID = r.id',
	$path_table->getTableName());
	}

	if ($this->commitHashes) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T hash_rel ON hash_rel.revisionID = r.id',
	ArcanistDifferentialRevisionHash::TABLE_NAME);
	}

	if ($this->ccs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T e_ccs ON e_ccs.src = r.phid '.
	'AND e_ccs.type = %s '.
	'AND e_ccs.dst in (%Ls)',
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	PhabricatorObjectHasSubscriberEdgeType::EDGECONST,
	$this->ccs);
	}

	if ($this->reviewers) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T reviewer ON reviewer.revisionPHID = r.phid
	AND reviewer.reviewerStatus != %s
	AND reviewer.reviewerPHID in (%Ls)',
	id(new DifferentialReviewer())->getTableName(),
	DifferentialReviewerStatus::STATUS_RESIGNED,
	$this->reviewers);
	}

	if ($this->draftAuthors) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T has_draft ON has_draft.srcPHID = r.phid
	AND has_draft.type = %s
	AND has_draft.dstPHID IN (%Ls)',
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	PhabricatorObjectHasDraftEdgeType::EDGECONST,
	$this->draftAuthors);
	}

	if ($this->commitPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T commits ON commits.revisionID = r.id',
	DifferentialRevision::TABLE_COMMIT);
	}

	$joins[] = $this->buildJoinClauseParts($conn_r);

	return $this->formatJoinClause($joins);
	}


	/**
	* @task internal
	*/
	protected function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if ($this->pathIDs) {
	$path_clauses = array();
	$repo_info = igroup($this->pathIDs, 'repositoryID');
	foreach ($repo_info as $repository_id => $paths) {
	$path_clauses[] = qsprintf(
	$conn_r,
	'(p.repositoryID = %d AND p.pathID IN (%Ld))',
	$repository_id,
	ipull($paths, 'pathID'));
	}
	$path_clauses = '('.implode(' OR ', $path_clauses).')';
	$where[] = $path_clauses;
	}

	if ($this->authors) {
	$where[] = qsprintf(
	$conn_r,
	'r.authorPHID IN (%Ls)',
	$this->authors);
	}

	if ($this->revIDs) {
	$where[] = qsprintf(
	$conn_r,
	'r.id IN (%Ld)',
	$this->revIDs);
	}

	if ($this->repositoryPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'r.repositoryPHID IN (%Ls)',
	$this->repositoryPHIDs);
	}

	if ($this->commitHashes) {
	$hash_clauses = array();
	foreach ($this->commitHashes as $info) {
	list($type, $hash) = $info;
	$hash_clauses[] = qsprintf(
	$conn_r,
	'(hash_rel.type = %s AND hash_rel.hash = %s)',
	$type,
	$hash);
	}
	$hash_clauses = '('.implode(' OR ', $hash_clauses).')';
	$where[] = $hash_clauses;
	}

	if ($this->commitPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'commits.commitPHID IN (%Ls)',
	$this->commitPHIDs);
	}

	if ($this->phids) {
	$where[] = qsprintf(
	$conn_r,
	'r.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->branches) {
	$where[] = qsprintf(
	$conn_r,
	'r.branchName in (%Ls)',
	$this->branches);
	}

	if ($this->updatedEpochMin !== null) {
	$where[] = qsprintf(
	$conn_r,
	'r.dateModified >= %d',
	$this->updatedEpochMin);
	}

	if ($this->updatedEpochMax !== null) {
	$where[] = qsprintf(
	$conn_r,
	'r.dateModified <= %d',
	$this->updatedEpochMax);
	}

	if ($this->statuses !== null) {
	$where[] = qsprintf(
	$conn_r,
	'r.status in (%Ls)',
	- DifferentialLegacyQuery::getLegacyValues($this->statuses));
	+ $this->statuses);
	}

	if ($this->isOpen !== null) {
	if ($this->isOpen) {
	$statuses = DifferentialLegacyQuery::getModernValues(
	DifferentialLegacyQuery::STATUS_OPEN);
	} else {
	$statuses = DifferentialLegacyQuery::getModernValues(
	DifferentialLegacyQuery::STATUS_CLOSED);
	}
	$where[] = qsprintf(
	$conn_r,
	'r.status in (%Ls)',
	- DifferentialLegacyQuery::getLegacyValues($statuses));
	+ $statuses);
	}

	$where[] = $this->buildWhereClauseParts($conn_r);
	return $this->formatWhereClause($where);
	}


	/**
	* @task internal
	*/
	protected function shouldGroupQueryResultRows() {

	$join_triggers = array_merge(
	$this->pathIDs,
	$this->ccs,
	$this->reviewers);

	if (count($join_triggers) > 1) {
	return true;
	}

	return parent::shouldGroupQueryResultRows();
	}

	public function getBuiltinOrders() {
	$orders = parent::getBuiltinOrders() + array(
	'updated' => array(
	'vector' => array('updated', 'id'),
	'name' => pht('Date Updated (Latest First)'),
	'aliases' => array(self::ORDER_MODIFIED),
	),
	'outdated' => array(
	'vector' => array('-updated', '-id'),
	'name' => pht('Date Updated (Oldest First)'),
	),
	);

	// Alias the "newest" builtin to the historical key for it.
	$orders['newest']['aliases'][] = self::ORDER_CREATED;

	return $orders;
	}

	protected function getDefaultOrderVector() {
	return array('updated', 'id');
	}

	public function getOrderableColumns() {
	$primary = ($this->buildingGlobalOrder ? null : 'r');

	return array(
	'id' => array(
	'table' => $primary,
	'column' => 'id',
	'type' => 'int',
	'unique' => true,
	),
	'updated' => array(
	'table' => $primary,
	'column' => 'dateModified',
	'type' => 'int',
	),
	);
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$revision = $this->loadCursorObject($cursor);
	return array(
	'id' => $revision->getID(),
	'updated' => $revision->getDateModified(),
	);
	}

	private function loadCommitPHIDs($conn_r, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');
	$commit_phids = queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE revisionID IN (%Ld)',
	DifferentialRevision::TABLE_COMMIT,
	mpull($revisions, 'getID'));
	$commit_phids = igroup($commit_phids, 'revisionID');
	foreach ($revisions as $revision) {
	$phids = idx($commit_phids, $revision->getID(), array());
	$phids = ipull($phids, 'commitPHID');
	$revision->attachCommitPHIDs($phids);
	}
	}

	private function loadDiffIDs($conn_r, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$diff_table = new DifferentialDiff();

	$diff_ids = queryfx_all(
	$conn_r,
	'SELECT revisionID, id FROM %T WHERE revisionID IN (%Ld)
	ORDER BY id DESC',
	$diff_table->getTableName(),
	mpull($revisions, 'getID'));
	$diff_ids = igroup($diff_ids, 'revisionID');

	foreach ($revisions as $revision) {
	$ids = idx($diff_ids, $revision->getID(), array());
	$ids = ipull($ids, 'id');
	$revision->attachDiffIDs($ids);
	}
	}

	private function loadActiveDiffs($conn_r, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$diff_table = new DifferentialDiff();

	$load_ids = array();
	foreach ($revisions as $revision) {
	$diffs = $revision->getDiffIDs();
	if ($diffs) {
	$load_ids[] = max($diffs);
	}
	}

	$active_diffs = array();
	if ($load_ids) {
	$active_diffs = $diff_table->loadAllWhere(
	'id IN (%Ld)',
	$load_ids);
	}

	$active_diffs = mpull($active_diffs, null, 'getRevisionID');
	foreach ($revisions as $revision) {
	$revision->attachActiveDiff(idx($active_diffs, $revision->getID()));
	}
	}

	private function loadHashes(
	AphrontDatabaseConnection $conn_r,
	array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE revisionID IN (%Ld)',
	'differential_revisionhash',
	mpull($revisions, 'getID'));

	$data = igroup($data, 'revisionID');
	foreach ($revisions as $revision) {
	$hashes = idx($data, $revision->getID(), array());
	$list = array();
	foreach ($hashes as $hash) {
	$list[] = array($hash['type'], $hash['hash']);
	}
	$revision->attachHashes($list);
	}
	}

	private function loadReviewers(
	AphrontDatabaseConnection $conn,
	array $revisions) {

	assert_instances_of($revisions, 'DifferentialRevision');

	$reviewer_table = new DifferentialReviewer();
	$reviewer_rows = queryfx_all(
	$conn,
	'SELECT * FROM %T WHERE revisionPHID IN (%Ls)
	ORDER BY id ASC',
	$reviewer_table->getTableName(),
	mpull($revisions, 'getPHID'));
	$reviewer_list = $reviewer_table->loadAllFromArray($reviewer_rows);
	$reviewer_map = mgroup($reviewer_list, 'getRevisionPHID');

	foreach ($reviewer_map as $key => $reviewers) {
	$reviewer_map[$key] = mpull($reviewers, null, 'getReviewerPHID');
	}

	$viewer = $this->getViewer();
	$viewer_phid = $viewer->getPHID();

	$allow_key = 'differential.allow-self-accept';
	$allow_self = PhabricatorEnv::getEnvConfig($allow_key);

	// Figure out which of these reviewers the viewer has authority to act as.
	if ($this->needReviewerAuthority && $viewer_phid) {
	$authority = $this->loadReviewerAuthority(
	$revisions,
	$reviewer_map,
	$allow_self);
	}

	foreach ($revisions as $revision) {
	$reviewers = idx($reviewer_map, $revision->getPHID(), array());
	foreach ($reviewers as $reviewer_phid => $reviewer) {
	if ($this->needReviewerAuthority) {
	if (!$viewer_phid) {
	// Logged-out users never have authority.
	$has_authority = false;
	} else if ((!$allow_self) &&
	($revision->getAuthorPHID() == $viewer_phid)) {
	// The author can never have authority unless we allow self-accept.
	$has_authority = false;
	} else {
	// Otherwise, look up whether the viewer has authority.
	$has_authority = isset($authority[$reviewer_phid]);
	}

	$reviewer->attachAuthority($viewer, $has_authority);
	}

	$reviewers[$reviewer_phid] = $reviewer;
	}

	$revision->attachReviewers($reviewers);
	}
	}

	private function loadReviewerAuthority(
	array $revisions,
	array $reviewers,
	$allow_self) {

	$revision_map = mpull($revisions, null, 'getPHID');
	$viewer_phid = $this->getViewer()->getPHID();

	// Find all the project/package reviewers which the user may have authority
	// over.
	$project_phids = array();
	$package_phids = array();
	$project_type = PhabricatorProjectProjectPHIDType::TYPECONST;
	$package_type = PhabricatorOwnersPackagePHIDType::TYPECONST;

	foreach ($reviewers as $revision_phid => $reviewer_list) {
	if (!$allow_self) {
	if ($revision_map[$revision_phid]->getAuthorPHID() == $viewer_phid) {
	// If self-review isn't permitted, the user will never have
	// authority over projects on revisions they authored because you
	// can't accept your own revisions, so we don't need to load any
	// data about these reviewers.
	continue;
	}
	}

	foreach ($reviewer_list as $reviewer_phid => $reviewer) {
	$phid_type = phid_get_type($reviewer_phid);
	if ($phid_type == $project_type) {
	$project_phids[] = $reviewer_phid;
	}
	if ($phid_type == $package_type) {
	$package_phids[] = $reviewer_phid;
	}
	}
	}

	// The viewer has authority over themselves.
	$user_authority = array_fuse(array($viewer_phid));

	// And over any projects they are a member of.
	$project_authority = array();
	if ($project_phids) {
	$project_authority = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($project_phids)
	->withMemberPHIDs(array($viewer_phid))
	->execute();
	$project_authority = mpull($project_authority, 'getPHID');
	$project_authority = array_fuse($project_authority);
	}

	// And over any packages they own.
	$package_authority = array();
	if ($package_phids) {
	$package_authority = id(new PhabricatorOwnersPackageQuery())
	->setViewer($this->getViewer())
	->withPHIDs($package_phids)
	->withAuthorityPHIDs(array($viewer_phid))
	->execute();
	$package_authority = mpull($package_authority, 'getPHID');
	$package_authority = array_fuse($package_authority);
	}

	return $user_authority + $project_authority + $package_authority;
	}

	public function getQueryApplicationClass() {
	return 'PhabricatorDifferentialApplication';
	}

	protected function getPrimaryTableAlias() {
	return 'r';
	}

	}
	diff --git a/src/applications/differential/storage/DifferentialRevision.php b/src/applications/differential/storage/DifferentialRevision.php
	index 69334bc01d..eaf856fd80 100644
	--- a/src/applications/differential/storage/DifferentialRevision.php
	+++ b/src/applications/differential/storage/DifferentialRevision.php
	@@ -1,965 +1,954 @@
	<?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())
	->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);
	+ return $this->setStatus($status);
	}

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

	public function getLegacyRevisionStatus() {
	- return $this->getStatus();
	+ return $this->getStatusObject()->getLegacyKey();
	}

	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);
	+ return DifferentialRevisionStatus::newForStatus($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/DifferentialRevisionStatusTransaction.php b/src/applications/differential/xaction/DifferentialRevisionStatusTransaction.php
	index 0c38bd6d84..75e85bc037 100644
	--- a/src/applications/differential/xaction/DifferentialRevisionStatusTransaction.php
	+++ b/src/applications/differential/xaction/DifferentialRevisionStatusTransaction.php
	@@ -1,74 +1,73 @@
	<?php

	final class DifferentialRevisionStatusTransaction
	extends DifferentialRevisionTransactionType {

	const TRANSACTIONTYPE = 'differential.revision.status';

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

	public function applyInternalEffects($object, $value) {
	$object->setLegacyRevisionStatus($value);
	}

	public function getTitle() {
	- $new = $this->getNewValue();
	- $status = DifferentialRevisionStatus::newForLegacyStatus($new);
	+ $status = $this->newStatusObject();

	if ($status->isAccepted()) {
	return pht('This revision is now accepted and ready to land.');
	}

	if ($status->isNeedsRevision()) {
	return pht('This revision now requires changes to proceed.');
	}

	if ($status->isNeedsReview()) {
	return pht('This revision now requires review to proceed.');
	}

	return null;
	}

	public function getTitleForFeed() {
	$status = $this->newStatusObject();

	if ($status->isAccepted()) {
	return pht(
	'%s is now accepted and ready to land.',
	$this->renderObject());
	}

	if ($status->isNeedsRevision()) {
	return pht(
	'%s now requires changes to proceed.',
	$this->renderObject());
	}

	if ($status->isNeedsReview()) {
	return pht(
	'%s now requires review to proceed.',
	$this->renderObject());
	}

	return null;
	}

	public function getIcon() {
	$status = $this->newStatusObject();
	return $status->getTimelineIcon();
	}

	public function getColor() {
	$status = $this->newStatusObject();
	return $status->getTimelineColor();
	}

	private function newStatusObject() {
	$new = $this->getNewValue();
	return DifferentialRevisionStatus::newForLegacyStatus($new);
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jul 23, 11:53 PM (9 h, 59 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 182408
Default Alt Text: (62 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions