No OneTemporary
Actions

Size

83 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/base/controller/PhabricatorController.php b/src/applications/base/controller/PhabricatorController.php
	index fa3e1ee107..f7ea73a453 100644
	--- a/src/applications/base/controller/PhabricatorController.php
	+++ b/src/applications/base/controller/PhabricatorController.php
	@@ -1,591 +1,590 @@
	<?php

	abstract class PhabricatorController extends AphrontController {

	private $handles;

	public function shouldRequireLogin() {
	return true;
	}

	public function shouldRequireAdmin() {
	return false;
	}

	public function shouldRequireEnabledUser() {
	return true;
	}

	public function shouldAllowPublic() {
	return false;
	}

	public function shouldAllowPartialSessions() {
	return false;
	}

	public function shouldRequireEmailVerification() {
	return PhabricatorUserEmail::isEmailVerificationRequired();
	}

	public function shouldAllowRestrictedParameter($parameter_name) {
	return false;
	}

	public function shouldRequireMultiFactorEnrollment() {
	if (!$this->shouldRequireLogin()) {
	return false;
	}

	if (!$this->shouldRequireEnabledUser()) {
	return false;
	}

	if ($this->shouldAllowPartialSessions()) {
	return false;
	}

	$user = $this->getRequest()->getUser();
	if (!$user->getIsStandardUser()) {
	return false;
	}

	return PhabricatorEnv::getEnvConfig('security.require-multi-factor-auth');
	}

	public function shouldAllowLegallyNonCompliantUsers() {
	return false;
	}

	public function willBeginExecution() {
	$request = $this->getRequest();

	if ($request->getUser()) {
	// NOTE: Unit tests can set a user explicitly. Normal requests are not
	// permitted to do this.
	PhabricatorTestCase::assertExecutingUnitTests();
	$user = $request->getUser();
	} else {
	$user = new PhabricatorUser();
	$session_engine = new PhabricatorAuthSessionEngine();

	$phsid = $request->getCookie(PhabricatorCookies::COOKIE_SESSION);
	if (strlen($phsid)) {
	$session_user = $session_engine->loadUserForSession(
	PhabricatorAuthSession::TYPE_WEB,
	$phsid);
	if ($session_user) {
	$user = $session_user;
	}
	} else {
	// If the client doesn't have a session token, generate an anonymous
	// session. This is used to provide CSRF protection to logged-out users.
	$phsid = $session_engine->establishSession(
	PhabricatorAuthSession::TYPE_WEB,
	null,
	$partial = false);

	// This may be a resource request, in which case we just don't set
	// the cookie.
	if ($request->canSetCookies()) {
	$request->setCookie(PhabricatorCookies::COOKIE_SESSION, $phsid);
	}
	}


	if (!$user->isLoggedIn()) {
	$user->attachAlternateCSRFString(PhabricatorHash::digest($phsid));
	}

	$request->setUser($user);
	}

	$locale_code = $user->getTranslation();
	if ($locale_code) {
	PhabricatorEnv::setLocaleCode($locale_code);
	}

	$preferences = $user->loadPreferences();
	if (PhabricatorEnv::getEnvConfig('darkconsole.enabled')) {
	$dark_console = PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE;
	if ($preferences->getPreference($dark_console) \|\|
	PhabricatorEnv::getEnvConfig('darkconsole.always-on')) {
	$console = new DarkConsoleCore();
	$request->getApplicationConfiguration()->setConsole($console);
	}
	}

	// NOTE: We want to set up the user first so we can render a real page
	// here, but fire this before any real logic.
	$restricted = array(
	'code',
	);
	foreach ($restricted as $parameter) {
	if ($request->getExists($parameter)) {
	if (!$this->shouldAllowRestrictedParameter($parameter)) {
	throw new Exception(
	pht(
	'Request includes restricted parameter "%s", but this '.
	'controller ("%s") does not whitelist it. Refusing to '.
	'serve this request because it might be part of a redirection '.
	'attack.',
	$parameter,
	get_class($this)));
	}
	}
	}

	if ($this->shouldRequireEnabledUser()) {
	if ($user->isLoggedIn() && !$user->getIsApproved()) {
	$controller = new PhabricatorAuthNeedsApprovalController();
	return $this->delegateToController($controller);
	}
	if ($user->getIsDisabled()) {
	$controller = new PhabricatorDisabledUserController();
	return $this->delegateToController($controller);
	}
	}

	$event = new PhabricatorEvent(
	PhabricatorEventType::TYPE_CONTROLLER_CHECKREQUEST,
	array(
	'request' => $request,
	'controller' => $this,
	));
	$event->setUser($user);
	PhutilEventEngine::dispatchEvent($event);
	$checker_controller = $event->getValue('controller');
	if ($checker_controller != $this) {
	return $this->delegateToController($checker_controller);
	}

	$auth_class = 'PhabricatorAuthApplication';
	$auth_application = PhabricatorApplication::getByClass($auth_class);

	// Require partial sessions to finish login before doing anything.
	if (!$this->shouldAllowPartialSessions()) {
	if ($user->hasSession() &&
	$user->getSession()->getIsPartial()) {
	$login_controller = new PhabricatorAuthFinishController();
	$this->setCurrentApplication($auth_application);
	return $this->delegateToController($login_controller);
	}
	}

	// Check if the user needs to configure MFA.
	$need_mfa = $this->shouldRequireMultiFactorEnrollment();
	$have_mfa = $user->getIsEnrolledInMultiFactor();
	if ($need_mfa && !$have_mfa) {
	// Check if the cache is just out of date. Otherwise, roadblock the user
	// and require MFA enrollment.
	$user->updateMultiFactorEnrollment();
	if (!$user->getIsEnrolledInMultiFactor()) {
	$mfa_controller = new PhabricatorAuthNeedsMultiFactorController();
	$this->setCurrentApplication($auth_application);
	return $this->delegateToController($mfa_controller);
	}
	}

	if ($this->shouldRequireLogin()) {
	// This actually means we need either:
	// - a valid user, or a public controller; and
	// - permission to see the application.

	$allow_public = $this->shouldAllowPublic() &&
	PhabricatorEnv::getEnvConfig('policy.allow-public');

	// If this controller isn't public, and the user isn't logged in, require
	// login.
	if (!$allow_public && !$user->isLoggedIn()) {
	$login_controller = new PhabricatorAuthStartController();
	$this->setCurrentApplication($auth_application);
	return $this->delegateToController($login_controller);
	}

	if ($user->isLoggedIn()) {
	if ($this->shouldRequireEmailVerification()) {
	if (!$user->getIsEmailVerified()) {
	$controller = new PhabricatorMustVerifyEmailController();
	$this->setCurrentApplication($auth_application);
	return $this->delegateToController($controller);
	}
	}
	}

	// If the user doesn't have access to the application, don't let them use
	// any of its controllers. We query the application in order to generate
	// a policy exception if the viewer doesn't have permission.

	$application = $this->getCurrentApplication();
	if ($application) {
	id(new PhabricatorApplicationQuery())
	->setViewer($user)
	->withPHIDs(array($application->getPHID()))
	->executeOne();
	}
	}


	if (!$this->shouldAllowLegallyNonCompliantUsers()) {
	$legalpad_class = 'PhabricatorLegalpadApplication';
	$legalpad = id(new PhabricatorApplicationQuery())
	->setViewer($user)
	->withClasses(array($legalpad_class))
	->withInstalled(true)
	->execute();
	$legalpad = head($legalpad);

	$doc_query = id(new LegalpadDocumentQuery())
	->setViewer($user)
	->withSignatureRequired(1)
	->needViewerSignatures(true);

	if ($user->hasSession() &&
	!$user->getSession()->getIsPartial() &&
	!$user->getSession()->getSignedLegalpadDocuments() &&
	$user->isLoggedIn() &&
	$legalpad) {

	$sign_docs = $doc_query->execute();
	$must_sign_docs = array();
	foreach ($sign_docs as $sign_doc) {
	if (!$sign_doc->getUserSignature($user->getPHID())) {
	$must_sign_docs[] = $sign_doc;
	}
	}
	if ($must_sign_docs) {
	$controller = new LegalpadDocumentSignController();
	$this->getRequest()->setURIMap(array(
	'id' => head($must_sign_docs)->getID(),
	));
	$this->setCurrentApplication($legalpad);
	return $this->delegateToController($controller);
	} else {
	$engine = id(new PhabricatorAuthSessionEngine())
	->signLegalpadDocuments($user, $sign_docs);
	}
	}
	}

	// NOTE: We do this last so that users get a login page instead of a 403
	// if they need to login.
	if ($this->shouldRequireAdmin() && !$user->getIsAdmin()) {
	return new Aphront403Response();
	}
	}

	public function buildStandardPageView() {
	$view = new PhabricatorStandardPageView();
	$view->setRequest($this->getRequest());
	$view->setController($this);
	return $view;
	}

	public function buildStandardPageResponse($view, array $data) {
	$page = $this->buildStandardPageView();
	$page->appendChild($view);
	return $this->buildPageResponse($page);
	}

	private function buildPageResponse($page) {
	if ($this->getRequest()->isQuicksand()) {
	$response = id(new AphrontAjaxResponse())
	->setContent($page->renderForQuicksand());
	} else {
	$response = id(new AphrontWebpageResponse())
	->setContent($page->render());
	}

	return $response;
	}

	public function getApplicationURI($path = '') {
	if (!$this->getCurrentApplication()) {
	throw new Exception('No application!');
	}
	return $this->getCurrentApplication()->getApplicationURI($path);
	}

	public function buildApplicationPage($view, array $options) {
	$page = $this->buildStandardPageView();

	$title = PhabricatorEnv::getEnvConfig('phabricator.serious-business') ?
	'Phabricator' :
	pht('Bacon Ice Cream for Breakfast');

	$application = $this->getCurrentApplication();
	$page->setTitle(idx($options, 'title', $title));
	if ($application) {
	$page->setApplicationName($application->getName());
	if ($application->getTitleGlyph()) {
	$page->setGlyph($application->getTitleGlyph());
	}
	}

	if (!($view instanceof AphrontSideNavFilterView)) {
	$nav = new AphrontSideNavFilterView();
	$nav->appendChild($view);
	$view = $nav;
	}

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

	$page->appendChild($view);

	$object_phids = idx($options, 'pageObjects', array());
	if ($object_phids) {
	$page->appendPageObjects($object_phids);
	foreach ($object_phids as $object_phid) {
	PhabricatorFeedStoryNotification::updateObjectNotificationViews(
	$user,
	$object_phid);
	}
	}

	if (idx($options, 'device', true)) {
	$page->setDeviceReady(true);
	}

	$page->setShowFooter(idx($options, 'showFooter', true));
	$page->setShowChrome(idx($options, 'chrome', true));

	$application_menu = $this->buildApplicationMenu();
	if ($application_menu) {
	$page->setApplicationMenu($application_menu);
	}

	return $this->buildPageResponse($page);
	}

	public function didProcessRequest($response) {
	// If a bare DialogView is returned, wrap it in a DialogResponse.
	if ($response instanceof AphrontDialogView) {
	$response = id(new AphrontDialogResponse())->setDialog($response);
	}

	$request = $this->getRequest();
	$response->setRequest($request);

	$seen = array();
	while ($response instanceof AphrontProxyResponse) {
	$hash = spl_object_hash($response);
	if (isset($seen[$hash])) {
	$seen[] = get_class($response);
	throw new Exception(
	'Cycle while reducing proxy responses: '.
	implode(' -> ', $seen));
	}
	$seen[$hash] = get_class($response);

	$response = $response->reduceProxyResponse();
	}

	if ($response instanceof AphrontDialogResponse) {
	if (!$request->isAjax() && !$request->isQuicksand()) {
	$dialog = $response->getDialog();

	$title = $dialog->getTitle();
	$short = $dialog->getShortTitle();

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb(coalesce($short, $title));

	$page_content = array(
	$crumbs,
	$response->buildResponseString(),
	);

	$view = id(new PhabricatorStandardPageView())
	->setRequest($request)
	->setController($this)
	->setDeviceReady(true)
	->setTitle($title)
	->appendChild($page_content);

	$response = id(new AphrontWebpageResponse())
	->setContent($view->render())
	->setHTTPResponseCode($response->getHTTPResponseCode());
	} else {
	$response->getDialog()->setIsStandalone(true);

	return id(new AphrontAjaxResponse())
	->setContent(array(
	'dialog' => $response->buildResponseString(),
	));
	}
	} else if ($response instanceof AphrontRedirectResponse) {
	if ($request->isAjax() \|\| $request->isQuicksand()) {
	return id(new AphrontAjaxResponse())
	->setContent(
	array(
	'redirect' => $response->getURI(),
	));
	}
	}

	return $response;
	}

	/**
	* WARNING: Do not call this in new code.
	*
	* @deprecated See "Handles Technical Documentation".
	*/
	protected function loadViewerHandles(array $phids) {
	return id(new PhabricatorHandleQuery())
	->setViewer($this->getRequest()->getUser())
	->withPHIDs($phids)
	->execute();
	}

	public function buildApplicationMenu() {
	return null;
	}

	protected function buildApplicationCrumbs() {
	$crumbs = array();

	$application = $this->getCurrentApplication();
	if ($application) {
	$icon = $application->getFontIcon();
	if (!$icon) {
	$icon = 'fa-puzzle';
	}

	$crumbs[] = id(new PHUICrumbView())
	->setHref($this->getApplicationURI())
	->setName($application->getName())
	->setIcon($icon);
	}

	$view = new PHUICrumbsView();
	foreach ($crumbs as $crumb) {
	$view->addCrumb($crumb);
	}

	return $view;
	}

	protected function hasApplicationCapability($capability) {
	return PhabricatorPolicyFilter::hasCapability(
	$this->getRequest()->getUser(),
	$this->getCurrentApplication(),
	$capability);
	}

	protected function requireApplicationCapability($capability) {
	PhabricatorPolicyFilter::requireCapability(
	$this->getRequest()->getUser(),
	$this->getCurrentApplication(),
	$capability);
	}

	protected function explainApplicationCapability(
	$capability,
	$positive_message,
	$negative_message) {

	$can_act = $this->hasApplicationCapability($capability);
	if ($can_act) {
	$message = $positive_message;
	$icon_name = 'fa-play-circle-o lightgreytext';
	} else {
	$message = $negative_message;
	$icon_name = 'fa-lock';
	}

	$icon = id(new PHUIIconView())
	->setIconFont($icon_name);

	require_celerity_resource('policy-css');

	$phid = $this->getCurrentApplication()->getPHID();
	$explain_uri = "/policy/explain/{$phid}/{$capability}/";

	$message = phutil_tag(
	'div',
	array(
	'class' => 'policy-capability-explanation',
	),
	array(
	$icon,
	javelin_tag(
	'a',
	array(
	'href' => $explain_uri,
	'sigil' => 'workflow',
	),
	$message),
	));

	return array($can_act, $message);
	}

	public function getDefaultResourceSource() {
	return 'phabricator';
	}

	/**
	* Create a new @{class:AphrontDialogView} with defaults filled in.
	*
	* @return AphrontDialogView New dialog.
	*/
	public function newDialog() {
	$submit_uri = new PhutilURI($this->getRequest()->getRequestURI());
	$submit_uri = $submit_uri->getPath();

	return id(new AphrontDialogView())
	->setUser($this->getRequest()->getUser())
	->setSubmitURI($submit_uri);
	}

	protected function buildTransactionTimeline(
	PhabricatorApplicationTransactionInterface $object,
	PhabricatorApplicationTransactionQuery $query,
	PhabricatorMarkupEngine $engine = null,
	$render_data = array()) {

	$viewer = $this->getRequest()->getUser();
	$xaction = $object->getApplicationTransactionTemplate();
	$view = $xaction->getApplicationTransactionViewObject();

	$pager = id(new AphrontCursorPagerView())
	->readFromRequest($this->getRequest())
	->setURI(new PhutilURI(
	'/transactions/showolder/'.$object->getPHID().'/'));

	$xactions = $query
	->setViewer($viewer)
	->withObjectPHIDs(array($object->getPHID()))
	->needComments(true)
	- ->setReversePaging(false)
	->executeWithCursorPager($pager);
	$xactions = array_reverse($xactions);

	if ($engine) {
	foreach ($xactions as $xaction) {
	if ($xaction->getComment()) {
	$engine->addObject(
	$xaction->getComment(),
	PhabricatorApplicationTransactionComment::MARKUP_FIELD_COMMENT);
	}
	}
	$engine->process();
	$view->setMarkupEngine($engine);
	}

	$timeline = $view
	->setUser($viewer)
	->setObjectPHID($object->getPHID())
	->setTransactions($xactions)
	->setPager($pager)
	->setRenderData($render_data)
	->setQuoteTargetID($this->getRequest()->getStr('quoteTargetID'))
	->setQuoteRef($this->getRequest()->getStr('quoteRef'));
	$object->willRenderTimeline($timeline, $this->getRequest());

	return $timeline;
	}

	}
	diff --git a/src/applications/config/controller/PhabricatorConfigHistoryController.php b/src/applications/config/controller/PhabricatorConfigHistoryController.php
	index 97fb926569..acb1d3c297 100644
	--- a/src/applications/config/controller/PhabricatorConfigHistoryController.php
	+++ b/src/applications/config/controller/PhabricatorConfigHistoryController.php
	@@ -1,54 +1,52 @@
	<?php

	final class PhabricatorConfigHistoryController
	extends PhabricatorConfigController {

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

	$xactions = id(new PhabricatorConfigTransactionQuery())
	->setViewer($user)
	->needComments(true)
	- ->setReversePaging(false)
	->execute();

	$object = new PhabricatorConfigEntry();

	$xaction = $object->getApplicationTransactionTemplate();

	$view = $xaction->getApplicationTransactionViewObject();

	$timeline = $view
	->setUser($user)
	->setTransactions($xactions)
	->setRenderAsFeed(true)
	->setObjectPHID(PhabricatorPHIDConstants::PHID_VOID);

	$timeline->setShouldTerminate(true);

	$object->willRenderTimeline($timeline, $this->getRequest());

	$title = pht('Settings History');

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->setBorder(true);
	$crumbs->addTextCrumb('Config', $this->getApplicationURI());
	$crumbs->addTextCrumb($title, '/config/history/');

	$nav = $this->buildSideNavView();
	$nav->selectFilter('history/');
	$nav->setCrumbs($crumbs);
	$nav->appendChild($timeline);

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

	}
	diff --git a/src/applications/conpherence/query/ConpherenceTransactionQuery.php b/src/applications/conpherence/query/ConpherenceTransactionQuery.php
	index aa2408d025..649a1ba6ab 100644
	--- a/src/applications/conpherence/query/ConpherenceTransactionQuery.php
	+++ b/src/applications/conpherence/query/ConpherenceTransactionQuery.php
	@@ -1,14 +1,15 @@
	<?php

	final class ConpherenceTransactionQuery
	extends PhabricatorApplicationTransactionQuery {

	public function getTemplateApplicationTransaction() {
	return new ConpherenceTransaction();
	}

	- protected function getReversePaging() {
	- return false;
	+ protected function getDefaultOrderVector() {
	+ // TODO: Can we get rid of this?
	+ return array('-id');
	}

	}
	diff --git a/src/applications/differential/query/DifferentialHunkQuery.php b/src/applications/differential/query/DifferentialHunkQuery.php
	index 7fb7ec864b..94bc0297b3 100644
	--- a/src/applications/differential/query/DifferentialHunkQuery.php
	+++ b/src/applications/differential/query/DifferentialHunkQuery.php
	@@ -1,119 +1,120 @@
	<?php

	final class DifferentialHunkQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $changesets;
	private $shouldAttachToChangesets;

	public function withChangesets(array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');
	$this->changesets = $changesets;
	return $this;
	}

	public function needAttachToChangesets($attach) {
	$this->shouldAttachToChangesets = $attach;
	return $this;
	}

	protected function willExecute() {
	// If we fail to load any hunks at all (for example, because all of
	// the requested changesets are directories or empty files and have no
	// hunks) we'll never call didFilterPage(), and thus never have an
	// opportunity to attach hunks. Attach empty hunk lists now so that we
	// end up with the right result.
	if ($this->shouldAttachToChangesets) {
	foreach ($this->changesets as $changeset) {
	$changeset->attachHunks(array());
	}
	}
	}

	protected function loadPage() {
	$all_results = array();

	// Load modern hunks.
	$table = new DifferentialModernHunk();
	$conn_r = $table->establishConnection('r');

	$modern_data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T %Q %Q %Q',
	$table->getTableName(),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));
	$modern_results = $table->loadAllFromArray($modern_data);


	// Now, load legacy hunks.
	$table = new DifferentialLegacyHunk();
	$conn_r = $table->establishConnection('r');

	$legacy_data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T %Q %Q %Q',
	$table->getTableName(),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));
	$legacy_results = $table->loadAllFromArray($legacy_data);

	// Strip all the IDs off since they're not unique and nothing should be
	// using them.
	return array_values(array_merge($legacy_results, $modern_results));
	}

	protected function willFilterPage(array $hunks) {
	$changesets = mpull($this->changesets, null, 'getID');
	foreach ($hunks as $key => $hunk) {
	$changeset = idx($changesets, $hunk->getChangesetID());
	if (!$changeset) {
	unset($hunks[$key]);
	}
	$hunk->attachChangeset($changeset);
	}

	return $hunks;
	}

	protected function didFilterPage(array $hunks) {
	if ($this->shouldAttachToChangesets) {
	$hunk_groups = mgroup($hunks, 'getChangesetID');
	foreach ($this->changesets as $changeset) {
	$hunks = idx($hunk_groups, $changeset->getID(), array());
	$changeset->attachHunks($hunks);
	}
	}

	return $hunks;
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

	if (!$this->changesets) {
	throw new Exception(
	pht('You must load hunks via changesets, with withChangesets()!'));
	}

	$where[] = qsprintf(
	$conn_r,
	'changesetID IN (%Ld)',
	mpull($this->changesets, 'getID'));

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

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

	- protected function getReversePaging() {
	- return true;
	+ protected function getDefaultOrderVector() {
	+ // TODO: Do we need this?
	+ return array('-id');
	}

	}
	diff --git a/src/applications/ponder/query/PonderAnswerQuery.php b/src/applications/ponder/query/PonderAnswerQuery.php
	index cea74d55d5..1b5c66a10c 100644
	--- a/src/applications/ponder/query/PonderAnswerQuery.php
	+++ b/src/applications/ponder/query/PonderAnswerQuery.php
	@@ -1,129 +1,125 @@
	<?php

	final class PonderAnswerQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $authorPHIDs;
	private $questionIDs;

	private $needViewerVotes;


	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

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

	public function withAuthorPHIDs(array $phids) {
	$this->authorPHIDs = $phids;
	return $this;
	}

	public function withQuestionIDs(array $ids) {
	$this->questionIDs = $ids;
	return $this;
	}

	public function needViewerVotes($need_viewer_votes) {
	$this->needViewerVotes = $need_viewer_votes;
	return $this;
	}

	private function buildWhereClause($conn_r) {
	$where = array();

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

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

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

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

	protected function loadPage() {
	$answer = new PonderAnswer();
	$conn_r = $answer->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT a.* FROM %T a %Q %Q %Q',
	$answer->getTableName(),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

	return $answer->loadAllFromArray($data);
	}

	protected function willFilterPage(array $answers) {
	$questions = id(new PonderQuestionQuery())
	->setViewer($this->getViewer())
	->withIDs(mpull($answers, 'getQuestionID'))
	->execute();

	foreach ($answers as $key => $answer) {
	$question = idx($questions, $answer->getQuestionID());
	if (!$question) {
	unset($answers[$key]);
	continue;
	}
	$answer->attachQuestion($question);
	}

	if ($this->needViewerVotes) {
	$viewer_phid = $this->getViewer()->getPHID();

	$etype = PonderAnswerHasVotingUserEdgeType::EDGECONST;
	$edges = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(mpull($answers, 'getPHID'))
	->withDestinationPHIDs(array($viewer_phid))
	->withEdgeTypes(array($etype))
	->needEdgeData(true)
	->execute();
	foreach ($answers as $answer) {
	$user_edge = idx(
	$edges[$answer->getPHID()][$etype],
	$viewer_phid,
	array());

	$answer->attachUserVote($viewer_phid, idx($user_edge, 'data', 0));
	}
	}

	return $answers;
	}

	- protected function getReversePaging() {
	- return true;
	- }
	-
	public function getQueryApplicationClass() {
	return 'PhabricatorPonderApplication';
	}

	}
	diff --git a/src/applications/ponder/query/PonderQuestionQuery.php b/src/applications/ponder/query/PonderQuestionQuery.php
	index 2b5bda369d..bd387b62f9 100644
	--- a/src/applications/ponder/query/PonderQuestionQuery.php
	+++ b/src/applications/ponder/query/PonderQuestionQuery.php
	@@ -1,201 +1,202 @@
	<?php

	final class PonderQuestionQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	const ORDER_CREATED = 'order-created';
	const ORDER_HOTTEST = 'order-hottest';

	private $ids;
	private $phids;
	private $authorPHIDs;
	private $answererPHIDs;
	private $order = self::ORDER_CREATED;

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';

	private $needAnswers;
	private $needViewerVotes;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

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

	public function withAuthorPHIDs(array $phids) {
	$this->authorPHIDs = $phids;
	return $this;
	}

	public function withStatus($status) {
	$this->status = $status;
	return $this;
	}

	public function withAnswererPHIDs(array $phids) {
	$this->answererPHIDs = $phids;
	return $this;
	}

	public function needAnswers($need_answers) {
	$this->needAnswers = $need_answers;
	return $this;
	}

	public function needViewerVotes($need_viewer_votes) {
	$this->needViewerVotes = $need_viewer_votes;
	return $this;
	}

	public function setOrder($order) {
	$this->order = $order;
	return $this;
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

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

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

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

	if ($this->status) {
	switch ($this->status) {
	case self::STATUS_ANY:
	break;
	case self::STATUS_OPEN:
	$where[] = qsprintf(
	$conn_r,
	'q.status = %d',
	PonderQuestionStatus::STATUS_OPEN);
	break;
	case self::STATUS_CLOSED:
	$where[] = qsprintf(
	$conn_r,
	'q.status = %d',
	PonderQuestionStatus::STATUS_CLOSED);
	break;
	default:
	throw new Exception("Unknown status query '{$this->status}'!");
	}
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}

	private function buildOrderByClause(AphrontDatabaseConnection $conn_r) {
	switch ($this->order) {
	case self::ORDER_HOTTEST:
	return qsprintf($conn_r, 'ORDER BY q.heat DESC, q.id DESC');
	case self::ORDER_CREATED:
	return qsprintf($conn_r, 'ORDER BY q.id DESC');
	default:
	throw new Exception("Unknown order '{$this->order}'!");
	}
	}

	protected function loadPage() {
	$question = new PonderQuestion();
	$conn_r = $question->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT q.* FROM %T q %Q %Q %Q %Q',
	$question->getTableName(),
	$this->buildJoinsClause($conn_r),
	$this->buildWhereClause($conn_r),
	$this->buildOrderByClause($conn_r),
	$this->buildLimitClause($conn_r));

	return $question->loadAllFromArray($data);
	}

	protected function willFilterPage(array $questions) {
	if ($this->needAnswers) {
	$aquery = id(new PonderAnswerQuery())
	->setViewer($this->getViewer())
	+ ->setOrderVector(array('-id'))
	->withQuestionIDs(mpull($questions, 'getID'));

	if ($this->needViewerVotes) {
	$aquery->needViewerVotes($this->needViewerVotes);
	}

	$answers = $aquery->execute();
	$answers = mgroup($answers, 'getQuestionID');

	foreach ($questions as $question) {
	$question_answers = idx($answers, $question->getID(), array());
	$question->attachAnswers(mpull($question_answers, null, 'getPHID'));
	}
	}

	if ($this->needViewerVotes) {
	$viewer_phid = $this->getViewer()->getPHID();

	$etype = PonderQuestionHasVotingUserEdgeType::EDGECONST;
	$edges = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(mpull($questions, 'getPHID'))
	->withDestinationPHIDs(array($viewer_phid))
	->withEdgeTypes(array($etype))
	->needEdgeData(true)
	->execute();
	foreach ($questions as $question) {
	$user_edge = idx(
	$edges[$question->getPHID()][$etype],
	$viewer_phid,
	array());

	$question->attachUserVote($viewer_phid, idx($user_edge, 'data', 0));
	}
	}

	return $questions;
	}

	private function buildJoinsClause(AphrontDatabaseConnection $conn_r) {
	$joins = array();

	if ($this->answererPHIDs) {
	$answer_table = new PonderAnswer();
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T a ON a.questionID = q.id AND a.authorPHID IN (%Ls)',
	$answer_table->getTableName(),
	$this->answererPHIDs);
	}

	return implode(' ', $joins);
	}

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

	}
	diff --git a/src/applications/repository/query/PhabricatorRepositoryQuery.php b/src/applications/repository/query/PhabricatorRepositoryQuery.php
	index 7e74261cbf..05d5bba58a 100644
	--- a/src/applications/repository/query/PhabricatorRepositoryQuery.php
	+++ b/src/applications/repository/query/PhabricatorRepositoryQuery.php
	@@ -1,539 +1,539 @@
	<?php

	final class PhabricatorRepositoryQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $callsigns;
	private $types;
	private $uuids;
	private $nameContains;
	private $remoteURIs;
	private $anyProjectPHIDs;

	private $numericIdentifiers;
	private $callsignIdentifiers;
	private $phidIdentifiers;

	private $identifierMap;

	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_ALL = 'status-all';
	private $status = self::STATUS_ALL;

	const ORDER_CREATED = 'order-created';
	const ORDER_COMMITTED = 'order-committed';
	const ORDER_CALLSIGN = 'order-callsign';
	const ORDER_NAME = 'order-name';
	const ORDER_SIZE = 'order-size';

	const HOSTED_PHABRICATOR = 'hosted-phab';
	const HOSTED_REMOTE = 'hosted-remote';
	const HOSTED_ALL = 'hosted-all';
	private $hosted = self::HOSTED_ALL;

	private $needMostRecentCommits;
	private $needCommitCounts;
	private $needProjectPHIDs;

	public function withIDs(array $ids) {
	$this->ids = $ids;
	return $this;
	}

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

	public function withCallsigns(array $callsigns) {
	$this->callsigns = $callsigns;
	return $this;
	}

	public function withIdentifiers(array $identifiers) {
	$ids = array(); $callsigns = array(); $phids = array();
	foreach ($identifiers as $identifier) {
	if (ctype_digit($identifier)) {
	$ids[$identifier] = $identifier;
	} else {
	$repository_type = PhabricatorRepositoryRepositoryPHIDType::TYPECONST;
	if (phid_get_type($identifier) === $repository_type) {
	$phids[$identifier] = $identifier;
	} else {
	$callsigns[$identifier] = $identifier;
	}
	}
	}

	$this->numericIdentifiers = $ids;
	$this->callsignIdentifiers = $callsigns;
	$this->phidIdentifiers = $phids;
	return $this;
	}

	public function withStatus($status) {
	$this->status = $status;
	return $this;
	}

	public function withHosted($hosted) {
	$this->hosted = $hosted;
	return $this;
	}

	public function withTypes(array $types) {
	$this->types = $types;
	return $this;
	}

	public function withUUIDs(array $uuids) {
	$this->uuids = $uuids;
	return $this;
	}

	public function withNameContains($contains) {
	$this->nameContains = $contains;
	return $this;
	}

	public function withRemoteURIs(array $uris) {
	$this->remoteURIs = $uris;
	return $this;
	}

	public function withAnyProjects(array $projects) {
	$this->anyProjectPHIDs = $projects;
	return $this;
	}

	public function needCommitCounts($need_counts) {
	$this->needCommitCounts = $need_counts;
	return $this;
	}

	public function needMostRecentCommits($need_commits) {
	$this->needMostRecentCommits = $need_commits;
	return $this;
	}

	public function needProjectPHIDs($need_phids) {
	$this->needProjectPHIDs = $need_phids;
	return $this;
	}

	public function setOrder($order) {
	switch ($order) {
	case self::ORDER_CREATED:
	$this->setOrderVector(array('id'));
	break;
	case self::ORDER_COMMITTED:
	$this->setOrderVector(array('committed', 'id'));
	break;
	case self::ORDER_CALLSIGN:
	$this->setOrderVector(array('callsign'));
	break;
	case self::ORDER_NAME:
	$this->setOrderVector(array('name', 'id'));
	break;
	case self::ORDER_SIZE:
	$this->setOrderVector(array('size', 'id'));
	break;
	default:
	throw new Exception(pht('Unknown order "%s".', $order));
	}
	return $this;
	}

	public function getIdentifierMap() {
	if ($this->identifierMap === null) {
	throw new Exception(
	'You must execute() the query before accessing the identifier map.');
	}
	return $this->identifierMap;
	}

	protected function willExecute() {
	$this->identifierMap = array();
	}

	protected function loadPage() {
	$table = new PhabricatorRepository();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T r %Q %Q %Q %Q',
	$table->getTableName(),
	$this->buildJoinsClause($conn_r),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

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

	if ($this->needCommitCounts) {
	$sizes = ipull($data, 'size', 'id');
	foreach ($repositories as $id => $repository) {
	$repository->attachCommitCount(nonempty($sizes[$id], 0));
	}
	}

	if ($this->needMostRecentCommits) {
	$commit_ids = ipull($data, 'lastCommitID', 'id');
	$commit_ids = array_filter($commit_ids);
	if ($commit_ids) {
	$commits = id(new DiffusionCommitQuery())
	->setViewer($this->getViewer())
	->withIDs($commit_ids)
	->execute();
	} else {
	$commits = array();
	}
	foreach ($repositories as $id => $repository) {
	$commit = null;
	if (idx($commit_ids, $id)) {
	$commit = idx($commits, $commit_ids[$id]);
	}
	$repository->attachMostRecentCommit($commit);
	}
	}

	return $repositories;
	}

	protected function willFilterPage(array $repositories) {
	assert_instances_of($repositories, 'PhabricatorRepository');

	// TODO: Denormalize repository status into the PhabricatorRepository
	// table so we can do this filtering in the database.
	foreach ($repositories as $key => $repo) {
	$status = $this->status;
	switch ($status) {
	case self::STATUS_OPEN:
	if (!$repo->isTracked()) {
	unset($repositories[$key]);
	}
	break;
	case self::STATUS_CLOSED:
	if ($repo->isTracked()) {
	unset($repositories[$key]);
	}
	break;
	case self::STATUS_ALL:
	break;
	default:
	throw new Exception("Unknown status '{$status}'!");
	}

	// TODO: This should also be denormalized.
	$hosted = $this->hosted;
	switch ($hosted) {
	case self::HOSTED_PHABRICATOR:
	if (!$repo->isHosted()) {
	unset($repositories[$key]);
	}
	break;
	case self::HOSTED_REMOTE:
	if ($repo->isHosted()) {
	unset($repositories[$key]);
	}
	break;
	case self::HOSTED_ALL:
	break;
	default:
	throw new Exception("Uknown hosted failed '${hosted}'!");
	}
	}

	// TODO: Denormalize this, too.
	if ($this->remoteURIs) {
	$try_uris = $this->getNormalizedPaths();
	$try_uris = array_fuse($try_uris);
	foreach ($repositories as $key => $repository) {
	if (!isset($try_uris[$repository->getNormalizedPath()])) {
	unset($repositories[$key]);
	}
	}
	}

	// Build the identifierMap
	if ($this->numericIdentifiers) {
	foreach ($this->numericIdentifiers as $id) {
	if (isset($repositories[$id])) {
	$this->identifierMap[$id] = $repositories[$id];
	}
	}
	}

	if ($this->callsignIdentifiers) {
	$repository_callsigns = mpull($repositories, null, 'getCallsign');

	foreach ($this->callsignIdentifiers as $callsign) {
	if (isset($repository_callsigns[$callsign])) {
	$this->identifierMap[$callsign] = $repository_callsigns[$callsign];
	}
	}
	}

	if ($this->phidIdentifiers) {
	$repository_phids = mpull($repositories, null, 'getPHID');

	foreach ($this->phidIdentifiers as $phid) {
	if (isset($repository_phids[$phid])) {
	$this->identifierMap[$phid] = $repository_phids[$phid];
	}
	}
	}

	return $repositories;
	}

	protected function didFilterPage(array $repositories) {
	if ($this->needProjectPHIDs) {
	$type_project = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;

	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs(mpull($repositories, 'getPHID'))
	->withEdgeTypes(array($type_project));
	$edge_query->execute();

	foreach ($repositories as $repository) {
	$project_phids = $edge_query->getDestinationPHIDs(
	array(
	$repository->getPHID(),
	));
	$repository->attachProjectPHIDs($project_phids);
	}
	}

	return $repositories;
	}

	- public function getPrimaryTableAlias() {
	+ protected function getPrimaryTableAlias() {
	return 'r';
	}

	public function getOrderableColumns() {
	return parent::getOrderableColumns() + array(
	'committed' => array(
	'table' => 's',
	'column' => 'epoch',
	'type' => 'int',
	'null' => 'tail',
	),
	'callsign' => array(
	'table' => 'r',
	'column' => 'callsign',
	'type' => 'string',
	'unique' => true,
	'reverse' => true,
	),
	'name' => array(
	'table' => 'r',
	'column' => 'name',
	'type' => 'string',
	'reverse' => true,
	),
	'size' => array(
	'table' => 's',
	'column' => 'size',
	'type' => 'int',
	'null' => 'tail',
	),
	);
	}

	protected function willExecuteCursorQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query) {
	$vector = $this->getOrderVector();

	if ($vector->containsKey('committed')) {
	$query->needMostRecentCommits(true);
	}

	if ($vector->containsKey('size')) {
	$query->needCommitCounts(true);
	}
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$repository = $this->loadCursorObject($cursor);

	$map = array(
	'id' => $repository->getID(),
	'callsign' => $repository->getCallsign(),
	'name' => $repository->getName(),
	);

	foreach ($keys as $key) {
	switch ($key) {
	case 'committed':
	$commit = $repository->getMostRecentCommit();
	if ($commit) {
	$map[$key] = $commit->getEpoch();
	} else {
	$map[$key] = null;
	}
	break;
	case 'size':
	$count = $repository->getCommitCount();
	if ($count) {
	$map[$key] = $count;
	} else {
	$map[$key] = null;
	}
	break;
	}
	}

	return $map;
	}

	private function buildJoinsClause(AphrontDatabaseConnection $conn_r) {
	$joins = array();

	$join_summary_table = $this->needCommitCounts \|\|
	$this->needMostRecentCommits;

	$vector = $this->getOrderVector();
	if ($vector->containsKey('committed') \|\|
	$vector->containsKey('size')) {
	$join_summary_table = true;
	}

	if ($join_summary_table) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T s ON r.id = s.repositoryID',
	PhabricatorRepository::TABLE_SUMMARY);
	}

	if ($this->anyProjectPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN edge e ON e.src = r.phid');
	}

	return implode(' ', $joins);
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

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

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

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

	if ($this->numericIdentifiers \|\|
	$this->callsignIdentifiers \|\|
	$this->phidIdentifiers) {
	$identifier_clause = array();

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

	if ($this->callsignIdentifiers) {
	$identifier_clause[] = qsprintf(
	$conn_r,
	'r.callsign IN (%Ls)',
	$this->callsignIdentifiers);
	}

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

	$where = array('('.implode(' OR ', $identifier_clause).')');
	}

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

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

	if (strlen($this->nameContains)) {
	$where[] = qsprintf(
	$conn_r,
	'name LIKE %~',
	$this->nameContains);
	}

	if ($this->anyProjectPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'e.dst IN (%Ls)',
	$this->anyProjectPHIDs);
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}



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

	private function getNormalizedPaths() {
	$normalized_uris = array();

	// Since we don't know which type of repository this URI is in the general
	// case, just generate all the normalizations. We could refine this in some
	// cases: if the query specifies VCS types, or the URI is a git-style URI
	// or an `svn+ssh` URI, we could deduce how to normalize it. However, this
	// would be more complicated and it's not clear if it matters in practice.

	foreach ($this->remoteURIs as $uri) {
	$normalized_uris[] = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_GIT,
	$uri);
	$normalized_uris[] = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_SVN,
	$uri);
	$normalized_uris[] = new PhabricatorRepositoryURINormalizer(
	PhabricatorRepositoryURINormalizer::TYPE_MERCURIAL,
	$uri);
	}

	return array_unique(mpull($normalized_uris, 'getNormalizedPath'));
	}

	}
	diff --git a/src/applications/transactions/query/PhabricatorApplicationTransactionQuery.php b/src/applications/transactions/query/PhabricatorApplicationTransactionQuery.php
	index 45dcbfd8cf..5da8411277 100644
	--- a/src/applications/transactions/query/PhabricatorApplicationTransactionQuery.php
	+++ b/src/applications/transactions/query/PhabricatorApplicationTransactionQuery.php
	@@ -1,201 +1,191 @@
	<?php

	abstract class PhabricatorApplicationTransactionQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $phids;
	private $objectPHIDs;
	private $authorPHIDs;
	private $transactionTypes;
	- private $reversePaging = true;

	private $needComments = true;
	private $needHandles = true;

	abstract public function getTemplateApplicationTransaction();

	protected function buildMoreWhereClauses(AphrontDatabaseConnection $conn_r) {
	return array();
	}

	- public function setReversePaging($bool) {
	- $this->reversePaging = $bool;
	- return $this;
	- }
	-
	- protected function getReversePaging() {
	- return $this->reversePaging;
	- }
	-
	public function withPHIDs(array $phids) {
	$this->phids = $phids;
	return $this;
	}

	public function withObjectPHIDs(array $object_phids) {
	$this->objectPHIDs = $object_phids;
	return $this;
	}

	public function withAuthorPHIDs(array $author_phids) {
	$this->authorPHIDs = $author_phids;
	return $this;
	}

	public function withTransactionTypes(array $transaction_types) {
	$this->transactionTypes = $transaction_types;
	return $this;
	}

	public function needComments($need) {
	$this->needComments = $need;
	return $this;
	}

	public function needHandles($need) {
	$this->needHandles = $need;
	return $this;
	}

	protected function loadPage() {
	$table = $this->getTemplateApplicationTransaction();
	$conn_r = $table->establishConnection('r');

	$data = queryfx_all(
	$conn_r,
	'SELECT * FROM %T x %Q %Q %Q',
	$table->getTableName(),
	$this->buildWhereClause($conn_r),
	$this->buildOrderClause($conn_r),
	$this->buildLimitClause($conn_r));

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

	foreach ($xactions as $xaction) {
	$xaction->attachViewer($this->getViewer());
	}

	if ($this->needComments) {
	$comment_phids = array_filter(mpull($xactions, 'getCommentPHID'));

	$comments = array();
	if ($comment_phids) {
	$comments =
	id(new PhabricatorApplicationTransactionTemplatedCommentQuery())
	->setTemplate($table->getApplicationTransactionCommentObject())
	->setViewer($this->getViewer())
	->withPHIDs($comment_phids)
	->execute();
	$comments = mpull($comments, null, 'getPHID');
	}

	foreach ($xactions as $xaction) {
	if ($xaction->getCommentPHID()) {
	$comment = idx($comments, $xaction->getCommentPHID());
	if ($comment) {
	$xaction->attachComment($comment);
	}
	}
	}
	} else {
	foreach ($xactions as $xaction) {
	$xaction->setCommentNotLoaded(true);
	}
	}

	return $xactions;
	}

	protected function willFilterPage(array $xactions) {
	$object_phids = array_keys(mpull($xactions, null, 'getObjectPHID'));

	$objects = id(new PhabricatorObjectQuery())
	->setViewer($this->getViewer())
	->setParentQuery($this)
	->withPHIDs($object_phids)
	->execute();

	foreach ($xactions as $key => $xaction) {
	$object_phid = $xaction->getObjectPHID();
	if (empty($objects[$object_phid])) {
	unset($xactions[$key]);
	continue;
	}
	$xaction->attachObject($objects[$object_phid]);
	}

	// NOTE: We have to do this after loading objects, because the objects
	// may help determine which handles are required (for example, in the case
	// of custom fields).

	if ($this->needHandles) {
	$phids = array();
	foreach ($xactions as $xaction) {
	$phids[$xaction->getPHID()] = $xaction->getRequiredHandlePHIDs();
	}
	$handles = array();
	$merged = array_mergev($phids);
	if ($merged) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->getViewer())
	->withPHIDs($merged)
	->execute();
	}
	foreach ($xactions as $xaction) {
	$xaction->setHandles(
	array_select_keys(
	$handles,
	$phids[$xaction->getPHID()]));
	}
	}

	return $xactions;
	}

	private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
	$where = array();

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

	if ($this->objectPHIDs) {
	$where[] = qsprintf(
	$conn_r,
	'objectPHID IN (%Ls)',
	$this->objectPHIDs);
	}

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

	if ($this->transactionTypes) {
	$where[] = qsprintf(
	$conn_r,
	'transactionType IN (%Ls)',
	$this->transactionTypes);
	}

	foreach ($this->buildMoreWhereClauses($conn_r) as $clause) {
	$where[] = $clause;
	}

	$where[] = $this->buildPagingClause($conn_r);

	return $this->formatWhereClause($where);
	}


	public function getQueryApplicationClass() {
	// TODO: Sort this out?
	return null;
	}

	}
	diff --git a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	index fdc8024ff2..b98648529b 100644
	--- a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	+++ b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	@@ -1,1036 +1,975 @@
	<?php

	/**
	* A query class which uses cursor-based paging. This paging is much more
	* performant than offset-based paging in the presence of policy filtering.
	*
	* @task appsearch Integration with ApplicationSearch
	* @task paging Paging
	* @task order Result Ordering
	*/
	abstract class PhabricatorCursorPagedPolicyAwareQuery
	extends PhabricatorPolicyAwareQuery {

	private $afterID;
	private $beforeID;
	private $applicationSearchConstraints = array();
	protected $applicationSearchOrders = array();
	private $internalPaging;
	private $orderVector;

	- protected function getPagingColumn() {
	- return 'id';
	- }
	-
	protected function getPagingValue($result) {
	if (!is_object($result)) {
	// This interface can't be typehinted and PHP gets really angry if we
	// call a method on a non-object, so add an explicit check here.
	throw new Exception(pht('Expected object, got "%s"!', gettype($result)));
	}
	return $result->getID();
	}

	- protected function getReversePaging() {
	- return false;
	- }
	-
	protected function nextPage(array $page) {
	// See getPagingViewer() for a description of this flag.
	$this->internalPaging = true;

	if ($this->beforeID) {
	$this->beforeID = $this->getPagingValue(last($page));
	} else {
	$this->afterID = $this->getPagingValue(last($page));
	}
	}

	final public function setAfterID($object_id) {
	$this->afterID = $object_id;
	return $this;
	}

	final protected function getAfterID() {
	return $this->afterID;
	}

	final public function setBeforeID($object_id) {
	$this->beforeID = $object_id;
	return $this;
	}

	final protected function getBeforeID() {
	return $this->beforeID;
	}


	/**
	* Get the viewer for making cursor paging queries.
	*
	* NOTE: You should ONLY use this viewer to load cursor objects while
	* building paging queries.
	*
	* Cursor paging can happen in two ways. First, the user can request a page
	* like `/stuff/?after=33`, which explicitly causes paging. Otherwise, we
	* can fall back to implicit paging if we filter some results out of a
	* result list because the user can't see them and need to go fetch some more
	* results to generate a large enough result list.
	*
	* In the first case, want to use the viewer's policies to load the object.
	* This prevents an attacker from figuring out information about an object
	* they can't see by executing queries like `/stuff/?after=33&order=name`,
	* which would otherwise give them a hint about the name of the object.
	* Generally, if a user can't see an object, they can't use it to page.
	*
	* In the second case, we need to load the object whether the user can see
	* it or not, because we need to examine new results. For example, if a user
	* loads `/stuff/` and we run a query for the first 100 items that they can
	* see, but the first 100 rows in the database aren't visible, we need to
	* be able to issue a query for the next 100 results. If we can't load the
	* cursor object, we'll fail or issue the same query over and over again.
	* So, generally, internal paging must bypass policy controls.
	*
	* This method returns the appropriate viewer, based on the context in which
	* the paging is occuring.
	*
	* @return PhabricatorUser Viewer for executing paging queries.
	*/
	final protected function getPagingViewer() {
	if ($this->internalPaging) {
	return PhabricatorUser::getOmnipotentUser();
	} else {
	return $this->getViewer();
	}
	}

	final protected function buildLimitClause(AphrontDatabaseConnection $conn_r) {
	if ($this->getRawResultLimit()) {
	return qsprintf($conn_r, 'LIMIT %d', $this->getRawResultLimit());
	} else {
	return '';
	}
	}

	final protected function didLoadResults(array $results) {
	if ($this->beforeID) {
	$results = array_reverse($results, $preserve_keys = true);
	}
	return $results;
	}

	final public function executeWithCursorPager(AphrontCursorPagerView $pager) {
	$this->setLimit($pager->getPageSize() + 1);

	if ($pager->getAfterID()) {
	$this->setAfterID($pager->getAfterID());
	} else if ($pager->getBeforeID()) {
	$this->setBeforeID($pager->getBeforeID());
	}

	$results = $this->execute();

	$sliced_results = $pager->sliceResults($results);

	if ($sliced_results) {
	if ($pager->getBeforeID() \|\| (count($results) > $pager->getPageSize())) {
	$pager->setNextPageID($this->getPagingValue(last($sliced_results)));
	}

	if ($pager->getAfterID() \|\|
	($pager->getBeforeID() && (count($results) > $pager->getPageSize()))) {
	$pager->setPrevPageID($this->getPagingValue(head($sliced_results)));
	}
	}

	return $sliced_results;
	}


	/**
	* Return the alias this query uses to identify the primary table.
	*
	* Some automatic query constructions may need to be qualified with a table
	* alias if the query performs joins which make column names ambiguous. If
	* this is the case, return the alias for the primary table the query
	* uses; generally the object table which has `id` and `phid` columns.
	*
	* @return string Alias for the primary table.
	*/
	protected function getPrimaryTableAlias() {
	return null;
	}

	protected function newResultObject() {
	return null;
	}


	/* -( Paging )------------------------------------------------------------- */


	protected function buildPagingClause(AphrontDatabaseConnection $conn) {
	$orderable = $this->getOrderableColumns();
	-
	- // TODO: Remove this once subqueries modernize.
	- if (!$orderable) {
	- if ($this->beforeID) {
	- return qsprintf(
	- $conn,
	- '%Q %Q %s',
	- $this->getPagingColumn(),
	- $this->getReversePaging() ? '<' : '>',
	- $this->beforeID);
	- } else if ($this->afterID) {
	- return qsprintf(
	- $conn,
	- '%Q %Q %s',
	- $this->getPagingColumn(),
	- $this->getReversePaging() ? '>' : '<',
	- $this->afterID);
	- } else {
	- return null;
	- }
	- }
	-
	$vector = $this->getOrderVector();

	if ($this->beforeID !== null) {
	$cursor = $this->beforeID;
	$reversed = true;
	} else if ($this->afterID !== null) {
	$cursor = $this->afterID;
	$reversed = false;
	} else {
	// No paging is being applied to this query so we do not need to
	// construct a paging clause.
	return '';
	}

	$keys = array();
	foreach ($vector as $order) {
	$keys[] = $order->getOrderKey();
	}

	$value_map = $this->getPagingValueMap($cursor, $keys);

	$columns = array();
	foreach ($vector as $order) {
	$key = $order->getOrderKey();

	if (!array_key_exists($key, $value_map)) {
	throw new Exception(
	pht(
	'Query "%s" failed to return a value from getPagingValueMap() '.
	'for column "%s".',
	get_class($this),
	$key));
	}

	$column = $orderable[$key];
	$column['value'] = $value_map[$key];

	$columns[] = $column;
	}

	return $this->buildPagingClauseFromMultipleColumns(
	$conn,
	$columns,
	array(
	'reversed' => $reversed,
	));
	}

	protected function getPagingValueMap($cursor, array $keys) {
	// TODO: This is a hack to make this work with existing classes for now.
	return array(
	'id' => $cursor,
	);
	}

	protected function loadCursorObject($cursor) {
	$query = newv(get_class($this), array())
	->setViewer($this->getPagingViewer())
	->withIDs(array((int)$cursor));

	$this->willExecuteCursorQuery($query);

	$object = $query->executeOne();
	if (!$object) {
	throw new Exception(
	pht(
	'Cursor "%s" does not identify a valid object.',
	$cursor));
	}

	return $object;
	}

	protected function willExecuteCursorQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query) {
	return;
	}


	/**
	* Simplifies the task of constructing a paging clause across multiple
	* columns. In the general case, this looks like:
	*
	* A > a OR (A = a AND B > b) OR (A = a AND B = b AND C > c)
	*
	* To build a clause, specify the name, type, and value of each column
	* to include:
	*
	* $this->buildPagingClauseFromMultipleColumns(
	* $conn_r,
	* array(
	* array(
	* 'table' => 't',
	* 'column' => 'title',
	* 'type' => 'string',
	* 'value' => $cursor->getTitle(),
	* 'reverse' => true,
	* ),
	* array(
	* 'table' => 't',
	* 'column' => 'id',
	* 'type' => 'int',
	* 'value' => $cursor->getID(),
	* ),
	* ),
	* array(
	* 'reversed' => $is_reversed,
	* ));
	*
	* This method will then return a composable clause for inclusion in WHERE.
	*
	* @param AphrontDatabaseConnection Connection query will execute on.
	* @param list<map> Column description dictionaries.
	* @param map Additional constuction options.
	* @return string Query clause.
	*/
	final protected function buildPagingClauseFromMultipleColumns(
	AphrontDatabaseConnection $conn,
	array $columns,
	array $options) {

	foreach ($columns as $column) {
	PhutilTypeSpec::checkMap(
	$column,
	array(
	'table' => 'optional string\|null',
	'column' => 'string',
	'value' => 'wild',
	'type' => 'string',
	'reverse' => 'optional bool',
	'unique' => 'optional bool',
	'null' => 'optional string\|null',
	));
	}

	PhutilTypeSpec::checkMap(
	$options,
	array(
	'reversed' => 'optional bool',
	));

	$is_query_reversed = idx($options, 'reversed', false);

	$clauses = array();
	$accumulated = array();
	$last_key = last_key($columns);
	foreach ($columns as $key => $column) {
	$type = $column['type'];

	$null = idx($column, 'null');
	if ($column['value'] === null) {
	if ($null) {
	$value = null;
	} else {
	throw new Exception(
	pht(
	'Column "%s" has null value, but does not specify a null '.
	'behavior.',
	$key));
	}
	} else {
	switch ($type) {
	case 'int':
	$value = qsprintf($conn, '%d', $column['value']);
	break;
	case 'float':
	$value = qsprintf($conn, '%f', $column['value']);
	break;
	case 'string':
	$value = qsprintf($conn, '%s', $column['value']);
	break;
	default:
	throw new Exception(
	pht(
	'Column "%s" has unknown column type "%s".',
	$column['column'],
	$type));
	}
	}

	$is_column_reversed = idx($column, 'reverse', false);
	$reverse = ($is_query_reversed xor $is_column_reversed);

	$clause = $accumulated;

	$table_name = idx($column, 'table');
	$column_name = $column['column'];
	if ($table_name !== null) {
	$field = qsprintf($conn, '%T.%T', $table_name, $column_name);
	} else {
	$field = qsprintf($conn, '%T', $column_name);
	}

	$parts = array();
	if ($null) {
	$can_page_if_null = ($null === 'head');
	$can_page_if_nonnull = ($null === 'tail');

	if ($reverse) {
	$can_page_if_null = !$can_page_if_null;
	$can_page_if_nonnull = !$can_page_if_nonnull;
	}

	$subclause = null;
	if ($can_page_if_null && $value === null) {
	$parts[] = qsprintf(
	$conn,
	'(%Q IS NOT NULL)',
	$field);
	} else if ($can_page_if_nonnull && $value !== null) {
	$parts[] = qsprintf(
	$conn,
	'(%Q IS NULL)',
	$field);
	}
	}

	if ($value !== null) {
	$parts[] = qsprintf(
	$conn,
	'%Q %Q %Q',
	$field,
	$reverse ? '>' : '<',
	$value);
	}

	if ($parts) {
	if (count($parts) > 1) {
	$clause[] = '('.implode(') OR (', $parts).')';
	} else {
	$clause[] = head($parts);
	}
	}

	if ($clause) {
	if (count($clause) > 1) {
	$clauses[] = '('.implode(') AND (', $clause).')';
	} else {
	$clauses[] = head($clause);
	}
	}

	if ($value === null) {
	$accumulated[] = qsprintf(
	$conn,
	'%Q IS NULL',
	$field);
	} else {
	$accumulated[] = qsprintf(
	$conn,
	'%Q = %Q',
	$field,
	$value);
	}
	}

	return '('.implode(') OR (', $clauses).')';
	}


	/* -( Result Ordering )---------------------------------------------------- */


	/**
	* @task order
	*/
	public function setOrderVector($vector) {
	$vector = PhabricatorQueryOrderVector::newFromVector($vector);

	$orderable = $this->getOrderableColumns();

	// Make sure that all the components identify valid columns.
	$unique = array();
	foreach ($vector as $order) {
	$key = $order->getOrderKey();
	if (empty($orderable[$key])) {
	$valid = implode(', ', array_keys($orderable));
	throw new Exception(
	pht(
	'This query ("%s") does not support sorting by order key "%s". '.
	'Supported orders are: %s.',
	get_class($this),
	$key,
	$valid));
	}

	$unique[$key] = idx($orderable[$key], 'unique', false);
	}

	// Make sure that the last column is unique so that this is a strong
	// ordering which can be used for paging.
	$last = last($unique);
	if ($last !== true) {
	throw new Exception(
	pht(
	'Order vector "%s" is invalid: the last column in an order must '.
	'be a column with unique values, but "%s" is not unique.',
	$vector->getAsString(),
	last_key($unique)));
	}

	// Make sure that other columns are not unique; an ordering like "id, name"
	// does not make sense because only "id" can ever have an effect.
	array_pop($unique);
	foreach ($unique as $key => $is_unique) {
	if ($is_unique) {
	throw new Exception(
	pht(
	'Order vector "%s" is invalid: only the last column in an order '.
	'may be unique, but "%s" is a unique column and not the last '.
	'column in the order.',
	$vector->getAsString(),
	$key));
	}
	}

	$this->orderVector = $vector;
	return $this;
	}


	/**
	* @task order
	*/
	protected function getOrderVector() {
	if (!$this->orderVector) {
	$vector = $this->getDefaultOrderVector();
	$vector = PhabricatorQueryOrderVector::newFromVector($vector);

	// We call setOrderVector() here to apply checks to the default vector.
	// This catches any errors in the implementation.
	$this->setOrderVector($vector);
	}

	return $this->orderVector;
	}


	/**
	* @task order
	*/
	protected function getDefaultOrderVector() {
	return array('id');
	}


	/**
	* @task order
	*/
	public function getOrderableColumns() {
	- // TODO: Remove this once all subclasses move off the old stuff.
	- if ($this->getPagingColumn() !== 'id') {
	- // This class has bad old custom logic around paging, so return nothing
	- // here. This deactivates the new order code.
	- return array();
	- }
	-
	$columns = array(
	'id' => array(
	'table' => $this->getPrimaryTableAlias(),
	'column' => 'id',
	'reverse' => false,
	'type' => 'int',
	'unique' => true,
	),
	);

	$object = $this->newResultObject();
	if ($object instanceof PhabricatorCustomFieldInterface) {
	$list = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	foreach ($list->getFields() as $field) {
	$index = $field->buildOrderIndex();
	if (!$index) {
	continue;
	}

	$key = $field->getFieldKey();
	$digest = $field->getFieldIndex();

	$full_key = 'custom:'.$key;
	$columns[$full_key] = array(
	'table' => 'appsearch_order_'.$digest,
	'column' => 'indexValue',
	'type' => $index->getIndexValueType(),
	'null' => 'tail',
	);
	}
	}

	return $columns;
	}


	/**
	* @task order
	*/
	final protected function buildOrderClause(AphrontDatabaseConnection $conn) {
	$orderable = $this->getOrderableColumns();
	-
	- // TODO: Remove this once all subclasses move off the old stuff. We'll
	- // only enter this block for code using older ordering mechanisms. New
	- // code should expose an orderable column list.
	- if (!$orderable) {
	- if ($this->beforeID) {
	- return qsprintf(
	- $conn,
	- 'ORDER BY %Q %Q',
	- $this->getPagingColumn(),
	- $this->getReversePaging() ? 'DESC' : 'ASC');
	- } else {
	- return qsprintf(
	- $conn,
	- 'ORDER BY %Q %Q',
	- $this->getPagingColumn(),
	- $this->getReversePaging() ? 'ASC' : 'DESC');
	- }
	- }
	-
	$vector = $this->getOrderVector();

	$parts = array();
	foreach ($vector as $order) {
	$part = $orderable[$order->getOrderKey()];
	if ($order->getIsReversed()) {
	$part['reverse'] = !idx($part, 'reverse', false);
	}
	$parts[] = $part;
	}

	return $this->formatOrderClause($conn, $parts);
	}


	/**
	* @task order
	*/
	protected function formatOrderClause(
	AphrontDatabaseConnection $conn,
	array $parts) {

	$is_query_reversed = false;
	- if ($this->getReversePaging()) {
	- $is_query_reversed = !$is_query_reversed;
	- }
	-
	if ($this->getBeforeID()) {
	$is_query_reversed = !$is_query_reversed;
	}

	$sql = array();
	foreach ($parts as $key => $part) {
	$is_column_reversed = !empty($part['reverse']);

	$descending = true;
	if ($is_query_reversed) {
	$descending = !$descending;
	}

	if ($is_column_reversed) {
	$descending = !$descending;
	}

	$table = idx($part, 'table');
	$column = $part['column'];

	if ($table !== null) {
	$field = qsprintf($conn, '%T.%T', $table, $column);
	} else {
	$field = qsprintf($conn, '%T', $column);
	}

	$null = idx($part, 'null');
	if ($null) {
	switch ($null) {
	case 'head':
	$null_field = qsprintf($conn, '(%Q IS NULL)', $field);
	break;
	case 'tail':
	$null_field = qsprintf($conn, '(%Q IS NOT NULL)', $field);
	break;
	default:
	throw new Exception(
	pht(
	'NULL value "%s" is invalid. Valid values are "head" and '.
	'"tail".',
	$null));
	}

	if ($descending) {
	$sql[] = qsprintf($conn, '%Q DESC', $null_field);
	} else {
	$sql[] = qsprintf($conn, '%Q ASC', $null_field);
	}
	}

	if ($descending) {
	$sql[] = qsprintf($conn, '%Q DESC', $field);
	} else {
	$sql[] = qsprintf($conn, '%Q ASC', $field);
	}
	}

	return qsprintf($conn, 'ORDER BY %Q', implode(', ', $sql));
	}


	/* -( Application Search )------------------------------------------------- */


	/**
	* Constrain the query with an ApplicationSearch index, requiring field values
	* contain at least one of the values in a set.
	*
	* This constraint can build the most common types of queries, like:
	*
	* - Find users with shirt sizes "X" or "XL".
	* - Find shoes with size "13".
	*
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param string\|list<string> One or more values to filter by.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchContainsConstraint(
	PhabricatorCustomFieldIndexStorage $index,
	$value) {

	$this->applicationSearchConstraints[] = array(
	'type' => $index->getIndexValueType(),
	'cond' => '=',
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'value' => $value,
	);

	return $this;
	}


	/**
	* Constrain the query with an ApplicationSearch index, requiring values
	* exist in a given range.
	*
	* This constraint is useful for expressing date ranges:
	*
	* - Find events between July 1st and July 7th.
	*
	* The ends of the range are inclusive, so a `$min` of `3` and a `$max` of
	* `5` will match fields with values `3`, `4`, or `5`. Providing `null` for
	* either end of the range will leave that end of the constraint open.
	*
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param int\|null Minimum permissible value, inclusive.
	* @param int\|null Maximum permissible value, inclusive.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchRangeConstraint(
	PhabricatorCustomFieldIndexStorage $index,
	$min,
	$max) {

	$index_type = $index->getIndexValueType();
	if ($index_type != 'int') {
	throw new Exception(
	pht(
	'Attempting to apply a range constraint to a field with index type '.
	'"%s", expected type "%s".',
	$index_type,
	'int'));
	}

	$this->applicationSearchConstraints[] = array(
	'type' => $index->getIndexValueType(),
	'cond' => 'range',
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'value' => array($min, $max),
	);

	return $this;
	}


	/**
	* Order the results by an ApplicationSearch index.
	*
	* @param PhabricatorCustomField Field to which the index belongs.
	* @param PhabricatorCustomFieldIndexStorage Table where the index is stored.
	* @param bool True to sort ascending.
	* @return this
	* @task appsearch
	*/
	public function withApplicationSearchOrder(
	PhabricatorCustomField $field,
	PhabricatorCustomFieldIndexStorage $index,
	$ascending) {

	$this->applicationSearchOrders[] = array(
	'key' => $field->getFieldKey(),
	'type' => $index->getIndexValueType(),
	'table' => $index->getTableName(),
	'index' => $index->getIndexKey(),
	'ascending' => $ascending,
	);

	return $this;
	}


	/**
	* Get the name of the query's primary object PHID column, for constructing
	* JOIN clauses. Normally (and by default) this is just `"phid"`, but it may
	* be something more exotic.
	*
	* See @{method:getPrimaryTableAlias} if the column needs to be qualified with
	* a table alias.
	*
	* @return string Column name.
	* @task appsearch
	*/
	protected function getApplicationSearchObjectPHIDColumn() {
	if ($this->getPrimaryTableAlias()) {
	$prefix = $this->getPrimaryTableAlias().'.';
	} else {
	$prefix = '';
	}

	return $prefix.'phid';
	}


	/**
	* Determine if the JOINs built by ApplicationSearch might cause each primary
	* object to return multiple result rows. Generally, this means the query
	* needs an extra GROUP BY clause.
	*
	* @return bool True if the query may return multiple rows for each object.
	* @task appsearch
	*/
	protected function getApplicationSearchMayJoinMultipleRows() {
	foreach ($this->applicationSearchConstraints as $constraint) {
	$type = $constraint['type'];
	$value = $constraint['value'];
	$cond = $constraint['cond'];

	switch ($cond) {
	case '=':
	switch ($type) {
	case 'string':
	case 'int':
	if (count((array)$value) > 1) {
	return true;
	}
	break;
	default:
	throw new Exception(pht('Unknown index type "%s"!', $type));
	}
	break;
	case 'range':
	// NOTE: It's possible to write a custom field where multiple rows
	// match a range constraint, but we don't currently ship any in the
	// upstream and I can't immediately come up with cases where this
	// would make sense.
	break;
	default:
	throw new Exception(pht('Unknown constraint condition "%s"!', $cond));
	}
	}

	return false;
	}


	/**
	* Construct a GROUP BY clause appropriate for ApplicationSearch constraints.
	*
	* @param AphrontDatabaseConnection Connection executing the query.
	* @return string Group clause.
	* @task appsearch
	*/
	protected function buildApplicationSearchGroupClause(
	AphrontDatabaseConnection $conn_r) {

	if ($this->getApplicationSearchMayJoinMultipleRows()) {
	return qsprintf(
	$conn_r,
	'GROUP BY %Q',
	$this->getApplicationSearchObjectPHIDColumn());
	} else {
	return '';
	}
	}


	/**
	* Construct a JOIN clause appropriate for applying ApplicationSearch
	* constraints.
	*
	* @param AphrontDatabaseConnection Connection executing the query.
	* @return string Join clause.
	* @task appsearch
	*/
	protected function buildApplicationSearchJoinClause(
	AphrontDatabaseConnection $conn_r) {

	$joins = array();
	foreach ($this->applicationSearchConstraints as $key => $constraint) {
	$table = $constraint['table'];
	$alias = 'appsearch_'.$key;
	$index = $constraint['index'];
	$cond = $constraint['cond'];
	$phid_column = $this->getApplicationSearchObjectPHIDColumn();
	switch ($cond) {
	case '=':
	$type = $constraint['type'];
	switch ($type) {
	case 'string':
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue IN (%Ls)',
	$alias,
	(array)$constraint['value']);
	break;
	case 'int':
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue IN (%Ld)',
	$alias,
	(array)$constraint['value']);
	break;
	default:
	throw new Exception(pht('Unknown index type "%s"!', $type));
	}

	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s
	AND (%Q)',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index,
	$constraint_clause);
	break;
	case 'range':
	list($min, $max) = $constraint['value'];
	if (($min === null) && ($max === null)) {
	// If there's no actual range constraint, just move on.
	break;
	}

	if ($min === null) {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue <= %d',
	$alias,
	$max);
	} else if ($max === null) {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue >= %d',
	$alias,
	$min);
	} else {
	$constraint_clause = qsprintf(
	$conn_r,
	'%T.indexValue BETWEEN %d AND %d',
	$alias,
	$min,
	$max);
	}

	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s
	AND (%Q)',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index,
	$constraint_clause);
	break;
	default:
	throw new Exception(pht('Unknown constraint condition "%s"!', $cond));
	}
	}

	foreach ($this->applicationSearchOrders as $key => $order) {
	$table = $order['table'];
	$index = $order['index'];
	$alias = 'appsearch_order_'.$index;
	$phid_column = $this->getApplicationSearchObjectPHIDColumn();

	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T %T ON %T.objectPHID = %Q
	AND %T.indexKey = %s',
	$table,
	$alias,
	$alias,
	$phid_column,
	$alias,
	$index);
	}

	return implode(' ', $joins);
	}

	protected function getPagingValueMapForCustomFields(
	PhabricatorCustomFieldInterface $object) {

	// We have to get the current field values on the cursor object.
	$fields = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	$fields->setViewer($this->getViewer());
	$fields->readFieldsFromStorage($object);

	$map = array();
	foreach ($fields->getFields() as $field) {
	$map['custom:'.$field->getFieldKey()] = $field->getValueForStorage();
	}

	return $map;
	}

	protected function isCustomFieldOrderKey($key) {
	$prefix = 'custom:';
	return !strncmp($key, $prefix, strlen($prefix));
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, May 1, 9:25 AM (1 d, 18 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 108938
Default Alt Text: (83 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions