No OneTemporary
Actions

Size

61 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/application/PhabricatorApplicationDifferential.php b/src/applications/differential/application/PhabricatorApplicationDifferential.php
	index da1b6c371c..ed49cb184b 100644
	--- a/src/applications/differential/application/PhabricatorApplicationDifferential.php
	+++ b/src/applications/differential/application/PhabricatorApplicationDifferential.php
	@@ -1,99 +1,99 @@
	<?php

	final class PhabricatorApplicationDifferential extends PhabricatorApplication {

	public function getBaseURI() {
	return '/differential/';
	}

	public function getShortDescription() {
	return 'Review Code';
	}

	public function getIconName() {
	return 'differential';
	}

	public function getHelpURI() {
	return PhabricatorEnv::getDoclink('article/Differential_User_Guide.html');
	}

	public function getFactObjectsForAnalysis() {
	return array(
	new DifferentialRevision(),
	);
	}

	public function getRoutes() {
	return array(
	'/D(?P<id>[1-9]\d*)' => 'DifferentialRevisionViewController',
	'/differential/' => array(
	'' => 'DifferentialRevisionListController',
	'filter/(?P<filter>\w+)/(?:(?P<username>[\w\.-_]+)/)?' =>
	'DifferentialRevisionListController',
	'stats/(?P<filter>\w+)/' => 'DifferentialRevisionStatsController',
	'diff/' => array(
	'(?P<id>[1-9]\d*)/' => 'DifferentialDiffViewController',
	'create/' => 'DifferentialDiffCreateController',
	),
	'changeset/' => 'DifferentialChangesetViewController',
	'revision/edit/(?:(?P<id>[1-9]\d*)/)?'
	=> 'DifferentialRevisionEditController',
	'comment/' => array(
	'preview/(?P<id>[1-9]\d*)/' => 'DifferentialCommentPreviewController',
	'save/' => 'DifferentialCommentSaveController',
	'inline/' => array(
	'preview/(?P<id>[1-9]\d*)/'
	=> 'DifferentialInlineCommentPreviewController',
	'edit/(?P<id>[1-9]\d*)/'
	=> 'DifferentialInlineCommentEditController',
	),
	),
	'subscribe/(?P<action>add\|rem)/(?P<id>[1-9]\d*)/'
	=> 'DifferentialSubscribeController',
	),
	);
	}

	public function getApplicationGroup() {
	return self::GROUP_CORE;
	}

	public function getApplicationOrder() {
	return 0.100;
	}

	public function loadStatus(PhabricatorUser $user) {
	$revisions = id(new DifferentialRevisionQuery())
	->withResponsibleUsers(array($user->getPHID()))
	->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	->execute();

	list($active, $waiting) = DifferentialRevisionQuery::splitResponsible(
	$revisions,
	- $user->getPHID());
	+ array($user->getPHID()));

	$status = array();

	$active = count($active);
	$type = $active
	? PhabricatorApplicationStatusView::TYPE_NEEDS_ATTENTION
	: PhabricatorApplicationStatusView::TYPE_EMPTY;
	$status[] = id(new PhabricatorApplicationStatusView())
	->setType($type)
	->setText(pht('%d Review(s) Need Attention', $active))
	->setCount($active);

	$waiting = count($waiting);
	$type = $waiting
	? PhabricatorApplicationStatusView::TYPE_INFO
	: PhabricatorApplicationStatusView::TYPE_EMPTY;
	$status[] = id(new PhabricatorApplicationStatusView())
	->setType($type)
	->setText(pht('%d Review(s) Waiting on Others', $waiting));

	return $status;
	}

	}

	diff --git a/src/applications/differential/controller/DifferentialRevisionListController.php b/src/applications/differential/controller/DifferentialRevisionListController.php
	index 978351407a..bdc9c54ab9 100644
	--- a/src/applications/differential/controller/DifferentialRevisionListController.php
	+++ b/src/applications/differential/controller/DifferentialRevisionListController.php
	@@ -1,474 +1,470 @@
	<?php

	final class DifferentialRevisionListController extends DifferentialController {

	private $filter;
	private $username;

	public function shouldRequireLogin() {
	return !$this->allowsAnonymousAccess();
	}

	public function willProcessRequest(array $data) {
	$this->filter = idx($data, 'filter');
	$this->username = idx($data, 'username');
	}

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

	$params = array_filter(
	array(
	'status' => $request->getStr('status'),
	'order' => $request->getStr('order'),
	));

	$default_filter = ($viewer_is_anonymous ? 'all' : 'active');
	$filters = $this->getFilters();
	$this->filter = $this->selectFilter(
	$filters,
	$this->filter,
	$default_filter);

	// Redirect from search to canonical URL.
	- $phid_arr = $request->getArr('view_user');
	+ $phid_arr = $request->getArr('view_users');
	if ($phid_arr) {
	- $view_user = id(new PhabricatorUser())
	- ->loadOneWhere('phid = %s', head($phid_arr));
	+ $view_users = id(new PhabricatorUser())
	+ ->loadAllWhere('phid IN (%Ls)', $phid_arr);

	- $base_uri = '/differential/filter/'.$this->filter.'/';
	- if ($view_user) {
	- // This is a user, so generate a pretty URI.
	- $uri = $base_uri.phutil_escape_uri($view_user->getUserName()).'/';
	- } else {
	- // We're assuming this is a mailing list, generate an ugly URI.
	- $uri = $base_uri;
	- $params['phid'] = head($phid_arr);
	- }
	+ if (count($view_users) == 1) {
	+ // This is a single user, so generate a pretty URI.
	+ $uri = new PhutilURI(
	+ '/differential/filter/'.$this->filter.'/'.
	+ phutil_escape_uri(reset($view_users)->getUserName()).'/');
	+ $uri->setQueryParams($params);

	- $uri = new PhutilURI($uri);
	- $uri->setQueryParams($params);
	+ return id(new AphrontRedirectResponse())->setURI($uri);
	+ }

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

	$uri = new PhutilURI('/differential/filter/'.$this->filter.'/');
	$uri->setQueryParams($params);

	$username = '';
	if ($this->username) {
	$view_user = id(new PhabricatorUser())
	->loadOneWhere('userName = %s', $this->username);
	if (!$view_user) {
	return new Aphront404Response();
	}
	$username = phutil_escape_uri($this->username).'/';
	$uri->setPath('/differential/filter/'.$this->filter.'/'.$username);
	- $params['phid'] = $view_user->getPHID();
	+ $params['view_users'] = array($view_user->getPHID());
	} else {
	- $phid = $request->getStr('phid');
	- if (strlen($phid)) {
	- $params['phid'] = $phid;
	+ $phids = $request->getArr('view_users');
	+ if ($phids) {
	+ $params['view_users'] = $phids;
	+ $uri->setQueryParams($params);
	}
	}

	// Fill in the defaults we'll actually use for calculations if any
	// parameters are missing.
	$params += array(
	- 'phid' => $user->getPHID(),
	+ 'view_users' => array($user->getPHID()),
	'status' => 'all',
	'order' => 'modified',
	);

	$side_nav = new AphrontSideNavFilterView();
	$side_nav->setBaseURI(id(clone $uri)->setPath('/differential/filter/'));
	foreach ($filters as $filter) {
	list($filter_name, $display_name) = $filter;
	if ($filter_name) {
	$side_nav->addFilter($filter_name.'/'.$username, $display_name);
	} else {
	$side_nav->addLabel($display_name);
	}
	}
	$side_nav->selectFilter($this->filter.'/'.$username, null);

	$panels = array();
	$handles = array();
	$controls = $this->getFilterControls($this->filter);
	- if ($this->getFilterRequiresUser($this->filter) && !$params['phid']) {
	+ if ($this->getFilterRequiresUser($this->filter) && !$params['view_users']) {
	// In the anonymous case, we still want to let you see some user's
	// list, but we don't have a default PHID to provide (normally, we use
	// the viewing user's). Show a warning instead.
	$warning = new AphrontErrorView();
	$warning->setSeverity(AphrontErrorView::SEVERITY_WARNING);
	$warning->setTitle('User Required');
	$warning->appendChild(
	'This filter requires that a user be specified above.');
	$panels[] = $warning;
	} else {
	- $query = $this->buildQuery($this->filter, $params['phid']);
	+ $query = $this->buildQuery($this->filter, $params['view_users']);

	$pager = null;
	if ($this->getFilterAllowsPaging($this->filter)) {
	$pager = new AphrontPagerView();
	$pager->setOffset($request->getInt('page'));
	$pager->setPageSize(1000);
	$pager->setURI($uri, 'page');

	$query->setOffset($pager->getOffset());
	$query->setLimit($pager->getPageSize() + 1);
	}

	foreach ($controls as $control) {
	$this->applyControlToQuery($control, $query, $params);
	}

	$revisions = $query->execute();

	if ($pager) {
	$revisions = $pager->sliceResults($revisions);
	}

	- $views = $this->buildViews($this->filter, $params['phid'], $revisions);
	+ $views = $this->buildViews(
	+ $this->filter,
	+ $params['view_users'],
	+ $revisions);

	$view_objects = array();
	foreach ($views as $view) {
	if (empty($view['special'])) {
	$view_objects[] = $view['view'];
	}
	}
	- $phids = array_mergev(mpull($view_objects, 'getRequiredHandlePHIDs'));
	- $phids[] = $params['phid'];
	+ $phids = mpull($view_objects, 'getRequiredHandlePHIDs');
	+ $phids[] = $params['view_users'];
	+ $phids = array_mergev($phids);
	$handles = $this->loadViewerHandles($phids);

	foreach ($views as $view) {
	if (empty($view['special'])) {
	$view['view']->setHandles($handles);
	}
	$panel = new AphrontPanelView();
	$panel->setHeader($view['title']);
	$panel->appendChild($view['view']);
	if ($pager) {
	$panel->appendChild($pager);
	}
	$panels[] = $panel;
	}
	}

	$filter_form = id(new AphrontFormView())
	->setMethod('GET')
	->setAction('/differential/filter/'.$this->filter.'/')
	->setUser($user);
	foreach ($controls as $control) {
	$control_view = $this->renderControl($control, $handles, $uri, $params);
	$filter_form->appendChild($control_view);
	}
	$filter_form
	->addHiddenInput('status', $params['status'])
	->addHiddenInput('order', $params['order'])
	->appendChild(
	id(new AphrontFormSubmitControl())
	->setValue('Filter Revisions'));

	$filter_view = new AphrontListFilterView();
	$filter_view->appendChild($filter_form);

	$side_nav->appendChild($filter_view);

	foreach ($panels as $panel) {
	$side_nav->appendChild($panel);
	}

	$crumbs = $this->buildApplicationCrumbs();
	$name = $side_nav
	->getMenu()
	->getItem($side_nav->getSelectedFilter())
	->getName();
	$crumbs->addCrumb(
	id(new PhabricatorCrumbView())
	->setName($name)
	->setHref($request->getRequestURI()));
	$side_nav->setCrumbs($crumbs);

	return $this->buildApplicationPage(
	$side_nav,
	array(
	'title' => 'Differential Home',
	));
	}

	private function getFilters() {
	return array(
	array(null, 'User Revisions'),
	array('active', 'Active'),
	array('revisions', 'Revisions'),
	array('reviews', 'Reviews'),
	array('subscribed', 'Subscribed'),
	array('drafts', 'Draft Reviews'),
	array(null, 'All Revisions'),
	array('all', 'All'),
	);
	}

	private function selectFilter(
	array $filters,
	$requested_filter,
	$default_filter) {

	// If the user requested a filter, make sure it actually exists.
	if ($requested_filter) {
	foreach ($filters as $filter) {
	if ($filter[0] === $requested_filter) {
	return $requested_filter;
	}
	}
	}

	// If not, return the default filter.
	return $default_filter;
	}

	private function getFilterRequiresUser($filter) {
	static $requires = array(
	'active' => true,
	'revisions' => true,
	'reviews' => true,
	'subscribed' => true,
	'drafts' => true,
	'all' => false,
	);
	if (!isset($requires[$filter])) {
	throw new Exception("Unknown filter '{$filter}'!");
	}
	return $requires[$filter];
	}

	private function getFilterAllowsPaging($filter) {
	static $allows = array(
	'active' => false,
	'revisions' => true,
	'reviews' => true,
	'subscribed' => true,
	'drafts' => true,
	'all' => true,
	);
	if (!isset($allows[$filter])) {
	throw new Exception("Unknown filter '{$filter}'!");
	}
	return $allows[$filter];
	}

	private function getFilterControls($filter) {
	static $controls = array(
	'active' => array('phid'),
	'revisions' => array('phid', 'status', 'order'),
	'reviews' => array('phid', 'status', 'order'),
	'subscribed' => array('subscriber', 'status', 'order'),
	'drafts' => array('phid', 'status', 'order'),
	'all' => array('status', 'order'),
	);
	if (!isset($controls[$filter])) {
	throw new Exception("Unknown filter '{$filter}'!");
	}
	return $controls[$filter];
	}

	- private function buildQuery($filter, $user_phid) {
	+ private function buildQuery($filter, array $user_phids) {
	$query = new DifferentialRevisionQuery();

	$query->needRelationships(true);

	switch ($filter) {
	case 'active':
	- $query->withResponsibleUsers(array($user_phid));
	+ $query->withResponsibleUsers($user_phids);
	$query->withStatus(DifferentialRevisionQuery::STATUS_OPEN);
	$query->setLimit(null);
	break;
	case 'revisions':
	- $query->withAuthors(array($user_phid));
	+ $query->withAuthors($user_phids);
	break;
	case 'reviews':
	- $query->withReviewers(array($user_phid));
	+ $query->withReviewers($user_phids);
	break;
	case 'subscribed':
	- $query->withSubscribers(array($user_phid));
	+ $query->withSubscribers($user_phids);
	break;
	case 'drafts':
	- $query->withDraftRepliesByAuthors(array($user_phid));
	+ $query->withDraftRepliesByAuthors($user_phids);
	break;
	case 'all':
	break;
	default:
	throw new Exception("Unknown filter '{$filter}'!");
	}
	return $query;
	}

	private function renderControl(
	$control,
	array $handles,
	PhutilURI $uri,
	array $params) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	switch ($control) {
	case 'subscriber':
	case 'phid':
	- $view_phid = $params['phid'];
	- $value = array();
	- if ($view_phid) {
	- $value = array(
	- $view_phid => $handles[$view_phid]->getFullName(),
	- );
	- }
	+ $value = mpull(
	+ array_select_keys($handles, $params['view_users']),
	+ 'getFullName');

	if ($control == 'subscriber') {
	$source = '/typeahead/common/allmailable/';
	- $label = 'View Subscriber';
	+ $label = 'View Subscribers';
	} else {
	$source = '/typeahead/common/accounts/';
	- $label = 'View User';
	+ $label = 'View Users';
	}

	return id(new AphrontFormTokenizerControl())
	->setDatasource($source)
	->setLabel($label)
	- ->setName('view_user')
	- ->setValue($value)
	- ->setLimit(1);
	+ ->setName('view_users')
	+ ->setValue($value);
	case 'status':
	return id(new AphrontFormToggleButtonsControl())
	->setLabel('Status')
	->setValue($params['status'])
	->setBaseURI($uri, 'status')
	->setButtons(
	array(
	'all' => 'All',
	'open' => 'Open',
	'closed' => pht('Closed'),
	'abandoned' => 'Abandoned',
	));
	case 'order':
	return id(new AphrontFormToggleButtonsControl())
	->setLabel('Order')
	->setValue($params['order'])
	->setBaseURI($uri, 'order')
	->setButtons(
	array(
	'modified' => 'Updated',
	'created' => 'Created',
	));
	default:
	throw new Exception("Unknown control '{$control}'!");
	}
	}

	private function applyControlToQuery($control, $query, array $params) {
	switch ($control) {
	case 'phid':
	case 'subscriber':
	// Already applied by query construction.
	break;
	case 'status':
	if ($params['status'] == 'open') {
	$query->withStatus(DifferentialRevisionQuery::STATUS_OPEN);
	} else if ($params['status'] == 'closed') {
	$query->withStatus(DifferentialRevisionQuery::STATUS_CLOSED);
	} else if ($params['status'] == 'abandoned') {
	$query->withStatus(DifferentialRevisionQuery::STATUS_ABANDONED);
	}
	break;
	case 'order':
	if ($params['order'] == 'created') {
	$query->setOrder(DifferentialRevisionQuery::ORDER_CREATED);
	}
	break;
	default:
	throw new Exception("Unknown control '{$control}'!");
	}
	}

	- private function buildViews($filter, $user_phid, array $revisions) {
	+ private function buildViews($filter, array $user_phids, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');

	$user = $this->getRequest()->getUser();

	$template = id(new DifferentialRevisionListView())
	->setUser($user)
	->setFields(DifferentialRevisionListView::getDefaultFields());

	$views = array();
	switch ($filter) {
	case 'active':
	list($active, $waiting) = DifferentialRevisionQuery::splitResponsible(
	$revisions,
	- $user_phid);
	+ $user_phids);

	$view = id(clone $template)
	->setHighlightAge(true)
	->setRevisions($active)
	->loadAssets();
	$views[] = array(
	'title' => 'Action Required',
	'view' => $view,
	);

	// Flags are sort of private, so only show the flag panel if you're
	// looking at your own requests.
	- if ($user_phid == $user->getPHID()) {
	+ if (in_array($user->getPHID(), $user_phids)) {
	$flags = id(new PhabricatorFlagQuery())
	- ->withOwnerPHIDs(array($user_phid))
	+ ->withOwnerPHIDs(array($user->getPHID()))
	->withTypes(array(PhabricatorPHIDConstants::PHID_TYPE_DREV))
	->needHandles(true)
	->execute();

	if ($flags) {
	$view = id(new PhabricatorFlagListView())
	->setFlags($flags)
	->setUser($user);

	$views[] = array(
	'title' => 'Flagged Revisions',
	'view' => $view,
	'special' => true,
	);
	}
	}

	$view = id(clone $template)
	->setRevisions($waiting)
	->loadAssets();
	$views[] = array(
	'title' => 'Waiting On Others',
	'view' => $view,
	);
	break;
	case 'revisions':
	case 'reviews':
	case 'subscribed':
	case 'drafts':
	case 'all':
	$titles = array(
	'revisions' => 'Revisions by Author',
	'reviews' => 'Revisions by Reviewer',
	'subscribed' => 'Revisions by Subscriber',
	'all' => 'Revisions',
	);
	$view = id(clone $template)
	->setRevisions($revisions)
	->loadAssets();
	$views[] = array(
	'title' => idx($titles, $filter),
	'view' => $view,
	);
	break;
	default:
	throw new Exception("Unknown filter '{$filter}'!");
	}

	return $views;
	}


	}
	diff --git a/src/applications/differential/query/DifferentialRevisionQuery.php b/src/applications/differential/query/DifferentialRevisionQuery.php
	index a9b687ce38..56f85464bc 100644
	--- a/src/applications/differential/query/DifferentialRevisionQuery.php
	+++ b/src/applications/differential/query/DifferentialRevisionQuery.php
	@@ -1,920 +1,920 @@
	<?php

	/**
	* Flexible query API for Differential revisions. Example:
	*
	* // Load open revisions
	* $revisions = id(new DifferentialRevisionQuery())
	* ->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	* ->execute();
	*
	* @task config Query Configuration
	* @task exec Query Execution
	* @task internal Internals
	*/
	final class DifferentialRevisionQuery {

	// TODO: Replace DifferentialRevisionListData with this class.

	private $pathIDs = array();

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_ACCEPTED = 'status-accepted';
	const STATUS_NEEDS_REVIEW = 'status-needs-review';
	const STATUS_CLOSED = 'status-closed'; // NOTE: Same as 'committed'.
	const STATUS_COMMITTED = 'status-committed'; // TODO: Remove.
	const STATUS_ABANDONED = 'status-abandoned';

	private $authors = array();
	private $draftAuthors = array();
	private $ccs = array();
	private $reviewers = array();
	private $revIDs = array();
	private $commitHashes = array();
	private $phids = array();
	private $subscribers = array();
	private $responsibles = array();
	private $branches = array();
	private $arcanistProjectPHIDs = array();
	private $draftRevisions = array();

	private $order = 'order-modified';
	const ORDER_MODIFIED = 'order-modified';
	const ORDER_CREATED = 'order-created';
	/**
	* This is essentially a denormalized copy of the revision modified time that
	* should perform better for path queries with a LIMIT. Critically, when you
	* browse "/", every revision in that repository for all time will match so
	* the query benefits from being able to stop before fully materializing the
	* result set.
	*/
	const ORDER_PATH_MODIFIED = 'order-path-modified';

	private $limit = 1000;
	private $offset = 0;

	private $needRelationships = false;
	private $needActiveDiffs = false;
	private $needDiffIDs = false;
	private $needCommitPHIDs = false;
	private $needHashes = false;


	/* -( 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 with comments authored bythe given PHIDs
	*
	* @param array List of PHIDs of authors
	* @return this
	* @task config
	*/
	public function withDraftRepliesByAuthors(array $author_phids) {
	$this->draftAuthors = $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 with a given status. Provide a class constant,
	* such as ##DifferentialRevisionQuery::STATUS_OPEN##.
	*
	* @param const Class STATUS constant, like STATUS_OPEN.
	* @return this
	* @task config
	*/
	public function withStatus($status_constant) {
	$this->status = $status_constant;
	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;
	}


	/**
	* Filter results to only return revisions with a given set of subscribers
	* (i.e., they are authors, reviewers or CC'd).
	*
	* @param array List of user PHIDs.
	* @return this
	* @task config
	*/
	public function withSubscribers(array $subscriber_phids) {
	$this->subscribers = $subscriber_phids;
	return $this;
	}


	/**
	* Filter results to only return revisions with a given set of arcanist
	* projects.
	*
	* @param array List of project PHIDs.
	* @return this
	* @task config
	*/
	public function withArcanistProjectPHIDs(array $arc_project_phids) {
	$this->arcanistProjectPHIDs = $arc_project_phids;
	return $this;
	}


	/**
	* Set result ordering. Provide a class constant, such as
	* ##DifferentialRevisionQuery::ORDER_CREATED##.
	*
	* @task config
	*/
	public function setOrder($order_constant) {
	$this->order = $order_constant;
	return $this;
	}


	/**
	* Set result limit. If unspecified, defaults to 1000.
	*
	* @param int Result limit.
	* @return this
	* @task config
	*/
	public function setLimit($limit) {
	$this->limit = $limit;
	return $this;
	}


	/**
	* Set result offset. If unspecified, defaults to 0.
	*
	* @param int Result offset.
	* @return this
	* @task config
	*/
	public function setOffset($offset) {
	$this->offset = $offset;
	return $this;
	}


	/**
	* Set whether or not the query will load and attach relationships.
	*
	* @param bool True to load and attach relationships.
	* @return this
	* @task config
	*/
	public function needRelationships($need_relationships) {
	$this->needRelationships = $need_relationships;
	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;
	}


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


	/**
	* Execute the query as configured, returning matching
	* @{class:DifferentialRevision} objects.
	*
	* @return list List of matching DifferentialRevision objects.
	* @task exec
	*/
	public function execute() {
	$table = new DifferentialRevision();
	$conn_r = $table->establishConnection('r');

	if ($this->shouldUseResponsibleFastPath()) {
	$data = $this->loadDataUsingResponsibleFastPath();
	} else {
	$data = $this->loadData();
	}

	$revisions = $table->loadAllFromArray($data);

	if ($revisions) {
	if ($this->needRelationships) {
	$this->loadRelationships($conn_r, $revisions);
	}

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

	return $revisions;
	}


	/**
	* Determine if we should execute an optimized, fast-path query to fetch
	* open revisions for one responsible user. This is used by the Differential
	* dashboard and much faster when executed as a UNION ALL than with JOIN
	* and WHERE, which is why we special case it.
	*/
	private function shouldUseResponsibleFastPath() {
	if ((count($this->responsibles) == 1) &&
	($this->status == self::STATUS_OPEN) &&
	($this->order == self::ORDER_MODIFIED) &&
	!$this->offset &&
	!$this->limit &&
	!$this->subscribers &&
	!$this->reviewers &&
	!$this->ccs &&
	!$this->authors &&
	!$this->revIDs &&
	!$this->commitHashes &&
	!$this->phids &&
	!$this->branches &&
	!$this->arcanistProjectPHIDs) {
	return true;
	}
	return false;
	}


	private function loadDataUsingResponsibleFastPath() {
	$table = new DifferentialRevision();
	$conn_r = $table->establishConnection('r');

	$responsible_phid = reset($this->responsibles);
	$open_statuses = array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
	ArcanistDifferentialRevisionStatus::NEEDS_REVISION,
	ArcanistDifferentialRevisionStatus::ACCEPTED,
	);

	return queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE authorPHID = %s AND status IN (%Ld)
	UNION ALL
	SELECT r.* FROM %T r JOIN %T rel
	ON rel.revisionID = r.id
	AND rel.relation = %s
	AND rel.objectPHID = %s
	WHERE r.status IN (%Ld) ORDER BY dateModified DESC',
	$table->getTableName(),
	$responsible_phid,
	$open_statuses,

	$table->getTableName(),
	DifferentialRevision::RELATIONSHIP_TABLE,
	DifferentialRevision::RELATION_REVIEWER,
	$responsible_phid,
	$open_statuses);
	}

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

	if ($this->draftAuthors) {
	$this->draftRevisions = array();

	$draft_key = 'differential-comment-';
	$drafts = id(new PhabricatorDraft())->loadAllWhere(
	'authorPHID IN (%Ls) AND draftKey LIKE %> AND draft != %s',
	$this->draftAuthors,
	$draft_key,
	'');
	$len = strlen($draft_key);
	foreach ($drafts as $draft) {
	$this->draftRevisions[] = substr($draft->getDraftKey(), $len);
	}

	$inlines = id(new DifferentialInlineComment())->loadAllWhere(
	'commentID IS NULL AND authorPHID IN (%Ls)',
	$this->draftAuthors);
	foreach ($inlines as $inline) {
	$this->draftRevisions[] = $inline->getRevisionID();
	}

	if (!$this->draftRevisions) {
	return array();
	}
	}

	$select = qsprintf(
	$conn_r,
	'SELECT r.* FROM %T r',
	$table->getTableName());

	$joins = $this->buildJoinsClause($conn_r);
	$where = $this->buildWhereClause($conn_r);
	$group_by = $this->buildGroupByClause($conn_r);
	$order_by = $this->buildOrderByClause($conn_r);

	$limit = '';
	if ($this->offset \|\| $this->limit) {
	$limit = qsprintf(
	$conn_r,
	'LIMIT %d, %d',
	(int)$this->offset,
	$this->limit);
	}

	return queryfx_all(
	$conn_r,
	'%Q %Q %Q %Q %Q %Q',
	$select,
	$joins,
	$where,
	$group_by,
	$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 cc_rel ON cc_rel.revisionID = r.id '.
	'AND cc_rel.relation = %s '.
	'AND cc_rel.objectPHID in (%Ls)',
	DifferentialRevision::RELATIONSHIP_TABLE,
	DifferentialRevision::RELATION_SUBSCRIBED,
	$this->ccs);
	}

	if ($this->reviewers) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T reviewer_rel ON reviewer_rel.revisionID = r.id '.
	'AND reviewer_rel.relation = %s '.
	'AND reviewer_rel.objectPHID in (%Ls)',
	DifferentialRevision::RELATIONSHIP_TABLE,
	DifferentialRevision::RELATION_REVIEWER,
	$this->reviewers);
	}

	if ($this->subscribers) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T sub_rel ON sub_rel.revisionID = r.id '.
	'AND sub_rel.relation IN (%Ls) '.
	'AND sub_rel.objectPHID in (%Ls)',
	DifferentialRevision::RELATIONSHIP_TABLE,
	array(
	DifferentialRevision::RELATION_SUBSCRIBED,
	DifferentialRevision::RELATION_REVIEWER,
	),
	$this->subscribers);
	}

	if ($this->responsibles) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T responsibles_rel ON responsibles_rel.revisionID = r.id '.
	'AND responsibles_rel.relation = %s '.
	'AND responsibles_rel.objectPHID in (%Ls)',
	DifferentialRevision::RELATIONSHIP_TABLE,
	DifferentialRevision::RELATION_REVIEWER,
	$this->responsibles);
	}

	$joins = implode(' ', $joins);

	return $joins;
	}


	/**
	* @task internal
	*/
	private function buildWhereClause($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->draftRevisions) {
	$where[] = qsprintf(
	$conn_r,
	'r.id IN (%Ld)',
	$this->draftRevisions);
	}

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

	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->phids) {
	$where[] = qsprintf(
	$conn_r,
	'r.phid IN (%Ls)',
	$this->phids);
	}

	if ($this->responsibles) {
	$where[] = qsprintf(
	$conn_r,
	'(responsibles_rel.objectPHID IS NOT NULL OR r.authorPHID IN (%Ls))',
	$this->responsibles);
	}

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

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

	switch ($this->status) {
	case self::STATUS_ANY:
	break;
	case self::STATUS_OPEN:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
	ArcanistDifferentialRevisionStatus::NEEDS_REVISION,
	ArcanistDifferentialRevisionStatus::ACCEPTED,
	));
	break;
	case self::STATUS_NEEDS_REVIEW:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::NEEDS_REVIEW,
	));
	break;
	case self::STATUS_ACCEPTED:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::ACCEPTED,
	));
	break;
	case self::STATUS_COMMITTED:
	phlog(
	"WARNING: DifferentialRevisionQuery using deprecated ".
	"STATUS_COMMITTED constant. This will be removed soon. ".
	"Use STATUS_CLOSED.");
	// fallthrough
	case self::STATUS_CLOSED:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::CLOSED,
	));
	break;
	case self::STATUS_ABANDONED:
	$where[] = qsprintf(
	$conn_r,
	'r.status IN (%Ld)',
	array(
	ArcanistDifferentialRevisionStatus::ABANDONED,
	));
	break;
	default:
	throw new Exception(
	"Unknown revision status filter constant '{$this->status}'!");
	}

	if ($where) {
	$where = 'WHERE '.implode(' AND ', $where);
	} else {
	$where = '';
	}

	return $where;
	}


	/**
	* @task internal
	*/
	private function buildGroupByClause($conn_r) {
	$join_triggers = array_merge(
	$this->pathIDs,
	$this->ccs,
	$this->reviewers,
	$this->subscribers,
	$this->responsibles);

	$needs_distinct = (count($join_triggers) > 1);

	if ($needs_distinct) {
	return 'GROUP BY r.id';
	} else {
	return '';
	}
	}


	/**
	* @task internal
	*/
	private function buildOrderByClause($conn_r) {
	switch ($this->order) {
	case self::ORDER_MODIFIED:
	return 'ORDER BY r.dateModified DESC';
	case self::ORDER_CREATED:
	return 'ORDER BY r.dateCreated DESC';
	case self::ORDER_PATH_MODIFIED:
	if (!$this->pathIDs) {
	throw new Exception(
	"To use ORDER_PATH_MODIFIED, you must specify withPath().");
	}
	return 'ORDER BY p.epoch DESC';
	default:
	throw new Exception("Unknown query order constant '{$this->order}'.");
	}
	}

	private function loadRelationships($conn_r, array $revisions) {
	assert_instances_of($revisions, 'DifferentialRevision');
	$relationships = queryfx_all(
	$conn_r,
	'SELECT * FROM %T WHERE revisionID in (%Ld) ORDER BY sequence',
	DifferentialRevision::RELATIONSHIP_TABLE,
	mpull($revisions, 'getID'));
	$relationships = igroup($relationships, 'revisionID');
	foreach ($revisions as $revision) {
	$revision->attachRelationships(
	idx(
	$relationships,
	$revision->getID(),
	array()));
	}
	}

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

	- public static function splitResponsible(array $revisions, $user_phid) {
	+ public static function splitResponsible(array $revisions, array $user_phids) {
	$active = array();
	$waiting = array();
	$status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;

	// Bucket revisions into $active (revisions you need to do something
	// about) and $waiting (revisions you're waiting on someone else to do
	// something about).
	foreach ($revisions as $revision) {
	$needs_review = ($revision->getStatus() == $status_review);
	- $filter_is_author = ($revision->getAuthorPHID() == $user_phid);
	+ $filter_is_author = in_array($revision->getAuthorPHID(), $user_phids);

	// If exactly one of "needs review" and "the user is the author" is
	// true, the user needs to act on it. Otherwise, they're waiting on
	// it.
	if ($needs_review ^ $filter_is_author) {
	$active[] = $revision;
	} else {
	$waiting[] = $revision;
	}
	}

	return array($active, $waiting);
	}


	}
	diff --git a/src/applications/directory/controller/PhabricatorDirectoryMainController.php b/src/applications/directory/controller/PhabricatorDirectoryMainController.php
	index 3e6f1145b3..754d519560 100644
	--- a/src/applications/directory/controller/PhabricatorDirectoryMainController.php
	+++ b/src/applications/directory/controller/PhabricatorDirectoryMainController.php
	@@ -1,593 +1,593 @@
	<?php

	final class PhabricatorDirectoryMainController
	extends PhabricatorDirectoryController {

	private $filter;
	private $subfilter;

	public function willProcessRequest(array $data) {
	$this->filter = idx($data, 'filter');
	$this->subfilter = idx($data, 'subfilter');
	}

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

	$nav = $this->buildNav();
	$this->filter = $nav->selectFilter($this->filter, 'home');

	switch ($this->filter) {
	case 'jump':
	break;
	case 'home':
	$project_query = new PhabricatorProjectQuery();
	$project_query->setViewer($user);
	$project_query->withMemberPHIDs(array($user->getPHID()));
	$projects = $project_query->execute();
	break;
	default:
	throw new Exception("Unknown filter '{$this->filter}'!");
	}

	switch ($this->filter) {
	case 'jump':
	return $this->buildJumpResponse($nav);
	default:
	return $this->buildMainResponse($nav, $projects);
	}

	}

	private function buildMainResponse($nav, array $projects) {
	assert_instances_of($projects, 'PhabricatorProject');

	if (PhabricatorEnv::getEnvConfig('maniphest.enabled')) {
	$unbreak_panel = $this->buildUnbreakNowPanel();
	$triage_panel = $this->buildNeedsTriagePanel($projects);
	$tasks_panel = $this->buildTasksPanel();
	} else {
	$unbreak_panel = null;
	$triage_panel = null;
	$tasks_panel = null;
	}

	$flagged_panel = $this->buildFlaggedPanel();

	$jump_panel = $this->buildJumpPanel();
	$revision_panel = $this->buildRevisionPanel();
	$app_panel = $this->buildAppPanel();
	$audit_panel = $this->buildAuditPanel();
	$commit_panel = $this->buildCommitPanel();

	$content = array(
	$app_panel,
	$jump_panel,
	$unbreak_panel,
	$triage_panel,
	$revision_panel,
	$tasks_panel,
	$flagged_panel,
	$audit_panel,
	$commit_panel,
	);

	$nav->appendChild($content);
	$nav->appendChild(new PhabricatorGlobalUploadTargetView());

	return $this->buildStandardPageResponse(
	$nav,
	array(
	'title' => 'Phabricator',
	));
	}

	private function buildJumpResponse($nav) {
	$request = $this->getRequest();

	$jump = $request->getStr('jump');

	$response = PhabricatorJumpNavHandler::jumpPostResponse($jump);
	if ($response) {
	return $response;
	} else if ($request->isFormPost()) {
	$query = new PhabricatorSearchQuery();
	$query->setQuery($jump);
	$query->save();

	return id(new AphrontRedirectResponse())
	->setURI('/search/'.$query->getQueryKey().'/');
	}


	$nav->appendChild($this->buildJumpPanel($jump));
	return $this->buildStandardPageResponse(
	$nav,
	array(
	'title' => 'Jump Nav',
	));
	}

	private function buildUnbreakNowPanel() {
	$user = $this->getRequest()->getUser();
	$user_phid = $user->getPHID();

	$task_query = new ManiphestTaskQuery();
	$task_query->withStatus(ManiphestTaskQuery::STATUS_OPEN);
	$task_query->withPriority(ManiphestTaskPriority::PRIORITY_UNBREAK_NOW);
	$task_query->setLimit(10);

	$tasks = $task_query->execute();

	if (!$tasks) {
	return $this->renderMiniPanel(
	'No "Unbreak Now!" Tasks',
	'Nothing appears to be critically broken right now.');
	}

	$panel = new AphrontPanelView();
	$panel->setHeader('Unbreak Now!');
	$panel->setCaption('Open tasks with "Unbreak Now!" priority.');
	$panel->addButton(
	phutil_render_tag(
	'a',
	array(
	'href' => '/maniphest/view/all/',
	'class' => 'grey button',
	),
	"View All Unbreak Now \xC2\xBB"));

	$panel->appendChild($this->buildTaskListView($tasks));

	return $panel;
	}

	private function buildFlaggedPanel() {
	$user = $this->getRequest()->getUser();

	$flag_query = id(new PhabricatorFlagQuery())
	->setViewer($user)
	->withOwnerPHIDs(array($user->getPHID()))
	->needHandles(true)
	->setLimit(10);

	$flags = $flag_query->execute();

	if (!$flags) {
	return $this->renderMiniPanel(
	'No Flags',
	"You haven't flagged anything.");
	}

	$panel = new AphrontPanelView();
	$panel->setHeader('Flagged Objects');
	$panel->setCaption("Objects you've flagged.");

	$flag_view = new PhabricatorFlagListView();
	$flag_view->setFlags($flags);
	$flag_view->setUser($user);
	$panel->appendChild($flag_view);

	$panel->addButton(
	phutil_render_tag(
	'a',
	array(
	'href' => '/flag/',
	'class' => 'grey button',
	),
	"View All Flags \xC2\xBB"));

	return $panel;
	}

	private function buildNeedsTriagePanel(array $projects) {
	assert_instances_of($projects, 'PhabricatorProject');

	$user = $this->getRequest()->getUser();
	$user_phid = $user->getPHID();

	if ($projects) {
	$task_query = new ManiphestTaskQuery();
	$task_query->withStatus(ManiphestTaskQuery::STATUS_OPEN);
	$task_query->withPriority(ManiphestTaskPriority::PRIORITY_TRIAGE);
	$task_query->withAnyProjects(mpull($projects, 'getPHID'));
	$task_query->setLimit(10);
	$tasks = $task_query->execute();
	} else {
	$tasks = array();
	}

	if (!$tasks) {
	return $this->renderMiniPanel(
	'No "Needs Triage" Tasks',
	'No tasks in <a href="/project/">projects you are a member of</a> '.
	'need triage.');
	}

	$panel = new AphrontPanelView();
	$panel->setHeader('Needs Triage');
	$panel->setCaption(
	'Open tasks with "Needs Triage" priority in '.
	'<a href="/project/">projects you are a member of</a>.');

	$panel->addButton(
	phutil_render_tag(
	'a',
	array(
	// TODO: This should filter to just your projects' need-triage
	// tasks?
	'href' => '/maniphest/view/projecttriage/',
	'class' => 'grey button',
	),
	"View All Triage \xC2\xBB"));
	$panel->appendChild($this->buildTaskListView($tasks));

	return $panel;
	}

	private function buildRevisionPanel() {
	$user = $this->getRequest()->getUser();
	$user_phid = $user->getPHID();

	$revision_query = new DifferentialRevisionQuery();
	$revision_query->withStatus(DifferentialRevisionQuery::STATUS_OPEN);
	$revision_query->withResponsibleUsers(array($user_phid));
	$revision_query->needRelationships(true);

	// NOTE: We need to unlimit this query to hit the responsible user
	// fast-path.
	$revision_query->setLimit(null);
	$revisions = $revision_query->execute();

	list($active, $waiting) = DifferentialRevisionQuery::splitResponsible(
	$revisions,
	- $user_phid);
	+ array($user_phid));

	if (!$active) {
	return $this->renderMiniPanel(
	'No Waiting Revisions',
	'No revisions are waiting on you.');
	}

	$panel = new AphrontPanelView();
	$panel->setHeader('Revisions Waiting on You');
	$panel->setCaption('Revisions waiting for you for review or commit.');

	$panel->addButton(
	phutil_render_tag(
	'a',
	array(
	'href' => '/differential/',
	'class' => 'button grey',
	),
	"View Active Revisions \xC2\xBB"));

	$revision_view = id(new DifferentialRevisionListView())
	->setHighlightAge(true)
	->setRevisions($active)
	->setFields(DifferentialRevisionListView::getDefaultFields())
	->setUser($user)
	->loadAssets();
	$phids = array_merge(
	array($user_phid),
	$revision_view->getRequiredHandlePHIDs());
	$handles = $this->loadViewerHandles($phids);

	$revision_view->setHandles($handles);

	$panel->appendChild($revision_view);

	return $panel;
	}

	private function buildTasksPanel() {
	$user = $this->getRequest()->getUser();
	$user_phid = $user->getPHID();

	$task_query = new ManiphestTaskQuery();
	$task_query->withStatus(ManiphestTaskQuery::STATUS_OPEN);
	$task_query->setGroupBy(ManiphestTaskQuery::GROUP_PRIORITY);
	$task_query->withOwners(array($user_phid));
	$task_query->setLimit(10);

	$tasks = $task_query->execute();


	if (!$tasks) {
	return $this->renderMiniPanel(
	'No Assigned Tasks',
	'You have no assigned tasks.');
	}

	$panel = new AphrontPanelView();
	$panel->setHeader('Assigned Tasks');
	$panel->setCaption('Tasks assigned to you.');

	$panel->addButton(
	phutil_render_tag(
	'a',
	array(
	'href' => '/maniphest/',
	'class' => 'button grey',
	),
	"View Active Tasks \xC2\xBB"));
	$panel->appendChild($this->buildTaskListView($tasks));

	return $panel;
	}

	private function buildTaskListView(array $tasks) {
	assert_instances_of($tasks, 'ManiphestTask');
	$user = $this->getRequest()->getUser();

	$phids = array_merge(
	array_filter(mpull($tasks, 'getOwnerPHID')),
	array_mergev(mpull($tasks, 'getProjectPHIDs')));

	$handles = $this->loadViewerHandles($phids);

	$view = new ManiphestTaskListView();
	$view->setTasks($tasks);
	$view->setUser($user);
	$view->setHandles($handles);

	return $view;
	}

	private function buildJumpPanel($query=null) {
	$request = $this->getRequest();
	$user = $request->getUser();

	$uniq_id = celerity_generate_unique_node_id();

	Javelin::initBehavior(
	'phabricator-autofocus',
	array(
	'id' => $uniq_id,
	));

	require_celerity_resource('phabricator-jump-nav');

	$doc_href = PhabricatorEnv::getDocLink('article/Jump_Nav_User_Guide.html');
	$doc_link = phutil_render_tag(
	'a',
	array(
	'href' => $doc_href,
	),
	'Jump Nav User Guide');

	$jump_input = phutil_render_tag(
	'input',
	array(
	'type' => 'text',
	'class' => 'phabricator-jump-nav',
	'name' => 'jump',
	'id' => $uniq_id,
	'value' => $query,
	));
	$jump_caption = phutil_render_tag(
	'p',
	array(
	'class' => 'phabricator-jump-nav-caption',
	),
	'Enter the name of an object like <tt>D123</tt> to quickly jump to '.
	'it. See '.$doc_link.' or type <tt>help</tt>.');

	$panel = new AphrontPanelView();
	$panel->addClass('aphront-unpadded-panel-view');
	$panel->appendChild(
	phabricator_render_form(
	$user,
	array(
	'action' => '/jump/',
	'method' => 'POST',
	'class' => 'phabricator-jump-nav-form',
	),
	$jump_input.
	$jump_caption));

	return $panel;
	}

	private function buildAppPanel() {
	require_celerity_resource('phabricator-app-buttons-css');

	$nav_buttons = array();

	$nav_buttons[] = array(
	'Differential',
	'/differential/',
	'differential',
	'Code Reviews');

	if (PhabricatorEnv::getEnvConfig('maniphest.enabled')) {
	$nav_buttons[] = array(
	'Maniphest',
	'/maniphest/',
	'maniphest',
	'Tasks');
	$nav_buttons[] = array(
	'Create Task',
	'/maniphest/task/create/',
	'create-task');
	}

	$nav_buttons[] = array(
	'Upload File',
	'/file/upload/',
	'upload-file',
	'Share Files');
	$nav_buttons[] = array(
	'Create Paste',
	'/paste/create/',
	'create-paste',
	'Share Text');


	if (PhabricatorEnv::getEnvConfig('phriction.enabled')) {
	$nav_buttons[] = array(
	'Phriction',
	'/w/',
	'phriction',
	'Browse Wiki');
	}

	$nav_buttons[] = array(
	'Diffusion',
	'/diffusion/',
	'diffusion',
	'Browse Code');

	$nav_buttons[] = array(
	'Audit',
	'/audit/',
	'audit',
	'Audit Code');

	$view = new AphrontNullView();
	$view->appendChild('<div class="phabricator-app-buttons">');
	foreach ($nav_buttons as $info) {
	// Subtitle is optional.
	list($name, $uri, $icon, $subtitle) = array_merge($info, array(null));

	if ($subtitle) {
	$subtitle =
	'<div class="phabricator-app-subtitle">'.
	phutil_escape_html($subtitle).
	'</div>';
	}

	$button = phutil_render_tag(
	'a',
	array(
	'href' => $uri,
	'class' => 'app-button icon-'.$icon,
	),
	phutil_render_tag(
	'div',
	array(
	'class' => 'app-icon icon-'.$icon,
	),
	''));
	$caption = phutil_render_tag(
	'a',
	array(
	'href' => $uri,
	'class' => 'phabricator-button-caption',
	),
	phutil_escape_html($name).$subtitle);

	$view->appendChild(
	'<div class="phabricator-app-button">'.
	$button.
	$caption.
	'</div>');
	}
	$view->appendChild('<div style="clear: both;"></div></div>');

	return $view;
	}

	private function renderMiniPanel($title, $body) {
	$panel = new AphrontMiniPanelView();
	$panel->appendChild(
	phutil_render_tag(
	'p',
	array(
	),
	'<strong>'.$title.':</strong> '.$body));
	return $panel;
	}

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

	$phids = PhabricatorAuditCommentEditor::loadAuditPHIDsForUser($user);

	$query = new PhabricatorAuditQuery();
	$query->withAuditorPHIDs($phids);
	$query->withStatus(PhabricatorAuditQuery::STATUS_OPEN);
	$query->withAwaitingUser($user);
	$query->needCommitData(true);
	$query->setLimit(10);

	$audits = $query->execute();
	$commits = $query->getCommits();

	if (!$audits) {
	return $this->renderMinipanel(
	'No Audits',
	'No commits are waiting for you to audit them.');
	}

	$view = new PhabricatorAuditListView();
	$view->setAudits($audits);
	$view->setCommits($commits);
	$view->setUser($user);

	$phids = $view->getRequiredHandlePHIDs();
	$handles = $this->loadViewerHandles($phids);
	$view->setHandles($handles);

	$panel = new AphrontPanelView();
	$panel->setHeader('Audits');
	$panel->setCaption('Commits awaiting your audit.');
	$panel->appendChild($view);
	$panel->addButton(
	phutil_render_tag(
	'a',
	array(
	'href' => '/audit/',
	'class' => 'button grey',
	),
	"View Active Audits \xC2\xBB"));

	return $panel;
	}

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

	$phids = array($user->getPHID());

	$query = new PhabricatorAuditCommitQuery();
	$query->withAuthorPHIDs($phids);
	$query->withStatus(PhabricatorAuditQuery::STATUS_OPEN);
	$query->needCommitData(true);
	$query->setLimit(10);

	$commits = $query->execute();

	if (!$commits) {
	return $this->renderMinipanel(
	'No Problem Commits',
	'No one has raised concerns with your commits.');
	}

	$view = new PhabricatorAuditCommitListView();
	$view->setCommits($commits);
	$view->setUser($user);

	$phids = $view->getRequiredHandlePHIDs();
	$handles = $this->loadViewerHandles($phids);
	$view->setHandles($handles);

	$panel = new AphrontPanelView();
	$panel->setHeader('Problem Commits');
	$panel->setCaption('Commits which auditors have raised concerns about.');
	$panel->appendChild($view);
	$panel->addButton(
	phutil_render_tag(
	'a',
	array(
	'href' => '/audit/',
	'class' => 'button grey',
	),
	"View Problem Commits \xC2\xBB"));

	return $panel;
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jul 2, 3:31 AM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 164661
Default Alt Text: (61 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions