No OneTemporary
Actions

Size

136 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/home/controller/PhabricatorHomeMainController.php b/src/applications/home/controller/PhabricatorHomeMainController.php
	index 6b78f2415c..7dcfb57c71 100644
	--- a/src/applications/home/controller/PhabricatorHomeMainController.php
	+++ b/src/applications/home/controller/PhabricatorHomeMainController.php
	@@ -1,423 +1,426 @@
	<?php

	final class PhabricatorHomeMainController extends PhabricatorHomeController {

	private $only;
	private $minipanels = array();

	public function shouldAllowPublic() {
	return true;
	}

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

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

	$dashboard = PhabricatorDashboardInstall::getDashboard(
	$user,
	$user->getPHID(),
	get_class($this->getCurrentApplication()));

	if (!$dashboard) {
	$dashboard = PhabricatorDashboardInstall::getDashboard(
	$user,
	PhabricatorHomeApplication::DASHBOARD_DEFAULT,
	get_class($this->getCurrentApplication()));
	}

	if ($dashboard) {
	$content = id(new PhabricatorDashboardRenderingEngine())
	->setViewer($user)
	->setDashboard($dashboard)
	->renderDashboard();
	} else {
	$project_query = new PhabricatorProjectQuery();
	$project_query->setViewer($user);
	$project_query->withMemberPHIDs(array($user->getPHID()));
	$projects = $project_query->execute();

	$content = $this->buildMainResponse($projects);
	}

	if (!$this->only) {
	$nav = $this->buildNav();
	$nav->appendChild(
	array(
	$content,
	id(new PhabricatorGlobalUploadTargetView())->setUser($user),
	));
	$content = $nav;
	}

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

	private function buildMainResponse(array $projects) {
	assert_instances_of($projects, 'PhabricatorProject');
	$viewer = $this->getRequest()->getUser();

	$has_maniphest = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorManiphestApplication',
	$viewer);

	$has_audit = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorAuditApplication',
	$viewer);

	$has_differential = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorDifferentialApplication',
	$viewer);

	if ($has_maniphest) {
	$unbreak_panel = $this->buildUnbreakNowPanel();
	$triage_panel = $this->buildNeedsTriagePanel($projects);
	$tasks_panel = $this->buildTasksPanel();
	} else {
	$unbreak_panel = null;
	$triage_panel = null;
	$tasks_panel = null;
	}

	if ($has_audit) {
	$audit_panel = $this->buildAuditPanel();
	$commit_panel = $this->buildCommitPanel();
	} else {
	$audit_panel = null;
	$commit_panel = null;
	}

	if (PhabricatorEnv::getEnvConfig('welcome.html') !== null) {
	$welcome_panel = $this->buildWelcomePanel();
	} else {
	$welcome_panel = null;
	}

	if ($has_differential) {
	$revision_panel = $this->buildRevisionPanel();
	} else {
	$revision_panel = null;
	}

	require_celerity_resource('homepage-panel-css');
	$home = phutil_tag(
	'div',
	array(
	'class' => 'homepage-panel',
	),
	array(
	$welcome_panel,
	$unbreak_panel,
	$triage_panel,
	$revision_panel,
	$tasks_panel,
	$audit_panel,
	$commit_panel,
	$this->minipanels,
	));
	return $home;
	}

	private function buildUnbreakNowPanel() {
	$unbreak_now = PhabricatorEnv::getEnvConfig(
	'maniphest.priorities.unbreak-now');
	if (!$unbreak_now) {
	return null;
	}

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

	$task_query = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withStatuses(ManiphestTaskStatus::getOpenStatusConstants())
	->withPriorities(array($unbreak_now))
	->needProjectPHIDs(true)
	->setLimit(10);

	$tasks = $task_query->execute();

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

	$href = urisprintf(
	'/maniphest/?statuses=%s&priorities=%s#R',
	implode(',', ManiphestTaskStatus::getOpenStatusConstants()),
	$unbreak_now);
	$title = pht('Unbreak Now!');
	$panel = new PHUIObjectBoxView();
	$panel->setHeader($this->renderSectionHeader($title, $href));
	$panel->appendChild($this->buildTaskListView($tasks));

	return $panel;
	}

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

	$needs_triage = PhabricatorEnv::getEnvConfig(
	'maniphest.priorities.needs-triage');
	if (!$needs_triage) {
	return null;
	}

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

	if ($projects) {
	$task_query = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withStatuses(ManiphestTaskStatus::getOpenStatusConstants())
	->withPriorities(array($needs_triage))
	- ->withAnyProjects(mpull($projects, 'getPHID'))
	+ ->withEdgeLogicPHIDs(
	+ PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	+ PhabricatorQueryConstraint::OPERATOR_OR,
	+ mpull($projects, 'getPHID'))
	->needProjectPHIDs(true)
	->setLimit(10);
	$tasks = $task_query->execute();
	} else {
	$tasks = array();
	}

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

	$title = pht('Needs Triage');
	$href = urisprintf(
	'/maniphest/?statuses=%s&priorities=%s&userProjects=%s#R',
	implode(',', ManiphestTaskStatus::getOpenStatusConstants()),
	$needs_triage,
	$user->getPHID());
	$panel = new PHUIObjectBoxView();
	$panel->setHeader($this->renderSectionHeader($title, $href));
	$panel->appendChild($this->buildTaskListView($tasks));

	return $panel;
	}

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

	$revision_query = id(new DifferentialRevisionQuery())
	->setViewer($user)
	->withStatus(DifferentialRevisionQuery::STATUS_OPEN)
	->withResponsibleUsers(array($user_phid))
	->needRelationships(true)
	->needFlags(true)
	->needDrafts(true);

	$revisions = $revision_query->execute();

	list($blocking, $active, ) = DifferentialRevisionQuery::splitResponsible(
	$revisions,
	array($user_phid));

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

	$title = pht('Revisions Waiting on You');
	$href = '/differential';
	$panel = new PHUIObjectBoxView();
	$panel->setHeader($this->renderSectionHeader($title, $href));

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

	$revision_view->setHandles($handles);

	$list_view = $revision_view->render();
	$list_view->setFlush(true);

	$panel->appendChild($list_view);

	return $panel;
	}

	private function buildWelcomePanel() {
	$panel = new PHUIObjectBoxView();
	$panel->setHeaderText(pht('Welcome'));
	$panel->appendChild(
	phutil_safe_html(
	PhabricatorEnv::getEnvConfig('welcome.html')));

	return $panel;
	}

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

	$task_query = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withStatuses(ManiphestTaskStatus::getOpenStatusConstants())
	->setGroupBy(ManiphestTaskQuery::GROUP_PRIORITY)
	->withOwners(array($user_phid))
	->needProjectPHIDs(true)
	->setLimit(10);

	$tasks = $task_query->execute();


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

	$title = pht('Assigned Tasks');
	$href = '/maniphest';
	$panel = new PHUIObjectBoxView();
	$panel->setHeader($this->renderSectionHeader($title, $href));
	$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 renderSectionHeader($title, $href) {
	$title = phutil_tag(
	'a',
	array(
	'href' => $href,
	),
	$title);
	$header = id(new PHUIHeaderView())
	->setHeader($title);
	return $header;
	}

	private function renderMiniPanel($title, $body) {
	$panel = new PHUIInfoView();
	$panel->setSeverity(PHUIInfoView::SEVERITY_NODATA);
	$panel->appendChild(
	phutil_tag(
	'p',
	array(
	),
	array(
	phutil_tag('strong', array(), $title.': '),
	$body,
	)));
	$this->minipanels[] = $panel;
	}

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

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

	$query = id(new DiffusionCommitQuery())
	->setViewer($user)
	->withAuditorPHIDs($phids)
	->withAuditStatus(DiffusionCommitQuery::AUDIT_STATUS_OPEN)
	->withAuditAwaitingUser($user)
	->needAuditRequests(true)
	->needCommitData(true)
	->setLimit(10);

	$commits = $query->execute();

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

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

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

	$title = pht('Audits');
	$href = '/audit/';
	$panel = new PHUIObjectBoxView();
	$panel->setHeader($this->renderSectionHeader($title, $href));
	$panel->appendChild($view);

	return $panel;
	}

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

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

	$query = id(new DiffusionCommitQuery())
	->setViewer($user)
	->withAuthorPHIDs($phids)
	->withAuditStatus(DiffusionCommitQuery::AUDIT_STATUS_CONCERN)
	->needCommitData(true)
	->needAuditRequests(true)
	->setLimit(10);

	$commits = $query->execute();

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

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

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

	$title = pht('Problem Commits');
	$href = '/audit/';
	$panel = new PHUIObjectBoxView();
	$panel->setHeader($this->renderSectionHeader($title, $href));
	$panel->appendChild($view);

	return $panel;
	}

	}
	diff --git a/src/applications/maniphest/conduit/ManiphestQueryConduitAPIMethod.php b/src/applications/maniphest/conduit/ManiphestQueryConduitAPIMethod.php
	index a8c687b36e..0dc26e58ab 100644
	--- a/src/applications/maniphest/conduit/ManiphestQueryConduitAPIMethod.php
	+++ b/src/applications/maniphest/conduit/ManiphestQueryConduitAPIMethod.php
	@@ -1,119 +1,122 @@
	<?php

	final class ManiphestQueryConduitAPIMethod extends ManiphestConduitAPIMethod {

	public function getAPIMethodName() {
	return 'maniphest.query';
	}

	public function getMethodDescription() {
	return 'Execute complex searches for Maniphest tasks.';
	}

	protected function defineParamTypes() {
	$statuses = array(
	ManiphestTaskQuery::STATUS_ANY,
	ManiphestTaskQuery::STATUS_OPEN,
	ManiphestTaskQuery::STATUS_CLOSED,
	ManiphestTaskQuery::STATUS_RESOLVED,
	ManiphestTaskQuery::STATUS_WONTFIX,
	ManiphestTaskQuery::STATUS_INVALID,
	ManiphestTaskQuery::STATUS_SPITE,
	ManiphestTaskQuery::STATUS_DUPLICATE,
	);
	$status_const = $this->formatStringConstants($statuses);

	$orders = array(
	ManiphestTaskQuery::ORDER_PRIORITY,
	ManiphestTaskQuery::ORDER_CREATED,
	ManiphestTaskQuery::ORDER_MODIFIED,
	);
	$order_const = $this->formatStringConstants($orders);

	return array(
	'ids' => 'optional list<uint>',
	'phids' => 'optional list<phid>',
	'ownerPHIDs' => 'optional list<phid>',
	'authorPHIDs' => 'optional list<phid>',
	'projectPHIDs' => 'optional list<phid>',
	'ccPHIDs' => 'optional list<phid>',
	'fullText' => 'optional string',

	'status' => 'optional '.$status_const,
	'order' => 'optional '.$order_const,

	'limit' => 'optional int',
	'offset' => 'optional int',
	);
	}

	protected function defineReturnType() {
	return 'list';
	}

	protected function execute(ConduitAPIRequest $request) {
	$query = id(new ManiphestTaskQuery())
	->setViewer($request->getUser())
	->needProjectPHIDs(true)
	->needSubscriberPHIDs(true);

	$task_ids = $request->getValue('ids');
	if ($task_ids) {
	$query->withIDs($task_ids);
	}

	$task_phids = $request->getValue('phids');
	if ($task_phids) {
	$query->withPHIDs($task_phids);
	}

	$owners = $request->getValue('ownerPHIDs');
	if ($owners) {
	$query->withOwners($owners);
	}

	$authors = $request->getValue('authorPHIDs');
	if ($authors) {
	$query->withAuthors($authors);
	}

	$projects = $request->getValue('projectPHIDs');
	if ($projects) {
	- $query->withAllProjects($projects);
	+ $query->withEdgeLogicPHIDs(
	+ PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	+ PhabricatorQueryConstraint::OPERATOR_AND,
	+ $projects);
	}

	$ccs = $request->getValue('ccPHIDs');
	if ($ccs) {
	$query->withSubscribers($ccs);
	}

	$full_text = $request->getValue('fullText');
	if ($full_text) {
	$query->withFullTextSearch($full_text);
	}

	$status = $request->getValue('status');
	if ($status) {
	$query->withStatus($status);
	}

	$order = $request->getValue('order');
	if ($order) {
	$query->setOrderBy($order);
	}

	$limit = $request->getValue('limit');
	if ($limit) {
	$query->setLimit($limit);
	}

	$offset = $request->getValue('offset');
	if ($offset) {
	$query->setOffset($offset);
	}

	$results = $query->execute();
	return $this->buildTaskInfoDictionaries($results);
	}

	}
	diff --git a/src/applications/maniphest/controller/ManiphestReportController.php b/src/applications/maniphest/controller/ManiphestReportController.php
	index f0b1c37110..e29697ab7e 100644
	--- a/src/applications/maniphest/controller/ManiphestReportController.php
	+++ b/src/applications/maniphest/controller/ManiphestReportController.php
	@@ -1,792 +1,795 @@
	<?php

	final class ManiphestReportController extends ManiphestController {

	private $view;

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

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

	if ($request->isFormPost()) {
	$uri = $request->getRequestURI();

	$project = head($request->getArr('set_project'));
	$project = nonempty($project, null);
	$uri = $uri->alter('project', $project);

	$window = $request->getStr('set_window');
	$uri = $uri->alter('window', $window);

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

	$nav = new AphrontSideNavFilterView();
	$nav->setBaseURI(new PhutilURI('/maniphest/report/'));
	$nav->addLabel(pht('Open Tasks'));
	$nav->addFilter('user', pht('By User'));
	$nav->addFilter('project', pht('By Project'));
	$nav->addLabel(pht('Burnup'));
	$nav->addFilter('burn', pht('Burnup Rate'));

	$this->view = $nav->selectFilter($this->view, 'user');

	require_celerity_resource('maniphest-report-css');

	switch ($this->view) {
	case 'burn':
	$core = $this->renderBurn();
	break;
	case 'user':
	case 'project':
	$core = $this->renderOpenTasks();
	break;
	default:
	return new Aphront404Response();
	}

	$nav->appendChild($core);
	$nav->setCrumbs(
	$this->buildApplicationCrumbs()
	->setBorder(true)
	->addTextCrumb(pht('Reports')));

	return $this->buildApplicationPage(
	$nav,
	array(
	'title' => pht('Maniphest Reports'),
	'device' => false,
	));
	}

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

	$handle = null;

	$project_phid = $request->getStr('project');
	if ($project_phid) {
	$phids = array($project_phid);
	$handles = $this->loadViewerHandles($phids);
	$handle = $handles[$project_phid];
	}

	$table = new ManiphestTransaction();
	$conn = $table->establishConnection('r');

	$joins = '';
	if ($project_phid) {
	$joins = qsprintf(
	$conn,
	'JOIN %T t ON x.objectPHID = t.phid
	JOIN %T p ON p.src = t.phid AND p.type = %d AND p.dst = %s',
	id(new ManiphestTask())->getTableName(),
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	$project_phid);
	}

	$data = queryfx_all(
	$conn,
	'SELECT x.oldValue, x.newValue, x.dateCreated FROM %T x %Q
	WHERE transactionType = %s
	ORDER BY x.dateCreated ASC',
	$table->getTableName(),
	$joins,
	ManiphestTransaction::TYPE_STATUS);

	$stats = array();
	$day_buckets = array();

	$open_tasks = array();

	foreach ($data as $key => $row) {

	// NOTE: Hack to avoid json_decode().
	$oldv = trim($row['oldValue'], '"');
	$newv = trim($row['newValue'], '"');

	if ($oldv == 'null') {
	$old_is_open = false;
	} else {
	$old_is_open = ManiphestTaskStatus::isOpenStatus($oldv);
	}

	$new_is_open = ManiphestTaskStatus::isOpenStatus($newv);

	$is_open = ($new_is_open && !$old_is_open);
	$is_close = ($old_is_open && !$new_is_open);

	$data[$key]['_is_open'] = $is_open;
	$data[$key]['_is_close'] = $is_close;

	if (!$is_open && !$is_close) {
	// This is either some kind of bogus event, or a resolution change
	// (e.g., resolved -> invalid). Just skip it.
	continue;
	}

	$day_bucket = phabricator_format_local_time(
	$row['dateCreated'],
	$user,
	'Yz');
	$day_buckets[$day_bucket] = $row['dateCreated'];
	if (empty($stats[$day_bucket])) {
	$stats[$day_bucket] = array(
	'open' => 0,
	'close' => 0,
	);
	}
	$stats[$day_bucket][$is_close ? 'close' : 'open']++;
	}

	$template = array(
	'open' => 0,
	'close' => 0,
	);

	$rows = array();
	$rowc = array();
	$last_month = null;
	$last_month_epoch = null;
	$last_week = null;
	$last_week_epoch = null;
	$week = null;
	$month = null;

	$last = last_key($stats) - 1;
	$period = $template;

	foreach ($stats as $bucket => $info) {
	$epoch = $day_buckets[$bucket];

	$week_bucket = phabricator_format_local_time(
	$epoch,
	$user,
	'YW');
	if ($week_bucket != $last_week) {
	if ($week) {
	$rows[] = $this->formatBurnRow(
	'Week of '.phabricator_date($last_week_epoch, $user),
	$week);
	$rowc[] = 'week';
	}
	$week = $template;
	$last_week = $week_bucket;
	$last_week_epoch = $epoch;
	}

	$month_bucket = phabricator_format_local_time(
	$epoch,
	$user,
	'Ym');
	if ($month_bucket != $last_month) {
	if ($month) {
	$rows[] = $this->formatBurnRow(
	phabricator_format_local_time($last_month_epoch, $user, 'F, Y'),
	$month);
	$rowc[] = 'month';
	}
	$month = $template;
	$last_month = $month_bucket;
	$last_month_epoch = $epoch;
	}

	$rows[] = $this->formatBurnRow(phabricator_date($epoch, $user), $info);
	$rowc[] = null;
	$week['open'] += $info['open'];
	$week['close'] += $info['close'];
	$month['open'] += $info['open'];
	$month['close'] += $info['close'];
	$period['open'] += $info['open'];
	$period['close'] += $info['close'];
	}

	if ($week) {
	$rows[] = $this->formatBurnRow(
	pht('Week To Date'),
	$week);
	$rowc[] = 'week';
	}

	if ($month) {
	$rows[] = $this->formatBurnRow(
	pht('Month To Date'),
	$month);
	$rowc[] = 'month';
	}

	$rows[] = $this->formatBurnRow(
	pht('All Time'),
	$period);
	$rowc[] = 'aggregate';

	$rows = array_reverse($rows);
	$rowc = array_reverse($rowc);

	$table = new AphrontTableView($rows);
	$table->setRowClasses($rowc);
	$table->setHeaders(
	array(
	pht('Period'),
	pht('Opened'),
	pht('Closed'),
	pht('Change'),
	));
	$table->setColumnClasses(
	array(
	'right wide',
	'n',
	'n',
	'n',
	));

	if ($handle) {
	$inst = pht(
	'NOTE: This table reflects tasks currently in '.
	'the project. If a task was opened in the past but added to '.
	'the project recently, it is counted on the day it was '.
	'opened, not the day it was categorized. If a task was part '.
	'of this project in the past but no longer is, it is not '.
	'counted at all.');
	$header = pht('Task Burn Rate for Project %s', $handle->renderLink());
	$caption = phutil_tag('p', array(), $inst);
	} else {
	$header = pht('Task Burn Rate for All Tasks');
	$caption = null;
	}

	if ($caption) {
	$caption = id(new PHUIInfoView())
	->appendChild($caption)
	->setSeverity(PHUIInfoView::SEVERITY_NOTICE);
	}

	$panel = new PHUIObjectBoxView();
	$panel->setHeaderText($header);
	if ($caption) {
	$panel->setInfoView($caption);
	}
	$panel->appendChild($table);

	$tokens = array();
	if ($handle) {
	$tokens = array($handle);
	}

	$filter = $this->renderReportFilters($tokens, $has_window = false);

	$id = celerity_generate_unique_node_id();
	$chart = phutil_tag(
	'div',
	array(
	'id' => $id,
	'style' => 'border: 1px solid #BFCFDA; '.
	'background-color: #fff; '.
	'margin: 8px 16px; '.
	'height: 400px; ',
	),
	'');

	list($burn_x, $burn_y) = $this->buildSeries($data);

	require_celerity_resource('raphael-core');
	require_celerity_resource('raphael-g');
	require_celerity_resource('raphael-g-line');

	Javelin::initBehavior('line-chart', array(
	'hardpoint' => $id,
	'x' => array(
	$burn_x,
	),
	'y' => array(
	$burn_y,
	),
	'xformat' => 'epoch',
	'yformat' => 'int',
	));

	return array($filter, $chart, $panel);
	}

	private function renderReportFilters(array $tokens, $has_window) {
	$request = $this->getRequest();
	$user = $request->getUser();

	$form = id(new AphrontFormView())
	->setUser($user)
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorProjectDatasource())
	->setLabel(pht('Project'))
	->setLimit(1)
	->setName('set_project')
	// TODO: This is silly, but this is Maniphest reports.
	->setValue(mpull($tokens, 'getPHID')));

	if ($has_window) {
	list($window_str, $ignored, $window_error) = $this->getWindow();
	$form
	->appendChild(
	id(new AphrontFormTextControl())
	->setLabel(pht('Recently Means'))
	->setName('set_window')
	->setCaption(
	pht('Configure the cutoff for the "Recently Closed" column.'))
	->setValue($window_str)
	->setError($window_error));
	}

	$form
	->appendChild(
	id(new AphrontFormSubmitControl())
	->setValue(pht('Filter By Project')));

	$filter = new AphrontListFilterView();
	$filter->appendChild($form);

	return $filter;
	}

	private function buildSeries(array $data) {
	$out = array();

	$counter = 0;
	foreach ($data as $row) {
	$t = (int)$row['dateCreated'];
	if ($row['_is_close']) {
	--$counter;
	$out[$t] = $counter;
	} else if ($row['_is_open']) {
	++$counter;
	$out[$t] = $counter;
	}
	}

	return array(array_keys($out), array_values($out));
	}

	private function formatBurnRow($label, $info) {
	$delta = $info['open'] - $info['close'];
	$fmt = number_format($delta);
	if ($delta > 0) {
	$fmt = '+'.$fmt;
	$fmt = phutil_tag('span', array('class' => 'red'), $fmt);
	} else {
	$fmt = phutil_tag('span', array('class' => 'green'), $fmt);
	}

	return array(
	$label,
	number_format($info['open']),
	number_format($info['close']),
	$fmt,
	);
	}

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


	$query = id(new ManiphestTaskQuery())
	->setViewer($user)
	->withStatuses(ManiphestTaskStatus::getOpenStatusConstants());

	switch ($this->view) {
	case 'project':
	$query->needProjectPHIDs(true);
	break;
	}

	$project_phid = $request->getStr('project');
	$project_handle = null;
	if ($project_phid) {
	$phids = array($project_phid);
	$handles = $this->loadViewerHandles($phids);
	$project_handle = $handles[$project_phid];

	- $query->withAnyProjects($phids);
	+ $query->withEdgeLogicPHIDs(
	+ PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	+ PhabricatorQueryConstraint::OPERATOR_OR,
	+ $phids);
	}

	$tasks = $query->execute();

	$recently_closed = $this->loadRecentlyClosedTasks();

	$date = phabricator_date(time(), $user);

	switch ($this->view) {
	case 'user':
	$result = mgroup($tasks, 'getOwnerPHID');
	$leftover = idx($result, '', array());
	unset($result['']);

	$result_closed = mgroup($recently_closed, 'getOwnerPHID');
	$leftover_closed = idx($result_closed, '', array());
	unset($result_closed['']);

	$base_link = '/maniphest/?assigned=';
	$leftover_name = phutil_tag('em', array(), pht('(Up For Grabs)'));
	$col_header = pht('User');
	$header = pht('Open Tasks by User and Priority (%s)', $date);
	break;
	case 'project':
	$result = array();
	$leftover = array();
	foreach ($tasks as $task) {
	$phids = $task->getProjectPHIDs();
	if ($phids) {
	foreach ($phids as $project_phid) {
	$result[$project_phid][] = $task;
	}
	} else {
	$leftover[] = $task;
	}
	}

	$result_closed = array();
	$leftover_closed = array();
	foreach ($recently_closed as $task) {
	$phids = $task->getProjectPHIDs();
	if ($phids) {
	foreach ($phids as $project_phid) {
	$result_closed[$project_phid][] = $task;
	}
	} else {
	$leftover_closed[] = $task;
	}
	}

	$base_link = '/maniphest/?allProjects=';
	$leftover_name = phutil_tag('em', array(), pht('(No Project)'));
	$col_header = pht('Project');
	$header = pht('Open Tasks by Project and Priority (%s)', $date);
	break;
	}

	$phids = array_keys($result);
	$handles = $this->loadViewerHandles($phids);
	$handles = msort($handles, 'getName');

	$order = $request->getStr('order', 'name');
	list($order, $reverse) = AphrontTableView::parseSort($order);

	require_celerity_resource('aphront-tooltip-css');
	Javelin::initBehavior('phabricator-tooltips', array());

	$rows = array();
	$pri_total = array();
	foreach (array_merge($handles, array(null)) as $handle) {
	if ($handle) {
	if (($project_handle) &&
	($project_handle->getPHID() == $handle->getPHID())) {
	// If filtering by, e.g., "bugs", don't show a "bugs" group.
	continue;
	}

	$tasks = idx($result, $handle->getPHID(), array());
	$name = phutil_tag(
	'a',
	array(
	'href' => $base_link.$handle->getPHID(),
	),
	$handle->getName());
	$closed = idx($result_closed, $handle->getPHID(), array());
	} else {
	$tasks = $leftover;
	$name = $leftover_name;
	$closed = $leftover_closed;
	}

	$taskv = $tasks;
	$tasks = mgroup($tasks, 'getPriority');

	$row = array();
	$row[] = $name;
	$total = 0;
	foreach (ManiphestTaskPriority::getTaskPriorityMap() as $pri => $label) {
	$n = count(idx($tasks, $pri, array()));
	if ($n == 0) {
	$row[] = '-';
	} else {
	$row[] = number_format($n);
	}
	$total += $n;
	}
	$row[] = number_format($total);

	list($link, $oldest_all) = $this->renderOldest($taskv);
	$row[] = $link;

	$normal_or_better = array();
	foreach ($taskv as $id => $task) {
	// TODO: This is sort of a hard-code for the default "normal" status.
	// When reports are more powerful, this should be made more general.
	if ($task->getPriority() < 50) {
	continue;
	}
	$normal_or_better[$id] = $task;
	}

	list($link, $oldest_pri) = $this->renderOldest($normal_or_better);
	$row[] = $link;

	if ($closed) {
	$task_ids = implode(',', mpull($closed, 'getID'));
	$row[] = phutil_tag(
	'a',
	array(
	'href' => '/maniphest/?ids='.$task_ids,
	'target' => '_blank',
	),
	number_format(count($closed)));
	} else {
	$row[] = '-';
	}

	switch ($order) {
	case 'total':
	$row['sort'] = $total;
	break;
	case 'oldest-all':
	$row['sort'] = $oldest_all;
	break;
	case 'oldest-pri':
	$row['sort'] = $oldest_pri;
	break;
	case 'closed':
	$row['sort'] = count($closed);
	break;
	case 'name':
	default:
	$row['sort'] = $handle ? $handle->getName() : '~';
	break;
	}

	$rows[] = $row;
	}

	$rows = isort($rows, 'sort');
	foreach ($rows as $k => $row) {
	unset($rows[$k]['sort']);
	}
	if ($reverse) {
	$rows = array_reverse($rows);
	}

	$cname = array($col_header);
	$cclass = array('pri right wide');
	$pri_map = ManiphestTaskPriority::getShortNameMap();
	foreach ($pri_map as $pri => $label) {
	$cname[] = $label;
	$cclass[] = 'n';
	}
	$cname[] = 'Total';
	$cclass[] = 'n';
	$cname[] = javelin_tag(
	'span',
	array(
	'sigil' => 'has-tooltip',
	'meta' => array(
	'tip' => pht('Oldest open task.'),
	'size' => 200,
	),
	),
	pht('Oldest (All)'));
	$cclass[] = 'n';
	$cname[] = javelin_tag(
	'span',
	array(
	'sigil' => 'has-tooltip',
	'meta' => array(
	'tip' => pht('Oldest open task, excluding those with Low or '.
	'Wishlist priority.'),
	'size' => 200,
	),
	),
	pht('Oldest (Pri)'));
	$cclass[] = 'n';

	list($ignored, $window_epoch) = $this->getWindow();
	$edate = phabricator_datetime($window_epoch, $user);
	$cname[] = javelin_tag(
	'span',
	array(
	'sigil' => 'has-tooltip',
	'meta' => array(
	'tip' => pht('Closed after %s', $edate),
	'size' => 260,
	),
	),
	pht('Recently Closed'));
	$cclass[] = 'n';

	$table = new AphrontTableView($rows);
	$table->setHeaders($cname);
	$table->setColumnClasses($cclass);
	$table->makeSortable(
	$request->getRequestURI(),
	'order',
	$order,
	$reverse,
	array(
	'name',
	null,
	null,
	null,
	null,
	null,
	null,
	'total',
	'oldest-all',
	'oldest-pri',
	'closed',
	));

	$panel = new PHUIObjectBoxView();
	$panel->setHeaderText($header);
	$panel->appendChild($table);

	$tokens = array();
	if ($project_handle) {
	$tokens = array($project_handle);
	}
	$filter = $this->renderReportFilters($tokens, $has_window = true);

	return array($filter, $panel);
	}


	/**
	* Load all the tasks that have been recently closed.
	*/
	private function loadRecentlyClosedTasks() {
	list($ignored, $window_epoch) = $this->getWindow();

	$table = new ManiphestTask();
	$xtable = new ManiphestTransaction();
	$conn_r = $table->establishConnection('r');

	// TODO: Gross. This table is not meant to be queried like this. Build
	// real stats tables.

	$open_status_list = array();
	foreach (ManiphestTaskStatus::getOpenStatusConstants() as $constant) {
	$open_status_list[] = json_encode((string)$constant);
	}

	$rows = queryfx_all(
	$conn_r,
	'SELECT t.id FROM %T t JOIN %T x ON x.objectPHID = t.phid
	WHERE t.status NOT IN (%Ls)
	AND x.oldValue IN (null, %Ls)
	AND x.newValue NOT IN (%Ls)
	AND t.dateModified >= %d
	AND x.dateCreated >= %d',
	$table->getTableName(),
	$xtable->getTableName(),
	ManiphestTaskStatus::getOpenStatusConstants(),
	$open_status_list,
	$open_status_list,
	$window_epoch,
	$window_epoch);

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

	$ids = ipull($rows, 'id');

	$query = id(new ManiphestTaskQuery())
	->setViewer($this->getRequest()->getUser())
	->withIDs($ids);

	switch ($this->view) {
	case 'project':
	$query->needProjectPHIDs(true);
	break;
	}

	return $query->execute();
	}

	/**
	* Parse the "Recently Means" filter into:
	*
	* - A string representation, like "12 AM 7 days ago" (default);
	* - a locale-aware epoch representation; and
	* - a possible error.
	*/
	private function getWindow() {
	$request = $this->getRequest();
	$user = $request->getUser();

	$window_str = $this->getRequest()->getStr('window', '12 AM 7 days ago');

	$error = null;
	$window_epoch = null;

	// Do locale-aware parsing so that the user's timezone is assumed for
	// time windows like "3 PM", rather than assuming the server timezone.

	$window_epoch = PhabricatorTime::parseLocalTime($window_str, $user);
	if (!$window_epoch) {
	$error = 'Invalid';
	$window_epoch = time() - (60 * 60 * 24 * 7);
	}

	// If the time ends up in the future, convert it to the corresponding time
	// and equal distance in the past. This is so users can type "6 days" (which
	// means "6 days from now") and get the behavior of "6 days ago", rather
	// than no results (because the window epoch is in the future). This might
	// be a little confusing because it casues "tomorrow" to mean "yesterday"
	// and "2022" (or whatever) to mean "ten years ago", but these inputs are
	// nonsense anyway.

	if ($window_epoch > time()) {
	$window_epoch = time() - ($window_epoch - time());
	}

	return array($window_str, $window_epoch, $error);
	}

	private function renderOldest(array $tasks) {
	assert_instances_of($tasks, 'ManiphestTask');
	$oldest = null;
	foreach ($tasks as $id => $task) {
	if (($oldest === null) \|\|
	($task->getDateCreated() < $tasks[$oldest]->getDateCreated())) {
	$oldest = $id;
	}
	}

	if ($oldest === null) {
	return array('-', 0);
	}

	$oldest = $tasks[$oldest];

	$raw_age = (time() - $oldest->getDateCreated());
	$age = number_format($raw_age / (24 * 60 * 60)).' d';

	$link = javelin_tag(
	'a',
	array(
	'href' => '/T'.$oldest->getID(),
	'sigil' => 'has-tooltip',
	'meta' => array(
	'tip' => 'T'.$oldest->getID().': '.$oldest->getTitle(),
	),
	'target' => '_blank',
	),
	$age);

	return array($link, $raw_age);
	}

	}
	diff --git a/src/applications/maniphest/query/ManiphestTaskQuery.php b/src/applications/maniphest/query/ManiphestTaskQuery.php
	index ebf0b891a1..974ac2ab44 100644
	--- a/src/applications/maniphest/query/ManiphestTaskQuery.php
	+++ b/src/applications/maniphest/query/ManiphestTaskQuery.php
	@@ -1,1035 +1,854 @@
	<?php

	/**
	* Query tasks by specific criteria. This class uses the higher-performance
	* but less-general Maniphest indexes to satisfy queries.
	*/
	final class ManiphestTaskQuery extends PhabricatorCursorPagedPolicyAwareQuery {

	private $taskIDs = array();
	private $taskPHIDs = array();
	private $authorPHIDs = array();
	private $ownerPHIDs = array();
	private $includeUnowned = null;
	- private $projectPHIDs = array();
	- private $xprojectPHIDs = array();
	private $subscriberPHIDs = array();
	- private $anyProjectPHIDs = array();
	- private $anyUserProjectPHIDs = array();
	- private $includeNoProject = null;
	private $dateCreatedAfter;
	private $dateCreatedBefore;
	private $dateModifiedAfter;
	private $dateModifiedBefore;
	private $subpriorityMin;
	private $subpriorityMax;

	private $fullTextSearch = '';

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_OPEN = 'status-open';
	const STATUS_CLOSED = 'status-closed';
	const STATUS_RESOLVED = 'status-resolved';
	const STATUS_WONTFIX = 'status-wontfix';
	const STATUS_INVALID = 'status-invalid';
	const STATUS_SPITE = 'status-spite';
	const STATUS_DUPLICATE = 'status-duplicate';

	private $statuses;
	private $priorities;
	private $subpriorities;

	private $groupBy = 'group-none';
	const GROUP_NONE = 'group-none';
	const GROUP_PRIORITY = 'group-priority';
	const GROUP_OWNER = 'group-owner';
	const GROUP_STATUS = 'group-status';
	const GROUP_PROJECT = 'group-project';

	private $orderBy = 'order-modified';
	const ORDER_PRIORITY = 'order-priority';
	const ORDER_CREATED = 'order-created';
	const ORDER_MODIFIED = 'order-modified';
	const ORDER_TITLE = 'order-title';

	private $needSubscriberPHIDs;
	private $needProjectPHIDs;
	private $blockingTasks;
	private $blockedTasks;
	- private $projectPolicyCheckFailed = false;

	public function withAuthors(array $authors) {
	$this->authorPHIDs = $authors;
	return $this;
	}

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

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

	public function withOwners(array $owners) {
	$no_owner = PhabricatorPeopleNoOwnerDatasource::FUNCTION_TOKEN;

	$this->includeUnowned = false;
	foreach ($owners as $k => $phid) {
	if ($phid === $no_owner \|\| $phid === null) {
	$this->includeUnowned = true;
	unset($owners[$k]);
	break;
	}
	}
	$this->ownerPHIDs = $owners;
	return $this;
	}

	- public function withAllProjects(array $projects) {
	- $this->includeNoProject = false;
	- foreach ($projects as $k => $phid) {
	- if ($phid == ManiphestTaskOwner::PROJECT_NO_PROJECT) {
	- $this->includeNoProject = true;
	- unset($projects[$k]);
	- }
	- }
	- $this->projectPHIDs = $projects;
	- return $this;
	- }
	-
	- /**
	- * Add an additional "all projects" constraint to existing filters.
	- *
	- * This is used by boards to supplement queries.
	- *
	- * @param list<phid> List of project PHIDs to add to any existing constraint.
	- * @return this
	- */
	- public function addWithAllProjects(array $projects) {
	- if ($this->projectPHIDs === null) {
	- $this->projectPHIDs = array();
	- }
	-
	- return $this->withAllProjects(array_merge($this->projectPHIDs, $projects));
	- }
	-
	- public function withoutProjects(array $projects) {
	- $this->xprojectPHIDs = $projects;
	- return $this;
	- }
	-
	public function withStatus($status) {
	$this->status = $status;
	return $this;
	}

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

	public function withPriorities(array $priorities) {
	$this->priorities = $priorities;
	return $this;
	}

	public function withSubpriorities(array $subpriorities) {
	$this->subpriorities = $subpriorities;
	return $this;
	}

	public function withSubpriorityBetween($min, $max) {
	$this->subpriorityMin = $min;
	$this->subpriorityMax = $max;
	return $this;
	}

	public function withSubscribers(array $subscribers) {
	$this->subscriberPHIDs = $subscribers;
	return $this;
	}

	public function withFullTextSearch($fulltext_search) {
	$this->fullTextSearch = $fulltext_search;
	return $this;
	}

	public function setGroupBy($group) {
	$this->groupBy = $group;
	return $this;
	}

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

	- public function withAnyProjects(array $projects) {
	- $this->anyProjectPHIDs = $projects;
	- return $this;
	- }
	-
	- public function withAnyUserProjects(array $users) {
	- $this->anyUserProjectPHIDs = $users;
	- return $this;
	- }
	-
	/**
	* True returns tasks that are blocking other tasks only.
	* False returns tasks that are not blocking other tasks only.
	* Null returns tasks regardless of blocking status.
	*/
	public function withBlockingTasks($mode) {
	$this->blockingTasks = $mode;
	return $this;
	}

	public function shouldJoinBlockingTasks() {
	return $this->blockingTasks !== null;
	}

	/**
	* True returns tasks that are blocked by other tasks only.
	* False returns tasks that are not blocked by other tasks only.
	* Null returns tasks regardless of blocked by status.
	*/
	public function withBlockedTasks($mode) {
	$this->blockedTasks = $mode;
	return $this;
	}

	public function shouldJoinBlockedTasks() {
	return $this->blockedTasks !== null;
	}

	public function withDateCreatedBefore($date_created_before) {
	$this->dateCreatedBefore = $date_created_before;
	return $this;
	}

	public function withDateCreatedAfter($date_created_after) {
	$this->dateCreatedAfter = $date_created_after;
	return $this;
	}

	public function withDateModifiedBefore($date_modified_before) {
	$this->dateModifiedBefore = $date_modified_before;
	return $this;
	}

	public function withDateModifiedAfter($date_modified_after) {
	$this->dateModifiedAfter = $date_modified_after;
	return $this;
	}

	public function needSubscriberPHIDs($bool) {
	$this->needSubscriberPHIDs = $bool;
	return $this;
	}

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

	protected function newResultObject() {
	return new ManiphestTask();
	}

	protected function willExecute() {
	- // Make sure the user can see any projects specified in this
	- // query FIRST.
	- if ($this->projectPHIDs) {
	- $projects = id(new PhabricatorProjectQuery())
	- ->setViewer($this->getViewer())
	- ->withPHIDs($this->projectPHIDs)
	- ->execute();
	- $projects = mpull($projects, null, 'getPHID');
	- foreach ($this->projectPHIDs as $index => $phid) {
	- $project = idx($projects, $phid);
	- if (!$project) {
	- unset($this->projectPHIDs[$index]);
	- continue;
	- }
	- }
	- if (!$this->projectPHIDs) {
	- $this->projectPolicyCheckFailed = true;
	- }
	- $this->projectPHIDs = array_values($this->projectPHIDs);
	- }
	-
	// If we already have an order vector, use it as provided.
	// TODO: This is a messy hack to make setOrderVector() stronger than
	// setPriority().
	$vector = $this->getOrderVector();
	$keys = mpull(iterator_to_array($vector), 'getOrderKey');
	if (array_values($keys) !== array('id')) {
	return;
	}

	$parts = array();
	switch ($this->groupBy) {
	case self::GROUP_NONE:
	break;
	case self::GROUP_PRIORITY:
	$parts[] = array('priority');
	break;
	case self::GROUP_OWNER:
	$parts[] = array('owner');
	break;
	case self::GROUP_STATUS:
	$parts[] = array('status');
	break;
	case self::GROUP_PROJECT:
	$parts[] = array('project');
	break;
	}

	if ($this->applicationSearchOrders) {
	$columns = array();
	foreach ($this->applicationSearchOrders as $order) {
	$part = 'custom:'.$order['key'];
	if ($order['ascending']) {
	$part = '-'.$part;
	}
	$columns[] = $part;
	}
	$columns[] = 'id';
	$parts[] = $columns;
	} else {
	switch ($this->orderBy) {
	case self::ORDER_PRIORITY:
	$parts[] = array('priority', 'subpriority', 'id');
	break;
	case self::ORDER_CREATED:
	$parts[] = array('id');
	break;
	case self::ORDER_MODIFIED:
	$parts[] = array('updated', 'id');
	break;
	case self::ORDER_TITLE:
	$parts[] = array('title', 'id');
	break;
	}
	}

	$parts = array_mergev($parts);
	// We may have a duplicate column if we are both ordering and grouping
	// by priority.
	$parts = array_unique($parts);
	$this->setOrderVector($parts);
	}

	protected function loadPage() {
	-
	- if ($this->projectPolicyCheckFailed) {
	- throw new PhabricatorEmptyQueryException();
	- }
	-
	$task_dao = new ManiphestTask();
	$conn = $task_dao->establishConnection('r');

	$where = array();
	$where[] = $this->buildTaskIDsWhereClause($conn);
	$where[] = $this->buildTaskPHIDsWhereClause($conn);
	$where[] = $this->buildStatusWhereClause($conn);
	$where[] = $this->buildStatusesWhereClause($conn);
	$where[] = $this->buildDependenciesWhereClause($conn);
	$where[] = $this->buildAuthorWhereClause($conn);
	$where[] = $this->buildOwnerWhereClause($conn);
	- $where[] = $this->buildProjectWhereClause($conn);
	- $where[] = $this->buildAnyProjectWhereClause($conn);
	- $where[] = $this->buildAnyUserProjectWhereClause($conn);
	- $where[] = $this->buildXProjectWhereClause($conn);
	$where[] = $this->buildFullTextWhereClause($conn);

	if ($this->dateCreatedAfter) {
	$where[] = qsprintf(
	$conn,
	'task.dateCreated >= %d',
	$this->dateCreatedAfter);
	}

	if ($this->dateCreatedBefore) {
	$where[] = qsprintf(
	$conn,
	'task.dateCreated <= %d',
	$this->dateCreatedBefore);
	}

	if ($this->dateModifiedAfter) {
	$where[] = qsprintf(
	$conn,
	'task.dateModified >= %d',
	$this->dateModifiedAfter);
	}

	if ($this->dateModifiedBefore) {
	$where[] = qsprintf(
	$conn,
	'task.dateModified <= %d',
	$this->dateModifiedBefore);
	}

	if ($this->priorities) {
	$where[] = qsprintf(
	$conn,
	'task.priority IN (%Ld)',
	$this->priorities);
	}

	if ($this->subpriorities) {
	$where[] = qsprintf(
	$conn,
	'task.subpriority IN (%Lf)',
	$this->subpriorities);
	}

	if ($this->subpriorityMin) {
	$where[] = qsprintf(
	$conn,
	'task.subpriority >= %f',
	$this->subpriorityMin);
	}

	if ($this->subpriorityMax) {
	$where[] = qsprintf(
	$conn,
	'task.subpriority <= %f',
	$this->subpriorityMax);
	}

	$where[] = $this->buildWhereClauseParts($conn);

	$where = $this->formatWhereClause($where);

	- $count = '';
	- if (count($this->projectPHIDs) > 1) {
	- $count = ', COUNT(project.dst) projectCount';
	- }
	-
	$group_column = '';
	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$group_column = qsprintf(
	$conn,
	', projectGroupName.indexedObjectPHID projectGroupPHID');
	break;
	}

	$rows = queryfx_all(
	$conn,
	- '%Q %Q %Q FROM %T task %Q %Q %Q %Q %Q %Q',
	+ '%Q %Q FROM %T task %Q %Q %Q %Q %Q %Q',
	$this->buildSelectClause($conn),
	- $count,
	$group_column,
	$task_dao->getTableName(),
	$this->buildJoinClause($conn),
	$where,
	$this->buildGroupClause($conn),
	$this->buildHavingClause($conn),
	$this->buildOrderClause($conn),
	$this->buildLimitClause($conn));

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$data = ipull($rows, null, 'id');
	break;
	default:
	$data = $rows;
	break;
	}

	$tasks = $task_dao->loadAllFromArray($data);

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$results = array();
	foreach ($rows as $row) {
	$task = clone $tasks[$row['id']];
	$task->attachGroupByProjectPHID($row['projectGroupPHID']);
	$results[] = $task;
	}
	$tasks = $results;
	break;
	}

	return $tasks;
	}

	protected function willFilterPage(array $tasks) {
	if ($this->groupBy == self::GROUP_PROJECT) {
	// We should only return project groups which the user can actually see.
	$project_phids = mpull($tasks, 'getGroupByProjectPHID');
	$projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs($project_phids)
	->execute();
	$projects = mpull($projects, null, 'getPHID');

	foreach ($tasks as $key => $task) {
	if (!$task->getGroupByProjectPHID()) {
	// This task is either not in any projects, or only in projects
	// which we're ignoring because they're being queried for explicitly.
	continue;
	}

	if (empty($projects[$task->getGroupByProjectPHID()])) {
	unset($tasks[$key]);
	}
	}
	}

	return $tasks;
	}

	protected function didFilterPage(array $tasks) {
	$phids = mpull($tasks, 'getPHID');

	if ($this->needProjectPHIDs) {
	$edge_query = id(new PhabricatorEdgeQuery())
	->withSourcePHIDs($phids)
	->withEdgeTypes(
	array(
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	));
	$edge_query->execute();

	foreach ($tasks as $task) {
	$project_phids = $edge_query->getDestinationPHIDs(
	array($task->getPHID()));
	$task->attachProjectPHIDs($project_phids);
	}
	}

	if ($this->needSubscriberPHIDs) {
	$subscriber_sets = id(new PhabricatorSubscribersQuery())
	->withObjectPHIDs($phids)
	->execute();
	foreach ($tasks as $task) {
	$subscribers = idx($subscriber_sets, $task->getPHID(), array());
	$task->attachSubscriberPHIDs($subscribers);
	}
	}

	return $tasks;
	}

	private function buildTaskIDsWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->taskIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'task.id in (%Ld)',
	$this->taskIDs);
	}

	private function buildTaskPHIDsWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->taskPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'task.phid in (%Ls)',
	$this->taskPHIDs);
	}

	private function buildStatusWhereClause(AphrontDatabaseConnection $conn) {
	static $map = array(
	self::STATUS_RESOLVED => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
	self::STATUS_WONTFIX => ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
	self::STATUS_INVALID => ManiphestTaskStatus::STATUS_CLOSED_INVALID,
	self::STATUS_SPITE => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
	self::STATUS_DUPLICATE => ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE,
	);

	switch ($this->status) {
	case self::STATUS_ANY:
	return null;
	case self::STATUS_OPEN:
	return qsprintf(
	$conn,
	'task.status IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	case self::STATUS_CLOSED:
	return qsprintf(
	$conn,
	'task.status IN (%Ls)',
	ManiphestTaskStatus::getClosedStatusConstants());
	default:
	$constant = idx($map, $this->status);
	if (!$constant) {
	throw new Exception("Unknown status query '{$this->status}'!");
	}
	return qsprintf(
	$conn,
	'task.status = %s',
	$constant);
	}
	}

	private function buildStatusesWhereClause(AphrontDatabaseConnection $conn) {
	if ($this->statuses) {
	return qsprintf(
	$conn,
	'task.status IN (%Ls)',
	$this->statuses);
	}
	return null;
	}

	private function buildAuthorWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->authorPHIDs) {
	return null;
	}

	return qsprintf(
	$conn,
	'task.authorPHID in (%Ls)',
	$this->authorPHIDs);
	}

	private function buildOwnerWhereClause(AphrontDatabaseConnection $conn) {
	if (!$this->ownerPHIDs) {
	if ($this->includeUnowned === null) {
	return null;
	} else if ($this->includeUnowned) {
	return qsprintf(
	$conn,
	'task.ownerPHID IS NULL');
	} else {
	return qsprintf(
	$conn,
	'task.ownerPHID IS NOT NULL');
	}
	}

	if ($this->includeUnowned) {
	return qsprintf(
	$conn,
	'task.ownerPHID IN (%Ls) OR task.ownerPHID IS NULL',
	$this->ownerPHIDs);
	} else {
	return qsprintf(
	$conn,
	'task.ownerPHID IN (%Ls)',
	$this->ownerPHIDs);
	}
	}

	private function buildFullTextWhereClause(AphrontDatabaseConnection $conn) {
	if (!strlen($this->fullTextSearch)) {
	return null;
	}

	// In doing a fulltext search, we first find all the PHIDs that match the
	// fulltext search, and then use that to limit the rest of the search
	$fulltext_query = id(new PhabricatorSavedQuery())
	->setEngineClassName('PhabricatorSearchApplicationSearchEngine')
	->setParameter('query', $this->fullTextSearch);

	// NOTE: Setting this to something larger than 2^53 will raise errors in
	// ElasticSearch, and billions of results won't fit in memory anyway.
	$fulltext_query->setParameter('limit', 100000);
	$fulltext_query->setParameter('type', ManiphestTaskPHIDType::TYPECONST);

	$engine = PhabricatorSearchEngineSelector::newSelector()->newEngine();
	$fulltext_results = $engine->executeSearch($fulltext_query);

	if (empty($fulltext_results)) {
	$fulltext_results = array(null);
	}

	return qsprintf(
	$conn,
	'task.phid IN (%Ls)',
	$fulltext_results);
	}

	private function buildDependenciesWhereClause(
	AphrontDatabaseConnection $conn) {

	if (!$this->shouldJoinBlockedTasks() &&
	!$this->shouldJoinBlockingTasks()) {
	return null;
	}

	$parts = array();
	if ($this->blockingTasks === true) {
	$parts[] = qsprintf(
	$conn,
	'blocking.dst IS NOT NULL AND blockingtask.status IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	} else if ($this->blockingTasks === false) {
	$parts[] = qsprintf(
	$conn,
	'blocking.dst IS NULL OR blockingtask.status NOT IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	}

	if ($this->blockedTasks === true) {
	$parts[] = qsprintf(
	$conn,
	'blocked.dst IS NOT NULL AND blockedtask.status IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	} else if ($this->blockedTasks === false) {
	$parts[] = qsprintf(
	$conn,
	'blocked.dst IS NULL OR blockedtask.status NOT IN (%Ls)',
	ManiphestTaskStatus::getOpenStatusConstants());
	}

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

	- private function buildProjectWhereClause(AphrontDatabaseConnection $conn) {
	- if (!$this->projectPHIDs && !$this->includeNoProject) {
	- return null;
	- }
	-
	- $parts = array();
	- if ($this->projectPHIDs) {
	- $parts[] = qsprintf(
	- $conn,
	- 'project.dst in (%Ls)',
	- $this->projectPHIDs);
	- }
	- if ($this->includeNoProject) {
	- $parts[] = qsprintf(
	- $conn,
	- 'project.dst IS NULL');
	- }
	-
	- return '('.implode(') OR (', $parts).')';
	- }
	-
	- private function buildAnyProjectWhereClause(AphrontDatabaseConnection $conn) {
	- if (!$this->anyProjectPHIDs) {
	- return null;
	- }
	-
	- return qsprintf(
	- $conn,
	- 'anyproject.dst IN (%Ls)',
	- $this->anyProjectPHIDs);
	- }
	-
	- private function buildAnyUserProjectWhereClause(
	- AphrontDatabaseConnection $conn) {
	- if (!$this->anyUserProjectPHIDs) {
	- return null;
	- }
	-
	- $projects = id(new PhabricatorProjectQuery())
	- ->setViewer($this->getViewer())
	- ->withMemberPHIDs($this->anyUserProjectPHIDs)
	- ->execute();
	- $any_user_project_phids = mpull($projects, 'getPHID');
	- if (!$any_user_project_phids) {
	- throw new PhabricatorEmptyQueryException();
	- }
	-
	- return qsprintf(
	- $conn,
	- 'anyproject.dst IN (%Ls)',
	- $any_user_project_phids);
	- }
	-
	- private function buildXProjectWhereClause(AphrontDatabaseConnection $conn) {
	- if (!$this->xprojectPHIDs) {
	- return null;
	- }
	-
	- return qsprintf(
	- $conn,
	- 'xproject.dst IS NULL');
	- }
	-
	protected function buildJoinClauseParts(AphrontDatabaseConnection $conn_r) {
	$edge_table = PhabricatorEdgeConfig::TABLE_NAME_EDGE;

	$joins = array();

	- if ($this->projectPHIDs \|\| $this->includeNoProject) {
	- $joins[] = qsprintf(
	- $conn_r,
	- '%Q JOIN %T project ON project.src = task.phid
	- AND project.type = %d',
	- ($this->includeNoProject ? 'LEFT' : ''),
	- $edge_table,
	- PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	- }
	-
	if ($this->shouldJoinBlockingTasks()) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T blocking ON blocking.src = task.phid '.
	'AND blocking.type = %d '.
	'LEFT JOIN %T blockingtask ON blocking.dst = blockingtask.phid',
	$edge_table,
	ManiphestTaskDependedOnByTaskEdgeType::EDGECONST,
	id(new ManiphestTask())->getTableName());
	}
	if ($this->shouldJoinBlockedTasks()) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T blocked ON blocked.src = task.phid '.
	'AND blocked.type = %d '.
	'LEFT JOIN %T blockedtask ON blocked.dst = blockedtask.phid',
	$edge_table,
	ManiphestTaskDependsOnTaskEdgeType::EDGECONST,
	id(new ManiphestTask())->getTableName());
	}

	- if ($this->anyProjectPHIDs \|\| $this->anyUserProjectPHIDs) {
	- $joins[] = qsprintf(
	- $conn_r,
	- 'JOIN %T anyproject ON anyproject.src = task.phid
	- AND anyproject.type = %d',
	- $edge_table,
	- PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	- }
	-
	- if ($this->xprojectPHIDs) {
	- $joins[] = qsprintf(
	- $conn_r,
	- 'LEFT JOIN %T xproject ON xproject.src = task.phid
	- AND xproject.type = %d
	- AND xproject.dst IN (%Ls)',
	- $edge_table,
	- PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	- $this->xprojectPHIDs);
	- }
	-
	if ($this->subscriberPHIDs) {
	$joins[] = qsprintf(
	$conn_r,
	'JOIN %T e_ccs ON e_ccs.src = task.phid '.
	'AND e_ccs.type = %s '.
	'AND e_ccs.dst in (%Ls)',
	PhabricatorEdgeConfig::TABLE_NAME_EDGE,
	PhabricatorObjectHasSubscriberEdgeType::EDGECONST,
	$this->subscriberPHIDs);
	}

	switch ($this->groupBy) {
	case self::GROUP_PROJECT:
	$ignore_group_phids = $this->getIgnoreGroupedProjectPHIDs();
	if ($ignore_group_phids) {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroup ON task.phid = projectGroup.src
	AND projectGroup.type = %d
	AND projectGroup.dst NOT IN (%Ls)',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	$ignore_group_phids);
	} else {
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroup ON task.phid = projectGroup.src
	AND projectGroup.type = %d',
	$edge_table,
	PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
	}
	$joins[] = qsprintf(
	$conn_r,
	'LEFT JOIN %T projectGroupName
	ON projectGroup.dst = projectGroupName.indexedObjectPHID',
	id(new ManiphestNameIndex())->getTableName());
	break;
	}

	$joins[] = parent::buildJoinClauseParts($conn_r);

	return $joins;
	}

	protected function buildGroupClause(AphrontDatabaseConnection $conn_r) {
	- $joined_multiple_rows = (count($this->projectPHIDs) > 1) \|\|
	- (count($this->anyProjectPHIDs) > 1) \|\|
	- $this->shouldJoinBlockingTasks() \|\|
	+ $joined_multiple_rows = $this->shouldJoinBlockingTasks() \|\|
	$this->shouldJoinBlockedTasks() \|\|
	($this->shouldGroupQueryResultRows());

	$joined_project_name = ($this->groupBy == self::GROUP_PROJECT);

	// If we're joining multiple rows, we need to group the results by the
	// task IDs.
	if ($joined_multiple_rows) {
	if ($joined_project_name) {
	return 'GROUP BY task.phid, projectGroup.dst';
	} else {
	return 'GROUP BY task.phid';
	}
	} else {
	return '';
	}
	}

	/**
	* Return project PHIDs which we should ignore when grouping tasks by
	* project. For example, if a user issues a query like:
	*
	* Tasks in all projects: Frontend, Bugs
	*
	* ...then we don't show "Frontend" or "Bugs" groups in the result set, since
	* they're meaningless as all results are in both groups.
	*
	* Similarly, for queries like:
	*
	* Tasks in any projects: Public Relations
	*
	* ...we ignore the single project, as every result is in that project. (In
	* the case that there are several "any" projects, we do not ignore them.)
	*
	* @return list<phid> Project PHIDs which should be ignored in query
	* construction.
	*/
	private function getIgnoreGroupedProjectPHIDs() {
	+ // Maybe we should also exclude the "OPERATOR_NOT" PHIDs? It won't
	+ // impact the results, but we might end up with a better query plan.
	+ // Investigate this on real data? This is likely very rare.
	+
	+ $edge_types = array(
	+ PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	+ );
	+
	$phids = array();

	- if ($this->projectPHIDs) {
	- $phids[] = $this->projectPHIDs;
	- }
	+ $phids[] = $this->getEdgeLogicValues(
	+ $edge_types,
	+ array(
	+ PhabricatorQueryConstraint::OPERATOR_AND,
	+ ));

	- if (count($this->anyProjectPHIDs) == 1) {
	- $phids[] = $this->anyProjectPHIDs;
	+ $any = $this->getEdgeLogicValues(
	+ $edge_types,
	+ array(
	+ PhabricatorQueryConstraint::OPERATOR_OR,
	+ ));
	+ if (count($any) == 1) {
	+ $phids[] = $any;
	}

	- // Maybe we should also exclude the "excludeProjectPHIDs"? It won't
	- // impact the results, but we might end up with a better query plan.
	- // Investigate this on real data? This is likely very rare.
	-
	return array_mergev($phids);
	}

	- // TODO: Remove this when moving fully to edge logic.
	- protected function buildHavingClauseParts(AphrontDatabaseConnection $conn) {
	- $having = parent::buildHavingClauseParts($conn);
	- if (count($this->projectPHIDs) > 1) {
	- $having[] = qsprintf(
	- $conn,
	- 'projectCount = %d',
	- count($this->projectPHIDs));
	- }
	- return $having;
	- }
	-
	protected function getResultCursor($result) {
	$id = $result->getID();

	if ($this->groupBy == self::GROUP_PROJECT) {
	return rtrim($id.'.'.$result->getGroupByProjectPHID(), '.');;
	}

	return $id;
	}

	public function getOrderableColumns() {
	return parent::getOrderableColumns() + array(
	'priority' => array(
	'table' => 'task',
	'column' => 'priority',
	'type' => 'int',
	),
	'owner' => array(
	'table' => 'task',
	'column' => 'ownerOrdering',
	'null' => 'head',
	'reverse' => true,
	'type' => 'string',
	),
	'status' => array(
	'table' => 'task',
	'column' => 'status',
	'type' => 'string',
	'reverse' => true,
	),
	'project' => array(
	'table' => 'projectGroupName',
	'column' => 'indexedObjectName',
	'type' => 'string',
	'null' => 'head',
	'reverse' => true,
	),
	'title' => array(
	'table' => 'task',
	'column' => 'title',
	'type' => 'string',
	'reverse' => true,
	),
	'subpriority' => array(
	'table' => 'task',
	'column' => 'subpriority',
	'type' => 'float',
	),
	'updated' => array(
	'table' => 'task',
	'column' => 'dateModified',
	'type' => 'int',
	),
	);
	}

	protected function getPagingValueMap($cursor, array $keys) {
	$cursor_parts = explode('.', $cursor, 2);
	$task_id = $cursor_parts[0];
	$group_id = idx($cursor_parts, 1);

	$task = $this->loadCursorObject($task_id);

	$map = array(
	'id' => $task->getID(),
	'priority' => $task->getPriority(),
	'subpriority' => $task->getSubpriority(),
	'owner' => $task->getOwnerOrdering(),
	'status' => $task->getStatus(),
	'title' => $task->getTitle(),
	'updated' => $task->getDateModified(),
	);

	foreach ($keys as $key) {
	switch ($key) {
	case 'project':
	$value = null;
	if ($group_id) {
	$paging_projects = id(new PhabricatorProjectQuery())
	->setViewer($this->getViewer())
	->withPHIDs(array($group_id))
	->execute();
	if ($paging_projects) {
	$value = head($paging_projects)->getName();
	}
	}
	$map[$key] = $value;
	break;
	}
	}

	foreach ($keys as $key) {
	if ($this->isCustomFieldOrderKey($key)) {
	$map += $this->getPagingValueMapForCustomFields($task);
	break;
	}
	}

	return $map;
	}

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

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

	}
	diff --git a/src/applications/project/controller/PhabricatorProjectBoardViewController.php b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	index 925edeabea..27e16ce56c 100644
	--- a/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	+++ b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
	@@ -1,744 +1,746 @@
	<?php

	final class PhabricatorProjectBoardViewController
	extends PhabricatorProjectBoardController {

	const BATCH_EDIT_ALL = 'all';

	private $id;
	private $slug;
	private $handles;
	private $queryKey;
	private $filter;
	private $sortKey;
	private $showHidden;

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $request->getUser();
	$id = $request->getURIData('id');

	$show_hidden = $request->getBool('hidden');
	$this->showHidden = $show_hidden;

	$project = id(new PhabricatorProjectQuery())
	->setViewer($viewer)
	->needImages(true);
	$id = $request->getURIData('id');
	$slug = $request->getURIData('slug');
	if ($slug) {
	$project->withSlugs(array($slug));
	} else {
	$project->withIDs(array($id));
	}
	$project = $project->executeOne();
	if (!$project) {
	return new Aphront404Response();
	}

	$this->setProject($project);
	$this->id = $project->getID();

	$sort_key = $request->getStr('order');
	switch ($sort_key) {
	case PhabricatorProjectColumn::ORDER_NATURAL:
	case PhabricatorProjectColumn::ORDER_PRIORITY:
	break;
	default:
	$sort_key = PhabricatorProjectColumn::DEFAULT_ORDER;
	break;
	}
	$this->sortKey = $sort_key;

	$column_query = id(new PhabricatorProjectColumnQuery())
	->setViewer($viewer)
	->withProjectPHIDs(array($project->getPHID()));
	-
	if (!$show_hidden) {
	$column_query->withStatuses(
	array(PhabricatorProjectColumn::STATUS_ACTIVE));
	}

	$columns = $column_query->execute();
	$columns = mpull($columns, null, 'getSequence');

	// TODO: Expand the checks here if we add the ability
	// to hide the Backlog column
	if (!$columns) {
	switch ($request->getStr('initialize-type')) {
	case 'backlog-only':
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	$column = PhabricatorProjectColumn::initializeNewColumn($viewer)
	->setSequence(0)
	->setProperty('isDefault', true)
	->setProjectPHID($project->getPHID())
	->save();
	$column->attachProject($project);
	$columns[0] = $column;
	unset($unguarded);
	break;
	case 'import':
	return id(new AphrontRedirectResponse())
	->setURI(
	$this->getApplicationURI('board/'.$project->getID().'/import/'));
	break;
	default:
	return $this->initializeWorkboardDialog($project);
	break;
	}
	}

	ksort($columns);

	$board_uri = $this->getApplicationURI('board/'.$project->getID().'/');

	$engine = id(new ManiphestTaskSearchEngine())
	->setViewer($viewer)
	->setBaseURI($board_uri)
	->setIsBoardView(true);

	if ($request->isFormPost()) {
	$saved = $engine->buildSavedQueryFromRequest($request);
	$engine->saveQuery($saved);
	$filter_form = id(new AphrontFormView())
	->setUser($viewer);
	$engine->buildSearchForm($filter_form, $saved);
	if ($engine->getErrors()) {
	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle(pht('Advanced Filter'))
	->appendChild($filter_form->buildLayoutView())
	->setErrors($engine->getErrors())
	->setSubmitURI($board_uri)
	->addSubmitButton(pht('Apply Filter'))
	->addCancelButton($board_uri);
	}
	return id(new AphrontRedirectResponse())->setURI(
	$this->getURIWithState(
	$engine->getQueryResultsPageURI($saved->getQueryKey())));
	}

	$query_key = $request->getURIData('queryKey');
	if (!$query_key) {
	$query_key = 'open';
	}
	$this->queryKey = $query_key;

	$custom_query = null;
	if ($engine->isBuiltinQuery($query_key)) {
	$saved = $engine->buildSavedQueryFromBuiltin($query_key);
	} else {
	$saved = id(new PhabricatorSavedQueryQuery())
	->setViewer($viewer)
	->withQueryKeys(array($query_key))
	->executeOne();

	if (!$saved) {
	return new Aphront404Response();
	}

	$custom_query = $saved;
	}

	if ($request->getURIData('filter')) {
	$filter_form = id(new AphrontFormView())
	->setUser($viewer);
	$engine->buildSearchForm($filter_form, $saved);

	return $this->newDialog()
	->setWidth(AphrontDialogView::WIDTH_FULL)
	->setTitle(pht('Advanced Filter'))
	->appendChild($filter_form->buildLayoutView())
	->setSubmitURI($board_uri)
	->addSubmitButton(pht('Apply Filter'))
	->addCancelButton($board_uri);
	}

	$task_query = $engine->buildQueryFromSavedQuery($saved);

	$tasks = $task_query
	- ->addWithAllProjects(array($project->getPHID()))
	+ ->withEdgeLogicPHIDs(
	+ PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	+ PhabricatorQueryConstraint::OPERATOR_AND,
	+ array($project->getPHID()))
	->setOrderBy(ManiphestTaskQuery::ORDER_PRIORITY)
	->setViewer($viewer)
	->execute();
	$tasks = mpull($tasks, null, 'getPHID');

	if ($tasks) {
	$positions = id(new PhabricatorProjectColumnPositionQuery())
	->setViewer($viewer)
	->withObjectPHIDs(mpull($tasks, 'getPHID'))
	->withColumns($columns)
	->execute();
	$positions = mpull($positions, null, 'getObjectPHID');
	} else {
	$positions = array();
	}

	$task_map = array();
	foreach ($tasks as $task) {
	$task_phid = $task->getPHID();
	if (empty($positions[$task_phid])) {
	// This shouldn't normally be possible because we create positions on
	// demand, but we might have raced as an object was removed from the
	// board. Just drop the task if we don't have a position for it.
	continue;
	}

	$position = $positions[$task_phid];
	$task_map[$position->getColumnPHID()][] = $task_phid;
	}

	// If we're showing the board in "natural" order, sort columns by their
	// column positions.
	if ($this->sortKey == PhabricatorProjectColumn::ORDER_NATURAL) {
	foreach ($task_map as $column_phid => $task_phids) {
	$order = array();
	foreach ($task_phids as $task_phid) {
	if (isset($positions[$task_phid])) {
	$order[$task_phid] = $positions[$task_phid]->getOrderingKey();
	} else {
	$order[$task_phid] = 0;
	}
	}
	asort($order);
	$task_map[$column_phid] = array_keys($order);
	}
	}

	$task_can_edit_map = id(new PhabricatorPolicyFilter())
	->setViewer($viewer)
	->requireCapabilities(array(PhabricatorPolicyCapability::CAN_EDIT))
	->apply($tasks);

	// If this is a batch edit, select the editable tasks in the chosen column
	// and ship the user into the batch editor.
	$batch_edit = $request->getStr('batch');
	if ($batch_edit) {
	if ($batch_edit !== self::BATCH_EDIT_ALL) {
	$column_id_map = mpull($columns, null, 'getID');
	$batch_column = idx($column_id_map, $batch_edit);
	if (!$batch_column) {
	return new Aphront404Response();
	}

	$batch_task_phids = idx($task_map, $batch_column->getPHID(), array());
	foreach ($batch_task_phids as $key => $batch_task_phid) {
	if (empty($task_can_edit_map[$batch_task_phid])) {
	unset($batch_task_phids[$key]);
	}
	}

	$batch_tasks = array_select_keys($tasks, $batch_task_phids);
	} else {
	$batch_tasks = $task_can_edit_map;
	}

	if (!$batch_tasks) {
	$cancel_uri = $this->getURIWithState($board_uri);
	return $this->newDialog()
	->setTitle(pht('No Editable Tasks'))
	->appendParagraph(
	pht(
	'The selected column contains no visible tasks which you '.
	'have permission to edit.'))
	->addCancelButton($board_uri);
	}

	$batch_ids = mpull($batch_tasks, 'getID');
	$batch_ids = implode(',', $batch_ids);

	$batch_uri = new PhutilURI('/maniphest/batch/');
	$batch_uri->setQueryParam('board', $this->id);
	$batch_uri->setQueryParam('batch', $batch_ids);
	return id(new AphrontRedirectResponse())
	->setURI($batch_uri);
	}

	$board_id = celerity_generate_unique_node_id();

	$board = id(new PHUIWorkboardView())
	->setUser($viewer)
	->setID($board_id);

	$this->initBehavior(
	'project-boards',
	array(
	'boardID' => $board_id,
	'projectPHID' => $project->getPHID(),
	'moveURI' => $this->getApplicationURI('move/'.$project->getID().'/'),
	'createURI' => '/maniphest/task/create/',
	'order' => $this->sortKey,
	));

	$this->handles = ManiphestTaskListView::loadTaskHandles($viewer, $tasks);

	foreach ($columns as $column) {
	$task_phids = idx($task_map, $column->getPHID(), array());
	$column_tasks = array_select_keys($tasks, $task_phids);

	$panel = id(new PHUIWorkpanelView())
	->setHeader($column->getDisplayName())
	->setSubHeader($column->getDisplayType())
	->addSigil('workpanel');

	$header_icon = $column->getHeaderIcon();
	if ($header_icon) {
	$panel->setHeaderIcon($header_icon);
	}

	if ($column->isHidden()) {
	$panel->addClass('project-panel-hidden');
	}

	$column_menu = $this->buildColumnMenu($project, $column);
	$panel->addHeaderAction($column_menu);

	$tag_id = celerity_generate_unique_node_id();
	$tag_content_id = celerity_generate_unique_node_id();

	$count_tag = id(new PHUITagView())
	->setType(PHUITagView::TYPE_SHADE)
	->setShade(PHUITagView::COLOR_BLUE)
	->setID($tag_id)
	->setName(phutil_tag('span', array('id' => $tag_content_id), '-'))
	->setStyle('display: none');

	$panel->setHeaderTag($count_tag);

	$cards = id(new PHUIObjectItemListView())
	->setUser($viewer)
	->setFlush(true)
	->setAllowEmptyList(true)
	->addSigil('project-column')
	->setMetadata(
	array(
	'columnPHID' => $column->getPHID(),
	'countTagID' => $tag_id,
	'countTagContentID' => $tag_content_id,
	'pointLimit' => $column->getPointLimit(),
	));

	foreach ($column_tasks as $task) {
	$owner = null;
	if ($task->getOwnerPHID()) {
	$owner = $this->handles[$task->getOwnerPHID()];
	}
	$can_edit = idx($task_can_edit_map, $task->getPHID(), false);
	$cards->addItem(id(new ProjectBoardTaskCard())
	->setViewer($viewer)
	->setTask($task)
	->setOwner($owner)
	->setCanEdit($can_edit)
	->getItem());
	}
	$panel->setCards($cards);
	$board->addPanel($panel);
	}

	Javelin::initBehavior(
	'boards-dropdown',
	array());

	$sort_menu = $this->buildSortMenu(
	$viewer,
	$sort_key);

	$filter_menu = $this->buildFilterMenu(
	$viewer,
	$custom_query,
	$engine,
	$query_key);

	$manage_menu = $this->buildManageMenu($project, $show_hidden);

	$header_link = phutil_tag(
	'a',
	array(
	'href' => $this->getApplicationURI('profile/'.$project->getID().'/'),
	),
	$project->getName());

	$header = id(new PHUIHeaderView())
	->setHeader(pht('%s Workboard', $header_link))
	->setUser($viewer)
	->setNoBackground(true)
	->addActionLink($sort_menu)
	->addActionLink($filter_menu)
	->addActionLink($manage_menu)
	->setPolicyObject($project);

	$board_box = id(new PHUIBoxView())
	->appendChild($board)
	->addClass('project-board-wrapper');

	$nav = $this->buildIconNavView($project);
	$nav->appendChild($header);
	$nav->appendChild($board_box);

	return $this->buildApplicationPage(
	$nav,
	array(
	'title' => pht('%s Board', $project->getName()),
	'showFooter' => false,
	));
	}

	private function buildSortMenu(
	PhabricatorUser $viewer,
	$sort_key) {

	$sort_icon = id(new PHUIIconView())
	->setIconFont('fa-sort-amount-asc bluegrey');

	$named = array(
	PhabricatorProjectColumn::ORDER_NATURAL => pht('Natural'),
	PhabricatorProjectColumn::ORDER_PRIORITY => pht('Sort by Priority'),
	);

	$base_uri = $this->getURIWithState();

	$items = array();
	foreach ($named as $key => $name) {
	$is_selected = ($key == $sort_key);
	if ($is_selected) {
	$active_order = $name;
	}

	$item = id(new PhabricatorActionView())
	->setIcon('fa-sort-amount-asc')
	->setSelected($is_selected)
	->setName($name);

	$uri = $base_uri->alter('order', $key);
	$item->setHref($uri);

	$items[] = $item;
	}

	$sort_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($items as $item) {
	$sort_menu->addAction($item);
	}

	$sort_button = id(new PHUIButtonView())
	->setText(pht('Sort: %s', $active_order))
	->setIcon($sort_icon)
	->setTag('a')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $sort_menu),
	));

	return $sort_button;
	}
	private function buildFilterMenu(
	PhabricatorUser $viewer,
	$custom_query,
	PhabricatorApplicationSearchEngine $engine,
	$query_key) {

	$filter_icon = id(new PHUIIconView())
	->setIconFont('fa-search-plus bluegrey');

	$named = array(
	'open' => pht('Open Tasks'),
	'all' => pht('All Tasks'),
	);

	if ($viewer->isLoggedIn()) {
	$named['assigned'] = pht('Assigned to Me');
	}

	if ($custom_query) {
	$named[$custom_query->getQueryKey()] = pht('Custom Filter');
	}

	$items = array();
	foreach ($named as $key => $name) {
	$is_selected = ($key == $query_key);
	if ($is_selected) {
	$active_filter = $name;
	}

	$is_custom = false;
	if ($custom_query) {
	$is_custom = ($key == $custom_query->getQueryKey());
	}

	$item = id(new PhabricatorActionView())
	->setIcon('fa-search')
	->setSelected($is_selected)
	->setName($name);

	if ($is_custom) {
	$uri = $this->getApplicationURI(
	'board/'.$this->id.'/filter/query/'.$key.'/');
	$item->setWorkflow(true);
	} else {
	$uri = $engine->getQueryResultsPageURI($key);
	}

	$uri = $this->getURIWithState($uri);
	$item->setHref($uri);

	$items[] = $item;
	}

	$items[] = id(new PhabricatorActionView())
	->setIcon('fa-cog')
	->setHref($this->getApplicationURI('board/'.$this->id.'/filter/'))
	->setWorkflow(true)
	->setName(pht('Advanced Filter...'));

	$filter_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($items as $item) {
	$filter_menu->addAction($item);
	}

	$filter_button = id(new PHUIButtonView())
	->setText(pht('Filter: %s', $active_filter))
	->setIcon($filter_icon)
	->setTag('a')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $filter_menu),
	));

	return $filter_button;
	}

	private function buildManageMenu(
	PhabricatorProject $project,
	$show_hidden) {

	$request = $this->getRequest();
	$viewer = $request->getUser();

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);

	$manage_icon = id(new PHUIIconView())
	->setIconFont('fa-cog bluegrey');

	$manage_items = array();

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-plus')
	->setName(pht('Add Column'))
	->setHref($this->getApplicationURI('board/'.$this->id.'/edit/'))
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit);

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-exchange')
	->setName(pht('Reorder Columns'))
	->setHref($this->getApplicationURI('board/'.$this->id.'/reorder/'))
	->setDisabled(!$can_edit)
	->setWorkflow(true);

	if ($show_hidden) {
	$hidden_uri = $this->getURIWithState()
	->setQueryParam('hidden', null);
	$hidden_icon = 'fa-eye-slash';
	$hidden_text = pht('Hide Hidden Columns');
	} else {
	$hidden_uri = $this->getURIWithState()
	->setQueryParam('hidden', 'true');
	$hidden_icon = 'fa-eye';
	$hidden_text = pht('Show Hidden Columns');
	}

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon($hidden_icon)
	->setName($hidden_text)
	->setHref($hidden_uri);

	$batch_edit_uri = $request->getRequestURI();
	$batch_edit_uri->setQueryParam('batch', self::BATCH_EDIT_ALL);
	$can_batch_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
	ManiphestBulkEditCapability::CAPABILITY);

	$manage_items[] = id(new PhabricatorActionView())
	->setIcon('fa-list-ul')
	->setName(pht('Batch Edit Visible Tasks...'))
	->setHref($batch_edit_uri)
	->setDisabled(!$can_batch_edit);

	$manage_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($manage_items as $item) {
	$manage_menu->addAction($item);
	}

	$manage_button = id(new PHUIButtonView())
	->setText(pht('Manage Board'))
	->setIcon($manage_icon)
	->setTag('a')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $manage_menu),
	));

	return $manage_button;
	}

	private function buildColumnMenu(
	PhabricatorProject $project,
	PhabricatorProjectColumn $column) {

	$request = $this->getRequest();
	$viewer = $request->getUser();

	$can_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	$project,
	PhabricatorPolicyCapability::CAN_EDIT);

	$column_items = array();

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-plus')
	->setName(pht('Create Task...'))
	->setHref('/maniphest/task/create/')
	->addSigil('column-add-task')
	->setMetadata(
	array(
	'columnPHID' => $column->getPHID(),
	))
	->setDisabled(!$can_edit);

	$batch_edit_uri = $request->getRequestURI();
	$batch_edit_uri->setQueryParam('batch', $column->getID());
	$can_batch_edit = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
	ManiphestBulkEditCapability::CAPABILITY);

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-list-ul')
	->setName(pht('Batch Edit Tasks...'))
	->setHref($batch_edit_uri)
	->setDisabled(!$can_batch_edit);

	$edit_uri = $this->getApplicationURI(
	'board/'.$this->id.'/column/'.$column->getID().'/');

	$column_items[] = id(new PhabricatorActionView())
	->setIcon('fa-pencil')
	->setName(pht('Edit Column'))
	->setHref($edit_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit);

	$can_hide = ($can_edit && !$column->isDefaultColumn());
	$hide_uri = 'board/'.$this->id.'/hide/'.$column->getID().'/';
	$hide_uri = $this->getApplicationURI($hide_uri);
	$hide_uri = $this->getURIWithState($hide_uri);

	if (!$column->isHidden()) {
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Hide Column'))
	->setIcon('fa-eye-slash')
	->setHref($hide_uri)
	->setDisabled(!$can_hide)
	->setWorkflow(true);
	} else {
	$column_items[] = id(new PhabricatorActionView())
	->setName(pht('Show Column'))
	->setIcon('fa-eye')
	->setHref($hide_uri)
	->setDisabled(!$can_hide)
	->setWorkflow(true);
	}

	$column_menu = id(new PhabricatorActionListView())
	->setUser($viewer);
	foreach ($column_items as $item) {
	$column_menu->addAction($item);
	}

	$column_button = id(new PHUIIconView())
	->setIconFont('fa-caret-down')
	->setHref('#')
	->addSigil('boards-dropdown-menu')
	->setMetadata(
	array(
	'items' => hsprintf('%s', $column_menu),
	));

	return $column_button;
	}

	private function initializeWorkboardDialog(PhabricatorProject $project) {

	$instructions = pht('This workboard has not been setup yet.');
	$new_selector = id(new AphrontFormRadioButtonControl())
	->setName('initialize-type')
	->setValue('backlog-only')
	->addButton(
	'backlog-only',
	pht('New Empty Board'),
	pht('Create a new board with just a backlog column.'))
	->addButton(
	'import',
	pht('Import Columns'),
	pht('Import board columns from another project.'));

	$dialog = id(new AphrontDialogView())
	->setUser($this->getRequest()->getUser())
	->setTitle(pht('New Workboard'))
	->addSubmitButton('Continue')
	->addCancelButton($this->getApplicationURI('view/'.$project->getID().'/'))
	->appendParagraph($instructions)
	->appendChild($new_selector);

	return id(new AphrontDialogResponse())
	->setDialog($dialog);
	}


	/**
	* Add current state parameters (like order and the visibility of hidden
	* columns) to a URI.
	*
	* This allows actions which toggle or adjust one piece of state to keep
	* the rest of the board state persistent. If no URI is provided, this method
	* starts with the request URI.
	*
	* @param string\|null URI to add state parameters to.
	* @return PhutilURI URI with state parameters.
	*/
	private function getURIWithState($base = null) {
	if ($base === null) {
	$base = $this->getRequest()->getRequestURI();
	}

	$base = new PhutilURI($base);

	if ($this->sortKey != PhabricatorProjectColumn::DEFAULT_ORDER) {
	$base->setQueryParam('order', $this->sortKey);
	} else {
	$base->setQueryParam('order', null);
	}

	$base->setQueryParam('hidden', $this->showHidden ? 'true' : null);

	return $base;
	}

	}
	diff --git a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	index b864130ca4..5028d30553 100644
	--- a/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	+++ b/src/infrastructure/query/policy/PhabricatorCursorPagedPolicyAwareQuery.php
	@@ -1,1511 +1,1613 @@
	<?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 clauses Building Query Clauses
	* @task appsearch Integration with ApplicationSearch
	* @task customfield Integration with CustomField
	* @task paging Paging
	* @task order Result Ordering
	* @task edgelogic Working with Edge Logic
	*/
	abstract class PhabricatorCursorPagedPolicyAwareQuery
	extends PhabricatorPolicyAwareQuery {

	private $afterID;
	private $beforeID;
	private $applicationSearchConstraints = array();
	protected $applicationSearchOrders = array();
	private $internalPaging;
	private $orderVector;
	private $builtinOrder;
	private $edgeLogicConstraints = array();
	+ private $edgeLogicConstraintsAreValid = false;

	protected function getPageCursors(array $page) {
	return array(
	$this->getResultCursor(head($page)),
	$this->getResultCursor(last($page)),
	);
	}

	protected function getResultCursor($object) {
	if (!is_object($object)) {
	throw new Exception(
	pht(
	'Expected object, got "%s".',
	gettype($object)));
	}

	return $object->getID();
	}

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

	if ($this->beforeID !== null) {
	$page = array_reverse($page, $preserve_keys = true);
	list($before, $after) = $this->getPageCursors($page);
	$this->beforeID = $before;
	} else {
	list($before, $after) = $this->getPageCursors($page);
	$this->afterID = $after;
	}
	}

	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) {
	$limit = $pager->getPageSize();

	$this->setLimit($limit + 1);

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

	$results = $this->execute();
	$count = count($results);

	$sliced_results = $pager->sliceResults($results);
	if ($sliced_results) {
	list($before, $after) = $this->getPageCursors($sliced_results);

	if ($pager->getBeforeID() \|\| ($count > $limit)) {
	$pager->setNextPageID($after);
	}

	if ($pager->getAfterID() \|\|
	($pager->getBeforeID() && ($count > $limit))) {
	$pager->setPrevPageID($before);
	}
	}

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


	/* -( Building Query Clauses )--------------------------------------------- */


	/**
	* @task clauses
	*/
	protected function buildSelectClause(AphrontDatabaseConnection $conn) {
	$parts = $this->buildSelectClauseParts($conn);
	return $this->formatSelectClause($parts);
	}


	/**
	* @task clauses
	*/
	protected function buildSelectClauseParts(AphrontDatabaseConnection $conn) {
	$select = array();

	$alias = $this->getPrimaryTableAlias();
	if ($alias) {
	$select[] = qsprintf($conn, '%T.*', $alias);
	} else {
	$select[] = '*';
	}

	$select[] = $this->buildEdgeLogicSelectClause($conn);

	return $select;
	}


	/**
	* @task clauses
	*/
	protected function buildJoinClause(AphrontDatabaseConnection $conn) {
	$joins = $this->buildJoinClauseParts($conn);
	return $this->formatJoinClause($joins);
	}


	/**
	* @task clauses
	*/
	protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
	$joins = array();
	$joins[] = $this->buildEdgeLogicJoinClause($conn);
	return $joins;
	}


	/**
	* @task clauses
	*/
	protected function buildWhereClause(AphrontDatabaseConnection $conn) {
	$where = $this->buildWhereClauseParts($conn);
	return $this->formatWhereClause($where);
	}


	/**
	* @task clauses
	*/
	protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
	$where = array();
	$where[] = $this->buildPagingClause($conn);
	$where[] = $this->buildEdgeLogicWhereClause($conn);
	return $where;
	}


	/**
	* @task clauses
	*/
	protected function buildHavingClause(AphrontDatabaseConnection $conn) {
	$having = $this->buildHavingClauseParts($conn);
	return $this->formatHavingClause($having);
	}


	/**
	* @task clauses
	*/
	protected function buildHavingClauseParts(AphrontDatabaseConnection $conn) {
	$having = array();
	$having[] = $this->buildEdgeLogicHavingClause($conn);
	return $having;
	}


	/**
	* @task clauses
	*/
	protected function buildGroupClause(AphrontDatabaseConnection $conn) {
	if (!$this->shouldGroupQueryResultRows()) {
	return '';
	}

	return qsprintf(
	$conn,
	'GROUP BY %Q',
	$this->getApplicationSearchObjectPHIDColumn());
	}


	/**
	* @task clauses
	*/
	protected function shouldGroupQueryResultRows() {
	if ($this->shouldGroupEdgeLogicResultRows()) {
	return true;
	}

	if ($this->getApplicationSearchMayJoinMultipleRows()) {
	return true;
	}

	return false;
	}



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


	/**
	* @task paging
	*/
	protected function buildPagingClause(AphrontDatabaseConnection $conn) {
	$orderable = $this->getOrderableColumns();
	$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,
	));
	}


	/**
	* @task paging
	*/
	protected function getPagingValueMap($cursor, array $keys) {
	return array(
	'id' => $cursor,
	);
	}


	/**
	* @task paging
	*/
	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;
	}


	/**
	* @task paging
	*/
	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.
	* @task paging
	*/
	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 )---------------------------------------------------- */


	/**
	* Select a result ordering.
	*
	* This is a high-level method which selects an ordering from a predefined
	* list of builtin orders, as provided by @{method:getBuiltinOrders}. These
	* options are user-facing and not exhaustive, but are generally convenient
	* and meaningful.
	*
	* You can also use @{method:setOrderVector} to specify a low-level ordering
	* across individual orderable columns. This offers greater control but is
	* also more involved.
	*
	* @param string Key of a builtin order supported by this query.
	* @return this
	* @task order
	*/
	public function setOrder($order) {
	$orders = $this->getBuiltinOrders();

	if (empty($orders[$order])) {
	throw new Exception(
	pht(
	'Query "%s" does not support a builtin order "%s". Supported orders '.
	'are: %s.',
	get_class($this),
	$order,
	implode(', ', array_keys($orders))));
	}

	$this->builtinOrder = $order;
	$this->orderVector = null;

	return $this;
	}


	/**
	* Get builtin orders for this class.
	*
	* In application UIs, we want to be able to present users with a small
	* selection of meaningful order options (like "Order by Title") rather than
	* an exhaustive set of column ordering options.
	*
	* Meaningful user-facing orders are often really orders across multiple
	* columns: for example, a "title" ordering is usually implemented as a
	* "title, id" ordering under the hood.
	*
	* Builtin orders provide a mapping from convenient, understandable
	* user-facing orders to implementations.
	*
	* A builtin order should provide these keys:
	*
	* - `vector` (`list<string>`): The actual order vector to use.
	* - `name` (`string`): Human-readable order name.
	*
	* @return map<string, wild> Map from builtin order keys to specification.
	* @task order
	*/
	public function getBuiltinOrders() {
	$orders = array(
	'newest' => array(
	'vector' => array('id'),
	'name' => pht('Creation (Newest First)'),
	'aliases' => array('created'),
	),
	'oldest' => array(
	'vector' => array('-id'),
	'name' => pht('Creation (Oldest First)'),
	),
	);

	$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;
	$orders[$full_key] = array(
	'vector' => array($full_key, 'id'),
	'name' => $field->getFieldName(),
	);
	}
	}

	return $orders;
	}


	/**
	* Set a low-level column ordering.
	*
	* This is a low-level method which offers granular control over column
	* ordering. In most cases, applications can more easily use
	* @{method:setOrder} to choose a high-level builtin order.
	*
	* To set an order vector, specify a list of order keys as provided by
	* @{method:getOrderableColumns}.
	*
	* @param PhabricatorQueryOrderVector\|list<string> List of order keys.
	* @return this
	* @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;
	}


	/**
	* Get the effective order vector.
	*
	* @return PhabricatorQueryOrderVector Effective vector.
	* @task order
	*/
	protected function getOrderVector() {
	if (!$this->orderVector) {
	if ($this->builtinOrder !== null) {
	$builtin_order = idx($this->getBuiltinOrders(), $this->builtinOrder);
	$vector = $builtin_order['vector'];
	} else {
	$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() {
	$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();
	$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->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);
	}


	/* -( Integration with CustomField )--------------------------------------- */


	/**
	* @task customfield
	*/
	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;
	}


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


	/* -( Edge Logic )--------------------------------------------------------- */


	+ /**
	+ * Convenience method for specifying edge logic constraints with a list of
	+ * PHIDs.
	+ *
	+ * @param const Edge constant.
	+ * @param const Constraint operator.
	+ * @param list<phid> List of PHIDs.
	+ * @return this
	+ * @task edgelogic
	+ */
	+ public function withEdgeLogicPHIDs($edge_type, $operator, array $phids) {
	+ $constraints = array();
	+ foreach ($phids as $phid) {
	+ $constraints[] = new PhabricatorQueryConstraint($operator, $phid);
	+ }
	+
	+ return $this->withEdgeLogicConstraints($edge_type, $constraints);
	+ }
	+
	+
	/**
	* @task edgelogic
	*/
	public function withEdgeLogicConstraints($edge_type, array $constraints) {
	assert_instances_of($constraints, 'PhabricatorQueryConstraint');

	$constraints = mgroup($constraints, 'getOperator');
	foreach ($constraints as $operator => $list) {
	foreach ($list as $item) {
	$value = $item->getValue();
	$this->edgeLogicConstraints[$edge_type][$operator][$value] = $item;
	}
	}

	+ $this->edgeLogicConstraintsAreValid = false;
	+
	return $this;
	}


	/**
	* @task edgelogic
	*/
	public function buildEdgeLogicSelectClause(AphrontDatabaseConnection $conn) {
	$select = array();

	+ $this->validateEdgeLogicConstraints();
	+
	foreach ($this->edgeLogicConstraints as $type => $constraints) {
	foreach ($constraints as $operator => $list) {
	$alias = $this->getEdgeLogicTableAlias($operator, $type);
	switch ($operator) {
	case PhabricatorQueryConstraint::OPERATOR_AND:
	if (count($list) > 1) {
	$select[] = qsprintf(
	$conn,
	'COUNT(DISTINCT(%T.dst)) %T',
	$alias,
	$this->buildEdgeLogicTableAliasCount($alias));
	}
	break;
	default:
	break;
	}
	}
	}

	return $select;
	}


	/**
	* @task edgelogic
	*/
	public function buildEdgeLogicJoinClause(AphrontDatabaseConnection $conn) {
	$edge_table = PhabricatorEdgeConfig::TABLE_NAME_EDGE;
	$phid_column = $this->getApplicationSearchObjectPHIDColumn();

	$joins = array();
	foreach ($this->edgeLogicConstraints as $type => $constraints) {

	$op_null = PhabricatorQueryConstraint::OPERATOR_NULL;
	$has_null = isset($constraints[$op_null]);

	foreach ($constraints as $operator => $list) {
	$alias = $this->getEdgeLogicTableAlias($operator, $type);
	switch ($operator) {
	case PhabricatorQueryConstraint::OPERATOR_NOT:
	$joins[] = qsprintf(
	$conn,
	'LEFT JOIN %T %T ON %Q = %T.src AND %T.type = %d
	AND %T.dst IN (%Ls)',
	$edge_table,
	$alias,
	$phid_column,
	$alias,
	$alias,
	$type,
	$alias,
	mpull($list, 'getValue'));
	break;
	case PhabricatorQueryConstraint::OPERATOR_AND:
	case PhabricatorQueryConstraint::OPERATOR_OR:
	// If we're including results with no matches, we have to degrade
	// this to a LEFT join. We'll use WHERE to select matching rows
	// later.
	if ($has_null) {
	$join_type = 'LEFT';
	} else {
	$join_type = '';
	}

	$joins[] = qsprintf(
	$conn,
	'%Q JOIN %T %T ON %Q = %T.src AND %T.type = %d
	AND %T.dst IN (%Ls)',
	$join_type,
	$edge_table,
	$alias,
	$phid_column,
	$alias,
	$alias,
	$type,
	$alias,
	mpull($list, 'getValue'));
	break;
	case PhabricatorQueryConstraint::OPERATOR_NULL:
	$joins[] = qsprintf(
	$conn,
	'LEFT JOIN %T %T ON %Q = %T.src AND %T.type = %d',
	$edge_table,
	$alias,
	$phid_column,
	$alias,
	$alias,
	$type);
	break;
	}
	}
	}

	return $joins;
	}


	/**
	* @task edgelogic
	*/
	public function buildEdgeLogicWhereClause(AphrontDatabaseConnection $conn) {
	$where = array();

	foreach ($this->edgeLogicConstraints as $type => $constraints) {

	$full = array();
	$null = array();

	$op_null = PhabricatorQueryConstraint::OPERATOR_NULL;
	$has_null = isset($constraints[$op_null]);

	foreach ($constraints as $operator => $list) {
	$alias = $this->getEdgeLogicTableAlias($operator, $type);
	switch ($operator) {
	case PhabricatorQueryConstraint::OPERATOR_NOT:
	$full[] = qsprintf(
	$conn,
	'%T.dst IS NULL',
	$alias);
	break;
	case PhabricatorQueryConstraint::OPERATOR_AND:
	case PhabricatorQueryConstraint::OPERATOR_OR:
	if ($has_null) {
	$full[] = qsprintf(
	$conn,
	'%T.dst IS NOT NULL',
	$alias);
	}
	break;
	case PhabricatorQueryConstraint::OPERATOR_NULL:
	$null[] = qsprintf(
	$conn,
	'%T.dst IS NULL',
	$alias);
	break;
	}
	}

	if ($full && $null) {
	$full = $this->formatWhereSubclause($full);
	$null = $this->formatWhereSubclause($null);
	$where[] = qsprintf($conn, '(%Q OR %Q)', $full, $null);
	} else if ($full) {
	foreach ($full as $condition) {
	$where[] = $condition;
	}
	} else if ($null) {
	foreach ($null as $condition) {
	$where[] = $condition;
	}
	}
	}

	return $where;
	}


	/**
	* @task edgelogic
	*/
	public function buildEdgeLogicHavingClause(AphrontDatabaseConnection $conn) {
	$having = array();

	foreach ($this->edgeLogicConstraints as $type => $constraints) {
	foreach ($constraints as $operator => $list) {
	$alias = $this->getEdgeLogicTableAlias($operator, $type);
	switch ($operator) {
	case PhabricatorQueryConstraint::OPERATOR_AND:
	if (count($list) > 1) {
	$having[] = qsprintf(
	$conn,
	'%T = %d',
	$this->buildEdgeLogicTableAliasCount($alias),
	count($list));
	}
	break;
	}
	}
	}

	return $having;
	}


	/**
	* @task edgelogic
	*/
	public function shouldGroupEdgeLogicResultRows() {
	foreach ($this->edgeLogicConstraints as $type => $constraints) {
	foreach ($constraints as $operator => $list) {
	switch ($operator) {
	case PhabricatorQueryConstraint::OPERATOR_NOT:
	case PhabricatorQueryConstraint::OPERATOR_AND:
	case PhabricatorQueryConstraint::OPERATOR_OR:
	if (count($list) > 1) {
	return true;
	}
	break;
	case PhabricatorQueryConstraint::OPERATOR_NULL:
	return true;
	}
	}
	}

	return false;
	}


	/**
	* @task edgelogic
	*/
	private function getEdgeLogicTableAlias($operator, $type) {
	return 'edgelogic_'.$operator.'_'.$type;
	}


	/**
	* @task edgelogic
	*/
	private function buildEdgeLogicTableAliasCount($alias) {
	return $alias.'_count';
	}


	+ /**
	+ * Select certain edge logic constraint values.
	+ *
	+ * @task edgelogic
	+ */
	+ protected function getEdgeLogicValues(
	+ array $edge_types,
	+ array $operators) {
	+
	+ $values = array();
	+
	+ $constraint_lists = $this->edgeLogicConstraints;
	+ if ($edge_types) {
	+ $constraint_lists = array_select_keys($constraint_lists, $edge_types);
	+ }
	+
	+ foreach ($constraint_lists as $type => $constraints) {
	+ if ($operators) {
	+ $constraints = array_select_keys($constraints, $operators);
	+ }
	+ foreach ($constraints as $operator => $list) {
	+ foreach ($list as $constraint) {
	+ $values[] = $constraint->getValue();
	+ }
	+ }
	+ }
	+
	+ return $values;
	+ }
	+
	+
	+ /**
	+ * Validate edge logic constraints for the query.
	+ *
	+ * @return this
	+ * @task edgelogic
	+ */
	+ private function validateEdgeLogicConstraints() {
	+ if ($this->edgeLogicConstraintsAreValid) {
	+ return $this;
	+ }
	+
	+ // This should probably be more modular, eventually, but we only do
	+ // project-based edge logic today.
	+
	+ $project_phids = $this->getEdgeLogicValues(
	+ array(
	+ PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
	+ ),
	+ array(
	+ PhabricatorQueryConstraint::OPERATOR_AND,
	+ PhabricatorQueryConstraint::OPERATOR_OR,
	+ PhabricatorQueryConstraint::OPERATOR_NOT,
	+ ));
	+ if ($project_phids) {
	+ $projects = id(new PhabricatorProjectQuery())
	+ ->setViewer($this->getViewer())
	+ ->setParentQuery($this)
	+ ->withPHIDs($project_phids)
	+ ->execute();
	+ $projects = mpull($projects, null, 'getPHID');
	+ foreach ($project_phids as $phid) {
	+ if (empty($projects[$phid])) {
	+ throw new PhabricatorEmptyQueryException(
	+ pht(
	+ 'This query is constrained by a project you do not have '.
	+ 'permission to see.'));
	+ }
	+ }
	+ }
	+
	+ $this->edgeLogicConstraintsAreValid = true;
	+
	+ return $this;
	+ }
	+
	+
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jul 3, 2:49 PM (9 h, 21 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 165905
Default Alt Text: (136 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions