No OneTemporary
Actions

Size

37 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/controller/DiffusionRepositoryController.php b/src/applications/diffusion/controller/DiffusionRepositoryController.php
	index 2268f59aef..4d51da9c60 100644
	--- a/src/applications/diffusion/controller/DiffusionRepositoryController.php
	+++ b/src/applications/diffusion/controller/DiffusionRepositoryController.php
	@@ -1,559 +1,571 @@
	<?php

	final class DiffusionRepositoryController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	public function processRequest() {
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$content = array();

	$crumbs = $this->buildCrumbs();
	$content[] = $crumbs;

	$content[] = $this->buildPropertiesTable($drequest->getRepository());
	$phids = array();

	try {
	$history_results = $this->callConduitWithDiffusionRequest(
	'diffusion.historyquery',
	array(
	'commit' => $drequest->getCommit(),
	'path' => $drequest->getPath(),
	'offset' => 0,
	'limit' => 15));
	$history = DiffusionPathChange::newFromConduit(
	$history_results['pathChanges']);

	foreach ($history as $item) {
	$data = $item->getCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}
	$history_exception = null;
	} catch (Exception $ex) {
	$history_results = null;
	$history = null;
	$history_exception = $ex;
	}

	try {
	$browse_results = DiffusionBrowseResultSet::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.browsequery',
	array(
	'path' => $drequest->getPath(),
	'commit' => $drequest->getCommit(),
	)));
	$browse_paths = $browse_results->getPaths();

	foreach ($browse_paths as $item) {
	$data = $item->getLastCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}

	$browse_exception = null;
	} catch (Exception $ex) {
	$browse_results = null;
	$browse_paths = null;
	$browse_exception = $ex;
	}

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

	if ($browse_results) {
	$readme = $this->callConduitWithDiffusionRequest(
	'diffusion.readmequery',
	array(
	'paths' => $browse_results->getPathDicts()
	));
	} else {
	$readme = null;
	}

	$content[] = $this->buildHistoryTable(
	$history_results,
	$history,
	$history_exception,
	$handles);

	$content[] = $this->buildBrowseTable(
	$browse_results,
	$browse_paths,
	$browse_exception,
	$handles);

	try {
	$content[] = $this->buildTagListTable($drequest);
	} catch (Exception $ex) {
	if (!$repository->isImporting()) {
	$content[] = $this->renderStatusMessage(
	pht('Unable to Load Tags'),
	$ex->getMessage());
	}
	}

	try {
	$content[] = $this->buildBranchListTable($drequest);
	} catch (Exception $ex) {
	if (!$repository->isImporting()) {
	$content[] = $this->renderStatusMessage(
	pht('Unable to Load Branches'),
	$ex->getMessage());
	}
	}

	if ($readme) {
	$box = new PHUIBoxView();
	$box->setShadow(true);
	$box->appendChild($readme);
	$box->addPadding(PHUI::PADDING_LARGE);

	$panel = new AphrontPanelView();
	$panel->setHeader(pht('README'));
	$panel->setNoBackground();
	$panel->appendChild($box);
	$content[] = $panel;
	}

	return $this->buildApplicationPage(
	$content,
	array(
	'title' => $drequest->getRepository()->getName(),
	'device' => true,
	));
	}

	private function buildPropertiesTable(PhabricatorRepository $repository) {
	$user = $this->getRequest()->getUser();

	$header = id(new PHUIHeaderView())
	->setHeader($repository->getName())
	->setUser($user)
	->setPolicyObject($repository);

	if (!$repository->isTracked()) {
	$header->setStatus('policy-noone', '', pht('Inactive'));
	} else if ($repository->isImporting()) {
	$header->setStatus('time', 'red', pht('Importing...'));
	} else {
	$header->setStatus('oh-ok', '', pht('Active'));
	}


	$actions = $this->buildActionList($repository);

	$view = id(new PHUIPropertyListView())
	->setUser($user);
	$view->addProperty(pht('Callsign'), $repository->getCallsign());

	if ($repository->isHosted()) {
	$serve_off = PhabricatorRepository::SERVE_OFF;
	$callsign = $repository->getCallsign();
	$repo_path = '/diffusion/'.$callsign.'/';

	$serve_ssh = $repository->getServeOverSSH();
	if ($serve_ssh !== $serve_off) {
	$uri = new PhutilURI(PhabricatorEnv::getProductionURI($repo_path));

	if ($repository->isSVN()) {
	$uri->setProtocol('svn+ssh');
	} else {
	$uri->setProtocol('ssh');
	}

	$ssh_user = PhabricatorEnv::getEnvConfig('diffusion.ssh-user');
	if ($ssh_user) {
	$uri->setUser($ssh_user);
	}

	// This isn't quite right, but for now it's probably better to drop
	// the port than sometimes show ":8080", etc. Using most VCS commands
	// against nonstandard ports is a huge pain so few installs are likely
	// to configure SSH on a nonstandard port.
	$uri->setPort(null);

	$clone_uri = $this->renderCloneURI(
	$uri,
	$serve_ssh,
	'/settings/panel/ssh/');

	$view->addProperty(pht('Clone URI (SSH)'), $clone_uri);
	}

	$serve_http = $repository->getServeOverHTTP();
	if ($serve_http !== $serve_off) {
	$http_uri = PhabricatorEnv::getProductionURI($repo_path);

	$clone_uri = $this->renderCloneURI(
	$http_uri,
	$serve_http,
	PhabricatorEnv::getEnvConfig('diffusion.allow-http-auth')
	? '/settings/panel/vcspassword/'
	: null);

	$view->addProperty(pht('Clone URI (HTTP)'), $clone_uri);
	}
	} else {
	switch ($repository->getVersionControlSystem()) {
	case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
	case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
	$view->addProperty(
	pht('Clone URI'),
	$this->renderCloneURI(
	$repository->getPublicRemoteURI()));
	break;
	case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
	$view->addProperty(
	pht('Repository Root'),
	$this->renderCloneURI(
	$repository->getPublicRemoteURI()));
	break;
	}
	}

	$description = $repository->getDetail('description');
	if (strlen($description)) {
	$description = PhabricatorMarkupEngine::renderOneObject(
	$repository,
	'description',
	$user);
	$view->addSectionHeader(pht('Description'));
	$view->addTextContent($description);
	}

	$view->setActionList($actions);

	return id(new PHUIObjectBoxView())
	->setHeader($header)
	->addPropertyList($view);

	}

	private function buildBranchListTable(DiffusionRequest $drequest) {
	$viewer = $this->getRequest()->getUser();

	if ($drequest->getBranch() === null) {
	return null;
	}

	$limit = 15;

	$branches = DiffusionBranchInformation::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.branchquery',
	array(
	'limit' => $limit + 1,
	)));
	if (!$branches) {
	return null;
	}

	$more_branches = (count($branches) > $limit);
	$branches = array_slice($branches, 0, $limit);

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIdentifiers(mpull($branches, 'getHeadCommitIdentifier'))
	->withRepository($drequest->getRepository())
	->execute();

	$table = id(new DiffusionBranchTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setBranches($branches)
	->setCommits($commits);

	$panel = id(new AphrontPanelView())
	->setHeader(pht('Branches'))
	->setNoBackground();

	if ($more_branches) {
	$panel->setCaption(pht('Showing %d branches.', $limit));
	}

	$panel->addButton(
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'branches',
	)),
	'class' => 'grey button',
	),
	pht("Show All Branches \xC2\xBB")));

	$panel->appendChild($table);

	return $panel;
	}

	private function buildTagListTable(DiffusionRequest $drequest) {
	$viewer = $this->getRequest()->getUser();

	$tag_limit = 15;
	$tags = array();
	try {
	$tags = DiffusionRepositoryTag::newFromConduit(
	$this->callConduitWithDiffusionRequest(
	'diffusion.tagsquery',
	array(
	// On the home page, we want to find tags on any branch.
	'commit' => null,
	'limit' => $tag_limit + 1,
	)));
	} catch (ConduitException $e) {
	if ($e->getMessage() != 'ERR-UNSUPPORTED-VCS') {
	throw $e;
	}
	}

	if (!$tags) {
	return null;
	}

	$more_tags = (count($tags) > $tag_limit);
	$tags = array_slice($tags, 0, $tag_limit);

	$commits = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withIdentifiers(mpull($tags, 'getCommitIdentifier'))
	->withRepository($drequest->getRepository())
	->needCommitData(true)
	->execute();

	$view = id(new DiffusionTagListView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setTags($tags)
	->setCommits($commits);

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

	$panel = id(new AphrontPanelView())
	->setHeader(pht('Tags'))
	->setNoBackground(true);

	if ($more_tags) {
	$panel->setCaption(pht('Showing the %d most recent tags.', $tag_limit));
	}

	$panel->addButton(
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'tags',
	)),
	'class' => 'grey button',
	),
	pht("Show All Tags \xC2\xBB")));
	$panel->appendChild($view);

	return $panel;
	}

	private function buildActionList(PhabricatorRepository $repository) {
	$viewer = $this->getRequest()->getUser();

	$view_uri = $this->getApplicationURI($repository->getCallsign().'/');
	$edit_uri = $this->getApplicationURI($repository->getCallsign().'/edit/');

	$view = id(new PhabricatorActionListView())
	->setUser($viewer)
	->setObject($repository)
	->setObjectURI($view_uri);

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

	$view->addAction(
	id(new PhabricatorActionView())
	->setName(pht('Edit Repository'))
	->setIcon('edit')
	->setHref($edit_uri)
	->setWorkflow(!$can_edit)
	->setDisabled(!$can_edit));

	+ if ($repository->isHosted()) {
	+ $callsign = $repository->getCallsign();
	+ $push_uri = $this->getApplicationURI(
	+ 'pushlog/?repositories=r'.$callsign);
	+
	+ $view->addAction(
	+ id(new PhabricatorActionView())
	+ ->setName(pht('View Push Logs'))
	+ ->setIcon('transcript')
	+ ->setHref($push_uri));
	+ }
	+
	return $view;
	}

	private function buildHistoryTable(
	$history_results,
	$history,
	$history_exception,
	array $handles) {

	$request = $this->getRequest();
	$viewer = $request->getUser();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	if ($history_exception) {
	if ($repository->isImporting()) {
	return $this->renderStatusMessage(
	pht('Still Importing...'),
	pht(
	'This repository is still importing. History is not yet '.
	'available.'));
	} else {
	return $this->renderStatusMessage(
	pht('Unable to Retrieve History'),
	$history_exception->getMessage());
	}
	}

	$history_table = id(new DiffusionHistoryTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHandles($handles)
	->setHistory($history);

	// TODO: Super sketchy.
	$history_table->loadRevisions();

	if ($history_results) {
	$history_table->setParents($history_results['parents']);
	}

	$history_table->setIsHead(true);

	$callsign = $drequest->getRepository()->getCallsign();
	$all = phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'history',
	)),
	),
	pht('View Full Commit History'));

	$panel = new AphrontPanelView();
	$panel->setHeader(pht("Recent Commits · %s", $all));
	$panel->appendChild($history_table);
	$panel->setNoBackground();

	return $panel;
	}

	private function buildBrowseTable(
	$browse_results,
	$browse_paths,
	$browse_exception,
	array $handles) {

	$request = $this->getRequest();
	$viewer = $request->getUser();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	if ($browse_exception) {
	if ($repository->isImporting()) {
	// The history table renders a useful message.
	return null;
	} else {
	return $this->renderStatusMessage(
	pht('Unable to Retrieve Paths'),
	$browse_exception->getMessage());
	}
	}

	$browse_table = id(new DiffusionBrowseTableView())
	->setUser($viewer)
	->setDiffusionRequest($drequest)
	->setHandles($handles);
	if ($browse_paths) {
	$browse_table->setPaths($browse_paths);
	} else {
	$browse_table->setPaths(array());
	}

	$browse_uri = $drequest->generateURI(array('action' => 'browse'));

	$browse_panel = new AphrontPanelView();
	$browse_panel->setHeader(
	phutil_tag(
	'a',
	array('href' => $browse_uri),
	pht('Browse Repository')));
	$browse_panel->appendChild($browse_table);
	$browse_panel->setNoBackground();

	return $browse_panel;
	}

	private function renderCloneURI(
	$uri,
	$serve_mode = null,
	$manage_uri = null) {

	require_celerity_resource('diffusion-icons-css');

	Javelin::initBehavior('select-on-click');

	$input = javelin_tag(
	'input',
	array(
	'type' => 'text',
	'value' => (string)$uri,
	'class' => 'diffusion-clone-uri',
	'sigil' => 'select-on-click',
	));

	$extras = array();
	if ($serve_mode) {
	if ($serve_mode === PhabricatorRepository::SERVE_READONLY) {
	$extras[] = pht('(Read Only)');
	}
	}

	if ($manage_uri) {
	if ($this->getRequest()->getUser()->isLoggedIn()) {
	$extras[] = phutil_tag(
	'a',
	array(
	'href' => $manage_uri,
	),
	pht('Manage Credentials'));
	}
	}

	if ($extras) {
	$extras = phutil_implode_html(' ', $extras);
	$extras = phutil_tag(
	'div',
	array(
	'class' => 'diffusion-clone-extras',
	),
	$extras);
	}

	return array($input, $extras);
	}

	}
	diff --git a/src/applications/repository/query/PhabricatorRepositoryPushLogQuery.php b/src/applications/repository/query/PhabricatorRepositoryPushLogQuery.php
	index 3d2900aef1..9eae4263aa 100644
	--- a/src/applications/repository/query/PhabricatorRepositoryPushLogQuery.php
	+++ b/src/applications/repository/query/PhabricatorRepositoryPushLogQuery.php
	@@ -1,86 +1,99 @@
	<?php

	final class PhabricatorRepositoryPushLogQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $repositoryPHIDs;
	+ private $pusherPHIDs;

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

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

	+ public function withPusherPHIDs(array $pusher_phids) {
	+ $this->pusherPHIDs = $pusher_phids;
	+ return $this;
	+ }
	+
	protected function loadPage() {
	$table = new PhabricatorRepositoryPushLog();
	$conn_r = $table->establishConnection('r');

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

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

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

	foreach ($logs as $key => $log) {
	$phid = $log->getRepositoryPHID();
	if (empty($repositories[$phid])) {
	unset($logs[$key]);
	continue;
	}
	$log->attachRepository($repositories[$phid]);
	}

	return $logs;
	}


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

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

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

	+ if ($this->pusherPHIDs) {
	+ $where[] = qsprintf(
	+ $conn_r,
	+ 'pusherPHID in (%Ls)',
	+ $this->pusherPHIDs);
	+ }
	+
	$where[] = $this->buildPagingClause($conn_r);

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


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

	}
	diff --git a/src/applications/repository/query/PhabricatorRepositoryPushLogSearchEngine.php b/src/applications/repository/query/PhabricatorRepositoryPushLogSearchEngine.php
	index 1a7449ff69..938ef48d12 100644
	--- a/src/applications/repository/query/PhabricatorRepositoryPushLogSearchEngine.php
	+++ b/src/applications/repository/query/PhabricatorRepositoryPushLogSearchEngine.php
	@@ -1,49 +1,106 @@
	<?php

	final class PhabricatorRepositoryPushLogSearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$saved = new PhabricatorSavedQuery();

	+ $saved->setParameter(
	+ 'repositoryPHIDs',
	+ $this->readPHIDsFromRequest(
	+ $request,
	+ 'repositories',
	+ array(
	+ PhabricatorRepositoryPHIDTypeRepository::TYPECONST,
	+ )));
	+
	+ $saved->setParameter(
	+ 'pusherPHIDs',
	+ $this->readUsersFromRequest(
	+ $request,
	+ 'pushers'));
	+
	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new PhabricatorRepositoryPushLogQuery());

	+ $repository_phids = $saved->getParameter('repositoryPHIDs');
	+ if ($repository_phids) {
	+ $query->withRepositoryPHIDs($repository_phids);
	+ }
	+
	+ $pusher_phids = $saved->getParameter('pusherPHIDs');
	+ if ($pusher_phids) {
	+ $query->withPusherPHIDs($pusher_phids);
	+ }
	+
	return $query;
	}

	public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved_query) {

	+ $repository_phids = $saved_query->getParameter('repositoryPHIDs', array());
	+ $pusher_phids = $saved_query->getParameter('pusherPHIDs', array());
	+
	+ $all_phids = array_merge(
	+ $repository_phids,
	+ $pusher_phids);
	+
	+ if ($all_phids) {
	+ $handles = id(new PhabricatorHandleQuery())
	+ ->setViewer($this->requireViewer())
	+ ->withPHIDs($all_phids)
	+ ->execute();
	+ } else {
	+ $handles = array();
	+ }
	+
	+ $repository_handles = array_select_keys($handles, $repository_phids);
	+ $pusher_handles = array_select_keys($handles, $pusher_phids);
	+
	+ $form
	+ ->appendChild(
	+ id(new AphrontFormTokenizerControl())
	+ ->setDatasource('/typeahead/common/repositories/')
	+ ->setName('repositories')
	+ ->setLabel(pht('Repositories'))
	+ ->setValue($repository_handles))
	+ ->appendChild(
	+ id(new AphrontFormTokenizerControl())
	+ ->setDatasource('/typeahead/common/accounts/')
	+ ->setName('pushers')
	+ ->setLabel(pht('Pushers'))
	+ ->setValue($pusher_handles));
	}

	protected function getURI($path) {
	return '/diffusion/pushlog/'.$path;
	}

	public function getBuiltinQueryNames() {
	$names = array(
	'all' => pht('All Push Logs'),
	);

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {

	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	switch ($query_key) {
	case 'all':
	return $query;
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	}
	diff --git a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	index 3011671e3a..d01e526e95 100644
	--- a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	+++ b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	@@ -1,551 +1,601 @@
	<?php

	/**
	* Represents an abstract search engine for an application. It supports
	* creating and storing saved queries.
	*
	* @task builtin Builtin Queries
	* @task uri Query URIs
	* @task dates Date Filters
	* @task read Reading Utilities
	*
	* @group search
	*/
	abstract class PhabricatorApplicationSearchEngine {

	private $viewer;
	private $errors = array();
	private $customFields = false;

	public function setViewer(PhabricatorUser $viewer) {
	$this->viewer = $viewer;
	return $this;
	}

	protected function requireViewer() {
	if (!$this->viewer) {
	throw new Exception("Call setViewer() before using an engine!");
	}
	return $this->viewer;
	}

	/**
	* Create a saved query object from the request.
	*
	* @param AphrontRequest The search request.
	* @return PhabricatorSavedQuery
	*/
	abstract public function buildSavedQueryFromRequest(
	AphrontRequest $request);

	/**
	* Executes the saved query.
	*
	* @param PhabricatorSavedQuery The saved query to operate on.
	* @return The result of the query.
	*/
	abstract public function buildQueryFromSavedQuery(
	PhabricatorSavedQuery $saved);

	/**
	* Builds the search form using the request.
	*
	* @param AphrontFormView Form to populate.
	* @param PhabricatorSavedQuery The query from which to build the form.
	* @return void
	*/
	abstract public function buildSearchForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $query);

	public function getErrors() {
	return $this->errors;
	}

	public function addError($error) {
	$this->errors[] = $error;
	return $this;
	}

	/**
	* Return an application URI corresponding to the results page of a query.
	* Normally, this is something like `/application/query/QUERYKEY/`.
	*
	* @param string The query key to build a URI for.
	* @return string URI where the query can be executed.
	* @task uri
	*/
	public function getQueryResultsPageURI($query_key) {
	return $this->getURI('query/'.$query_key.'/');
	}


	/**
	* Return an application URI for query management. This is used when, e.g.,
	* a query deletion operation is cancelled.
	*
	* @return string URI where queries can be managed.
	* @task uri
	*/
	public function getQueryManagementURI() {
	return $this->getURI('query/edit/');
	}


	/**
	* Return the URI to a path within the application. Used to construct default
	* URIs for management and results.
	*
	* @return string URI to path.
	* @task uri
	*/
	abstract protected function getURI($path);


	public function newSavedQuery() {
	return id(new PhabricatorSavedQuery())
	->setEngineClassName(get_class($this));
	}


	public function addNavigationItems(PHUIListView $menu) {
	$viewer = $this->requireViewer();

	$menu->newLabel(pht('Queries'));

	$named_queries = $this->loadEnabledNamedQueries();

	foreach ($named_queries as $query) {
	$key = $query->getQueryKey();
	$uri = $this->getQueryResultsPageURI($key);
	$menu->newLink($query->getQueryName(), $uri, 'query/'.$key);
	}

	if ($viewer->isLoggedIn()) {
	$manage_uri = $this->getQueryManagementURI();
	$menu->newLink(pht('Edit Queries...'), $manage_uri, 'query/edit');
	}

	$menu->newLabel(pht('Search'));
	$advanced_uri = $this->getQueryResultsPageURI('advanced');
	$menu->newLink(pht('Advanced Search'), $advanced_uri, 'query/advanced');

	return $this;
	}

	public function loadAllNamedQueries() {
	$viewer = $this->requireViewer();

	$named_queries = id(new PhabricatorNamedQueryQuery())
	->setViewer($viewer)
	->withUserPHIDs(array($viewer->getPHID()))
	->withEngineClassNames(array(get_class($this)))
	->execute();
	$named_queries = mpull($named_queries, null, 'getQueryKey');

	$builtin = $this->getBuiltinQueries($viewer);
	$builtin = mpull($builtin, null, 'getQueryKey');

	foreach ($named_queries as $key => $named_query) {
	if ($named_query->getIsBuiltin()) {
	if (isset($builtin[$key])) {
	$named_queries[$key]->setQueryName($builtin[$key]->getQueryName());
	unset($builtin[$key]);
	} else {
	unset($named_queries[$key]);
	}
	}

	unset($builtin[$key]);
	}

	$named_queries = msort($named_queries, 'getSortKey');

	return $named_queries + $builtin;
	}

	public function loadEnabledNamedQueries() {
	$named_queries = $this->loadAllNamedQueries();
	foreach ($named_queries as $key => $named_query) {
	if ($named_query->getIsBuiltin() && $named_query->getIsDisabled()) {
	unset($named_queries[$key]);
	}
	}
	return $named_queries;
	}


	/* -( Builtin Queries )---------------------------------------------------- */


	/**
	* @task builtin
	*/
	public function getBuiltinQueries() {
	$names = $this->getBuiltinQueryNames();

	$queries = array();
	$sequence = 0;
	foreach ($names as $key => $name) {
	$queries[$key] = id(new PhabricatorNamedQuery())
	->setUserPHID($this->requireViewer()->getPHID())
	->setEngineClassName(get_class($this))
	->setQueryName($name)
	->setQueryKey($key)
	->setSequence((1 << 24) + $sequence++)
	->setIsBuiltin(true);
	}

	return $queries;
	}


	/**
	* @task builtin
	*/
	public function getBuiltinQuery($query_key) {
	if (!$this->isBuiltinQuery($query_key)) {
	throw new Exception("'{$query_key}' is not a builtin!");
	}
	return idx($this->getBuiltinQueries(), $query_key);
	}


	/**
	* @task builtin
	*/
	protected function getBuiltinQueryNames() {
	return array();
	}


	/**
	* @task builtin
	*/
	public function isBuiltinQuery($query_key) {
	$builtins = $this->getBuiltinQueries();
	return isset($builtins[$query_key]);
	}


	/**
	* @task builtin
	*/
	public function buildSavedQueryFromBuiltin($query_key) {
	throw new Exception("Builtin '{$query_key}' is not supported!");
	}


	/* -( Reading Utilities )--------------------------------------------------- */


	/**
	* Read a list of user PHIDs from a request in a flexible way. This method
	* supports either of these forms:
	*
	* users[]=alincoln&users[]=htaft
	* users=alincoln,htaft
	*
	* Additionally, users can be specified either by PHID or by name.
	*
	* The main goal of this flexibility is to allow external programs to generate
	* links to pages (like "alincoln's open revisions") without needing to make
	* API calls.
	*
	* @param AphrontRequest Request to read user PHIDs from.
	* @param string Key to read in the request.
	* @param list<const> Other permitted PHID types.
	* @return list<phid> List of user PHIDs.
	*
	* @task read
	*/
	protected function readUsersFromRequest(
	AphrontRequest $request,
	$key,
	array $allow_types = array()) {
	$list = $request->getArr($key, null);
	if ($list === null) {
	$list = $request->getStrList($key);
	}

	$phids = array();
	$names = array();
	$allow_types = array_fuse($allow_types);
	$user_type = PhabricatorPHIDConstants::PHID_TYPE_USER;
	foreach ($list as $item) {
	$type = phid_get_type($item);
	phlog($type);
	if ($type == $user_type) {
	$phids[] = $item;
	} else if (isset($allow_types[$type])) {
	$phids[] = $item;
	} else {
	$names[] = $item;
	}
	}

	if ($names) {
	$users = id(new PhabricatorPeopleQuery())
	->setViewer($this->requireViewer())
	->withUsernames($names)
	->execute();
	foreach ($users as $user) {
	$phids[] = $user->getPHID();
	}
	$phids = array_unique($phids);
	}

	return $phids;
	}


	+ /**
	+ * Read a list of generic PHIDs from a request in a flexible way. Like
	+ * @{method:readUsersFromRequest}, this method supports either array or
	+ * comma-delimited forms. Objects can be specified either by PHID or by
	+ * object name.
	+ *
	+ * @param AphrontRequest Request to read PHIDs from.
	+ * @param string Key to read in the request.
	+ * @param list<const> Optional, list of permitted PHID types.
	+ * @return list<phid> List of object PHIDs.
	+ *
	+ * @task read
	+ */
	+ protected function readPHIDsFromRequest(
	+ AphrontRequest $request,
	+ $key,
	+ array $allow_types = array()) {
	+
	+ $list = $request->getArr($key, null);
	+ if ($list === null) {
	+ $list = $request->getStrList($key);
	+ }
	+
	+ if (!$list) {
	+ return array();
	+ }
	+
	+ $objects = id(new PhabricatorObjectQuery())
	+ ->setViewer($this->requireViewer())
	+ ->withNames($list)
	+ ->execute();
	+ $list = mpull($objects, 'getPHID');
	+
	+ if (!$list) {
	+ return array();
	+ }
	+
	+ // If only certain PHID types are allowed, filter out all the others.
	+ if ($allow_types) {
	+ $allow_types = array_fuse($allow_types);
	+ foreach ($list as $key => $phid) {
	+ if (empty($allow_types[phid_get_type($phid)])) {
	+ unset($list[$key]);
	+ }
	+ }
	+ }
	+
	+ return $list;
	+ }
	+
	protected function readBoolFromRequest(
	AphrontRequest $request,
	$key) {
	if (!strlen($request->getStr($key))) {
	return null;
	}
	return $request->getBool($key);
	}


	protected function getBoolFromQuery(PhabricatorSavedQuery $query, $key) {
	$value = $query->getParameter($key);
	if ($value === null) {
	return $value;
	}
	return $value ? 'true' : 'false';
	}


	/* -( Dates )-------------------------------------------------------------- */


	/**
	* @task dates
	*/
	protected function parseDateTime($date_time) {
	if (!strlen($date_time)) {
	return null;
	}

	return PhabricatorTime::parseLocalTime($date_time, $this->requireViewer());
	}


	/**
	* @task dates
	*/
	protected function buildDateRange(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved_query,
	$start_key,
	$start_name,
	$end_key,
	$end_name) {

	$start_str = $saved_query->getParameter($start_key);
	$start = null;
	if (strlen($start_str)) {
	$start = $this->parseDateTime($start_str);
	if (!$start) {
	$this->addError(
	pht(
	'"%s" date can not be parsed.',
	$start_name));
	}
	}


	$end_str = $saved_query->getParameter($end_key);
	$end = null;
	if (strlen($end_str)) {
	$end = $this->parseDateTime($end_str);
	if (!$end) {
	$this->addError(
	pht(
	'"%s" date can not be parsed.',
	$end_name));
	}
	}

	if ($start && $end && ($start >= $end)) {
	$this->addError(
	pht(
	'"%s" must be a date before "%s".',
	$start_name,
	$end_name));
	}

	$form
	->appendChild(
	id(new PHUIFormFreeformDateControl())
	->setName($start_key)
	->setLabel($start_name)
	->setValue($start_str))
	->appendChild(
	id(new AphrontFormTextControl())
	->setName($end_key)
	->setLabel($end_name)
	->setValue($end_str));
	}


	/* -( Pagination )--------------------------------------------------------- */


	public function getPageSize(PhabricatorSavedQuery $saved) {
	return $saved->getParameter('limit', 100);
	}


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


	/**
	* Retrieve an object to use to define custom fields for this search.
	*
	* To integrate with custom fields, subclasses should override this method
	* and return an instance of the application object which implements
	* @{interface:PhabricatorCustomFieldInterface}.
	*
	* @return PhabricatorCustomFieldInterface\|null Object with custom fields.
	* @task appsearch
	*/
	public function getCustomFieldObject() {
	return null;
	}


	/**
	* Get the custom fields for this search.
	*
	* @return PhabricatorCustomFieldList\|null Custom fields, if this search
	* supports custom fields.
	* @task appsearch
	*/
	public function getCustomFieldList() {
	if ($this->customFields === false) {
	$object = $this->getCustomFieldObject();
	if ($object) {
	$fields = PhabricatorCustomField::getObjectFields(
	$object,
	PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
	} else {
	$fields = null;
	}
	$this->customFields = $fields;
	}
	return $this->customFields;
	}


	/**
	* Moves data from the request into a saved query.
	*
	* @param AphrontRequest Request to read.
	* @param PhabricatorSavedQuery Query to write to.
	* @return void
	* @task appsearch
	*/
	protected function readCustomFieldsFromRequest(
	AphrontRequest $request,
	PhabricatorSavedQuery $saved) {

	$list = $this->getCustomFieldList();
	if (!$list) {
	return;
	}

	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);
	$value = $field->readApplicationSearchValueFromRequest(
	$this,
	$request);
	$saved->setParameter($key, $value);
	}
	}


	/**
	* Applies data from a saved query to an executable query.
	*
	* @param PhabricatorCursorPagedPolicyAwareQuery Query to constrain.
	* @param PhabricatorSavedQuery Saved query to read.
	* @return void
	*/
	protected function applyCustomFieldsToQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query,
	PhabricatorSavedQuery $saved) {

	$list = $this->getCustomFieldList();
	if (!$list) {
	return;
	}

	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);
	$value = $field->applyApplicationSearchConstraintToQuery(
	$this,
	$query,
	$saved->getParameter($key));
	}
	}


	/**
	* Get a unique key identifying a field.
	*
	* @param PhabricatorCustomField Field to identify.
	* @return string Unique identifier, suitable for use as an input name.
	*/
	public function getKeyForCustomField(PhabricatorCustomField $field) {
	return 'custom:'.$field->getFieldIndex();
	}


	/**
	* Add inputs to an application search form so the user can query on custom
	* fields.
	*
	* @param AphrontFormView Form to update.
	* @param PhabricatorSavedQuery Values to prefill.
	* @return void
	*/
	protected function appendCustomFieldsToForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved) {

	$list = $this->getCustomFieldList();
	if (!$list) {
	return;
	}

	$phids = array();
	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);
	$value = $saved->getParameter($key);
	$phids[$key] = $field->getRequiredHandlePHIDsForApplicationSearch($value);
	}
	$all_phids = array_mergev($phids);

	$handles = array();
	if ($all_phids) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireViewer())
	->withPHIDs($all_phids)
	->execute();
	}

	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);
	$value = $saved->getParameter($key);
	$field->appendToApplicationSearchForm(
	$this,
	$form,
	$value,
	array_select_keys($handles, $phids[$key]));
	}
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Feb 24, 10:53 PM (19 h, 55 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 851566
Default Alt Text: (37 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions