No OneTemporary
Actions

Size

40 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/macro/query/PhabricatorMacroQuery.php b/src/applications/macro/query/PhabricatorMacroQuery.php
	index a326f97697..83d9f1abd6 100644
	--- a/src/applications/macro/query/PhabricatorMacroQuery.php
	+++ b/src/applications/macro/query/PhabricatorMacroQuery.php
	@@ -1,236 +1,278 @@
	<?php

	final class PhabricatorMacroQuery
	extends PhabricatorCursorPagedPolicyAwareQuery {

	private $ids;
	private $phids;
	private $authors;
	private $names;
	private $nameLike;
	+ private $namePrefix;
	private $dateCreatedAfter;
	private $dateCreatedBefore;
	private $flagColor;

	private $needFiles;

	private $status = 'status-any';
	const STATUS_ANY = 'status-any';
	const STATUS_ACTIVE = 'status-active';
	const STATUS_DISABLED = 'status-disabled';

	public static function getStatusOptions() {
	return array(
	self::STATUS_ACTIVE => pht('Active Macros'),
	self::STATUS_DISABLED => pht('Disabled Macros'),
	self::STATUS_ANY => pht('Active and Disabled Macros'),
	);
	}

	public static function getFlagColorsOptions() {
	$options = array(
	'-1' => pht('(No Filtering)'),
	'-2' => pht('(Marked With Any Flag)'),
	);

	foreach (PhabricatorFlagColor::getColorNameMap() as $color => $name) {
	$options[$color] = $name;
	}

	return $options;
	}

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

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

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

	public function withNameLike($name) {
	$this->nameLike = $name;
	return $this;
	}

	public function withNames(array $names) {
	$this->names = $names;
	return $this;
	}

	+ public function withNamePrefix($prefix) {
	+ $this->namePrefix = $prefix;
	+ return $this;
	+ }
	+
	public function withStatus($status) {
	$this->status = $status;
	return $this;
	}

	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 withFlagColor($flag_color) {
	$this->flagColor = $flag_color;
	return $this;
	}

	public function needFiles($need_files) {
	$this->needFiles = $need_files;
	return $this;
	}

	protected function loadPage() {
	$macro_table = new PhabricatorFileImageMacro();
	$conn = $macro_table->establishConnection('r');

	$rows = queryfx_all(
	$conn,
	'SELECT m.* FROM %T m %Q %Q %Q',
	$macro_table->getTableName(),
	$this->buildWhereClause($conn),
	$this->buildOrderClause($conn),
	$this->buildLimitClause($conn));

	return $macro_table->loadAllFromArray($rows);
	}

	protected function buildWhereClause(AphrontDatabaseConnection $conn) {
	$where = array();

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

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

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

	if ($this->nameLike) {
	$where[] = qsprintf(
	$conn,
	'm.name LIKE %~',
	$this->nameLike);
	}

	if ($this->names) {
	$where[] = qsprintf(
	$conn,
	'm.name IN (%Ls)',
	$this->names);
	}

	+ if (strlen($this->namePrefix)) {
	+ $where[] = qsprintf(
	+ $conn,
	+ 'm.name LIKE %>',
	+ $this->namePrefix);
	+ }
	+
	switch ($this->status) {
	case self::STATUS_ACTIVE:
	$where[] = qsprintf(
	$conn,
	'm.isDisabled = 0');
	break;
	case self::STATUS_DISABLED:
	$where[] = qsprintf(
	$conn,
	'm.isDisabled = 1');
	break;
	case self::STATUS_ANY:
	break;
	default:
	throw new Exception("Unknown status '{$this->status}'!");
	}

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

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

	if ($this->flagColor != '-1' && $this->flagColor !== null) {
	if ($this->flagColor == '-2') {
	$flag_colors = array_keys(PhabricatorFlagColor::getColorNameMap());
	} else {
	$flag_colors = array($this->flagColor);
	}
	$flags = id(new PhabricatorFlagQuery())
	->withOwnerPHIDs(array($this->getViewer()->getPHID()))
	->withTypes(array(PhabricatorMacroMacroPHIDType::TYPECONST))
	->withColors($flag_colors)
	->setViewer($this->getViewer())
	->execute();

	if (empty($flags)) {
	throw new PhabricatorEmptyQueryException('No matching flags.');
	} else {
	$where[] = qsprintf(
	$conn,
	'm.phid IN (%Ls)',
	mpull($flags, 'getObjectPHID'));
	}
	}

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

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

	protected function didFilterPage(array $macros) {
	if ($this->needFiles) {
	$file_phids = mpull($macros, 'getFilePHID');
	$files = id(new PhabricatorFileQuery())
	->setViewer($this->getViewer())
	->setParentQuery($this)
	->withPHIDs($file_phids)
	->execute();
	$files = mpull($files, null, 'getPHID');

	foreach ($macros as $key => $macro) {
	$file = idx($files, $macro->getFilePHID());
	if (!$file) {
	unset($macros[$key]);
	continue;
	}
	$macro->attachFile($file);
	}
	}

	return $macros;
	}

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

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

	+ public function getOrderableColumns() {
	+ return parent::getOrderableColumns() + array(
	+ 'name' => array(
	+ 'table' => 'm',
	+ 'column' => 'name',
	+ 'type' => 'string',
	+ 'reverse' => true,
	+ 'unique' => true,
	+ ),
	+ );
	+ }
	+
	+ public function getPagingValueMap($cursor, array $keys) {
	+ $macro = $this->loadCursorObject($cursor);
	+ return array(
	+ 'id' => $macro->getID(),
	+ 'name' => $macro->getName(),
	+ );
	+ }
	+
	+ public function getBuiltinOrders() {
	+ return array(
	+ 'name' => array(
	+ 'vector' => array('name'),
	+ 'name' => pht('Name'),
	+ ),
	+ ) + parent::getBuiltinOrders();
	+ }
	+
	}
	diff --git a/src/applications/macro/query/PhabricatorMacroSearchEngine.php b/src/applications/macro/query/PhabricatorMacroSearchEngine.php
	index 9207685dc5..8a810c886f 100644
	--- a/src/applications/macro/query/PhabricatorMacroSearchEngine.php
	+++ b/src/applications/macro/query/PhabricatorMacroSearchEngine.php
	@@ -1,216 +1,225 @@
	<?php

	final class PhabricatorMacroSearchEngine
	extends PhabricatorApplicationSearchEngine {

	public function getResultTypeDescription() {
	return pht('Macros');
	}

	public function getApplicationClassName() {
	return 'PhabricatorMacroApplication';
	}

	public function buildSavedQueryFromRequest(AphrontRequest $request) {
	$saved = new PhabricatorSavedQuery();
	$saved->setParameter(
	'authorPHIDs',
	$this->readUsersFromRequest($request, 'authors'));

	$saved->setParameter('status', $request->getStr('status'));
	$saved->setParameter('names', $request->getStrList('names'));
	$saved->setParameter('nameLike', $request->getStr('nameLike'));
	$saved->setParameter('createdStart', $request->getStr('createdStart'));
	$saved->setParameter('createdEnd', $request->getStr('createdEnd'));
	$saved->setParameter('flagColor', $request->getStr('flagColor', '-1'));

	+ $this->saveQueryOrder($saved, $request);
	+
	return $saved;
	}

	public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
	$query = id(new PhabricatorMacroQuery())
	->needFiles(true)
	->withIDs($saved->getParameter('ids', array()))
	->withPHIDs($saved->getParameter('phids', array()))
	->withAuthorPHIDs($saved->getParameter('authorPHIDs', array()));

	+ $this->setQueryOrder($query, $saved);
	+
	$status = $saved->getParameter('status');
	$options = PhabricatorMacroQuery::getStatusOptions();
	if (empty($options[$status])) {
	$status = head_key($options);
	}
	$query->withStatus($status);

	$names = $saved->getParameter('names', array());
	if ($names) {
	$query->withNames($names);
	}

	$like = $saved->getParameter('nameLike');
	if (strlen($like)) {
	$query->withNameLike($like);
	}

	$start = $this->parseDateTime($saved->getParameter('createdStart'));
	$end = $this->parseDateTime($saved->getParameter('createdEnd'));

	if ($start) {
	$query->withDateCreatedAfter($start);
	}

	if ($end) {
	$query->withDateCreatedBefore($end);
	}

	$color = $saved->getParameter('flagColor');
	if (strlen($color)) {
	$query->withFlagColor($color);
	}

	return $query;
	}

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

	- $author_phids = $saved_query->getParameter('authorPHIDs', array());
	- $status = $saved_query->getParameter('status');
	- $names = implode(', ', $saved_query->getParameter('names', array()));
	- $like = $saved_query->getParameter('nameLike');
	- $color = $saved_query->getParameter('flagColor', '-1');
	+ $author_phids = $saved->getParameter('authorPHIDs', array());
	+ $status = $saved->getParameter('status');
	+ $names = implode(', ', $saved->getParameter('names', array()));
	+ $like = $saved->getParameter('nameLike');
	+ $color = $saved->getParameter('flagColor', '-1');

	$form
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('status')
	->setLabel(pht('Status'))
	->setOptions(PhabricatorMacroQuery::getStatusOptions())
	->setValue($status))
	->appendControl(
	id(new AphrontFormTokenizerControl())
	->setDatasource(new PhabricatorPeopleDatasource())
	->setName('authors')
	->setLabel(pht('Authors'))
	->setValue($author_phids))
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('nameLike')
	->setLabel(pht('Name Contains'))
	->setValue($like))
	->appendChild(
	id(new AphrontFormTextControl())
	->setName('names')
	->setLabel(pht('Exact Names'))
	->setValue($names))
	->appendChild(
	id(new AphrontFormSelectControl())
	->setName('flagColor')
	->setLabel(pht('Marked with Flag'))
	->setOptions(PhabricatorMacroQuery::getFlagColorsOptions())
	->setValue($color));

	$this->buildDateRange(
	$form,
	- $saved_query,
	+ $saved,
	'createdStart',
	pht('Created After'),
	'createdEnd',
	pht('Created Before'));
	+
	+ $this->appendOrderFieldsToForm(
	+ $form,
	+ $saved,
	+ new PhabricatorMacroQuery());
	}

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

	protected function getBuiltinQueryNames() {
	$names = array(
	'active' => pht('Active'),
	'all' => pht('All'),
	);

	if ($this->requireViewer()->isLoggedIn()) {
	$names['authored'] = pht('Authored');
	}

	return $names;
	}

	public function buildSavedQueryFromBuiltin($query_key) {
	$query = $this->newSavedQuery();
	$query->setQueryKey($query_key);

	switch ($query_key) {
	case 'active':
	return $query;
	case 'all':
	return $query->setParameter(
	'status',
	PhabricatorMacroQuery::STATUS_ANY);
	case 'authored':
	return $query->setParameter(
	'authorPHIDs',
	array($this->requireViewer()->getPHID()));
	}

	return parent::buildSavedQueryFromBuiltin($query_key);
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $macros,
	PhabricatorSavedQuery $query) {
	return mpull($macros, 'getAuthorPHID');
	}

	protected function renderResultList(
	array $macros,
	PhabricatorSavedQuery $query,
	array $handles) {

	assert_instances_of($macros, 'PhabricatorFileImageMacro');
	$viewer = $this->requireViewer();

	$pinboard = new PHUIPinboardView();
	foreach ($macros as $macro) {
	$file = $macro->getFile();

	$item = new PHUIPinboardItemView();
	if ($file) {
	$item->setImageURI($file->getThumb280x210URI());
	$item->setImageSize(280, 210);
	}

	if ($macro->getDateCreated()) {
	$datetime = phabricator_date($macro->getDateCreated(), $viewer);
	$item->appendChild(
	phutil_tag(
	'div',
	array(),
	pht('Created on %s', $datetime)));
	} else {
	// Very old macros don't have a creation date. Rendering something
	// keeps all the pins at the same height and avoids flow issues.
	$item->appendChild(
	phutil_tag(
	'div',
	array(),
	pht('Created in ages long past')));
	}

	if ($macro->getAuthorPHID()) {
	$author_handle = $handles[$macro->getAuthorPHID()];
	$item->appendChild(
	pht('Created by %s', $author_handle->renderLink()));
	}

	$item->setURI($this->getApplicationURI('/view/'.$macro->getID().'/'));
	$item->setDisabled($macro->getisDisabled());
	$item->setHeader($macro->getName());

	$pinboard->addItem($item);
	}

	return $pinboard;
	}

	}
	diff --git a/src/applications/macro/typeahead/PhabricatorMacroDatasource.php b/src/applications/macro/typeahead/PhabricatorMacroDatasource.php
	index 4b8d52b4d4..1d978683cc 100644
	--- a/src/applications/macro/typeahead/PhabricatorMacroDatasource.php
	+++ b/src/applications/macro/typeahead/PhabricatorMacroDatasource.php
	@@ -1,38 +1,37 @@
	<?php

	final class PhabricatorMacroDatasource extends PhabricatorTypeaheadDatasource {

	- public function isBrowsable() {
	- // TODO: This should be made browsable.
	- return false;
	- }
	-
	public function getPlaceholderText() {
	return pht('Type a macro name...');
	}

	public function getDatasourceApplicationClass() {
	return 'PhabricatorMacroApplication';
	}

	public function loadResults() {
	- $viewer = $this->getViewer();
	$raw_query = $this->getRawQuery();

	- $results = array();
	-
	- $macros = id(new PhabricatorMacroQuery())
	- ->setViewer($viewer)
	- ->withStatus(PhabricatorMacroQuery::STATUS_ACTIVE)
	- ->execute();
	+ $query = id(new PhabricatorMacroQuery())
	+ ->setOrder('name')
	+ ->withNamePrefix($raw_query);
	+ $macros = $this->executeQuery($query);

	+ $results = array();
	foreach ($macros as $macro) {
	+ $closed = null;
	+ if ($macro->getIsDisabled()) {
	+ $closed = pht('Disabled');
	+ }
	+
	$results[] = id(new PhabricatorTypeaheadResult())
	->setPHID($macro->getPHID())
	+ ->setClosed($closed)
	->setName($macro->getName());
	}

	return $results;
	}

	}
	diff --git a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	index 9705c64c89..b10aff4f17 100644
	--- a/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	+++ b/src/applications/search/engine/PhabricatorApplicationSearchEngine.php
	@@ -1,944 +1,942 @@
	<?php

	/**
	* Represents an abstract search engine for an application. It supports
	* creating and storing saved queries.
	*
	* @task construct Constructing Engines
	* @task app Applications
	* @task builtin Builtin Queries
	* @task uri Query URIs
	* @task dates Date Filters
	* @task order Result Ordering
	* @task read Reading Utilities
	* @task exec Paging and Executing Queries
	* @task render Rendering Results
	*/
	abstract class PhabricatorApplicationSearchEngine {

	private $application;
	private $viewer;
	private $errors = array();
	private $customFields = false;
	private $request;
	private $context;

	const CONTEXT_LIST = 'list';
	const CONTEXT_PANEL = 'panel';

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

	public function setContext($context) {
	$this->context = $context;
	return $this;
	}

	public function isPanelContext() {
	return ($this->context == self::CONTEXT_PANEL);
	}

	public function canUseInPanelContext() {
	return true;
	}

	public function saveQuery(PhabricatorSavedQuery $query) {
	$query->setEngineClassName(get_class($this));

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	try {
	$query->save();
	} catch (AphrontDuplicateKeyQueryException $ex) {
	// Ignore, this is just a repeated search.
	}
	unset($unguarded);
	}

	/**
	* 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);


	/**
	* Return a human readable description of the type of objects this query
	* searches for.
	*
	* For example, "Tasks" or "Commits".
	*
	* @return string Human-readable description of what this engine is used to
	* find.
	*/
	abstract public function getResultTypeDescription();


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


	/* -( Applications )------------------------------------------------------- */


	protected function getApplicationURI($path = '') {
	return $this->getApplication()->getApplicationURI($path);
	}

	protected function getApplication() {
	if (!$this->application) {
	$class = $this->getApplicationClassName();

	$this->application = id(new PhabricatorApplicationQuery())
	->setViewer($this->requireViewer())
	->withClasses(array($class))
	->withInstalled(true)
	->executeOne();

	if (!$this->application) {
	throw new Exception(
	pht(
	'Application "%s" is not installed!',
	$class));
	}
	}

	return $this->application;
	}

	abstract public function getApplicationClassName();


	/* -( Constructing Engines )----------------------------------------------- */


	/**
	* Load all available application search engines.
	*
	* @return list<PhabricatorApplicationSearchEngine> All available engines.
	* @task construct
	*/
	public static function getAllEngines() {
	$engines = id(new PhutilSymbolLoader())
	->setAncestorClass(__CLASS__)
	->loadObjects();

	return $engines;
	}


	/**
	* Get an engine by class name, if it exists.
	*
	* @return PhabricatorApplicationSearchEngine\|null Engine, or null if it does
	* not exist.
	* @task construct
	*/
	public static function getEngineByClassName($class_name) {
	return idx(self::getAllEngines(), $class_name);
	}


	/* -( 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 = $this->readListFromRequest($request, $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);
	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 = $this->readListFromRequest($request, $key);

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


	/**
	* Read a list of items from the request, in either array format or string
	* format:
	*
	* list[]=item1&list[]=item2
	* list=item1,item2
	*
	* This provides flexibility when constructing URIs, especially from external
	* sources.
	*
	* @param AphrontRequest Request to read strings from.
	* @param string Key to read in the request.
	* @return list<string> List of values.
	*/
	protected function readListFromRequest(
	AphrontRequest $request,
	$key) {
	$list = $request->getArr($key, null);
	if ($list === null) {
	$list = $request->getStrList($key);
	}

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

	return $list;
	}

	protected function readDateFromRequest(
	AphrontRequest $request,
	$key) {

	return id(new AphrontFormDateControl())
	->setUser($this->requireViewer())
	->setName($key)
	->setAllowNull(true)
	->readValueFromRequest($request);
	}

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


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


	/**
	* Save order selection to a @{class:PhabricatorSavedQuery}.
	*/
	protected function saveQueryOrder(
	PhabricatorSavedQuery $saved,
	AphrontRequest $request) {

	$saved->setParameter('order', $request->getStr('order'));

	return $this;
	}


	/**
	* Set query ordering from a saved value.
	*/
	protected function setQueryOrder(
	PhabricatorCursorPagedPolicyAwareQuery $query,
	PhabricatorSavedQuery $saved) {

	$order = $saved->getParameter('order');
	- if (strlen($order)) {
	- $builtin = $query->getBuiltinOrders();
	- if (isset($builtin[$order])) {
	- $query->setOrder($order);
	- } else {
	- // If the order is invalid or not available, we choose the first
	- // builtin order. This isn't always the default order for the query,
	- // but is the first value in the "Order" dropdown, and makes the query
	- // behavior more consistent with the UI. In queries where the two
	- // orders differ, this order is the preferred order for humans.
	- $query->setOrder(head_key($builtin));
	- }
	+ $builtin = $query->getBuiltinOrders();
	+ if (strlen($order) && isset($builtin[$order])) {
	+ $query->setOrder($order);
	+ } else {
	+ // If the order is invalid or not available, we choose the first
	+ // builtin order. This isn't always the default order for the query,
	+ // but is the first value in the "Order" dropdown, and makes the query
	+ // behavior more consistent with the UI. In queries where the two
	+ // orders differ, this order is the preferred order for humans.
	+ $query->setOrder(head_key($builtin));
	}

	return $this;
	}



	protected function appendOrderFieldsToForm(
	AphrontFormView $form,
	PhabricatorSavedQuery $saved,
	PhabricatorCursorPagedPolicyAwareQuery $query) {

	$orders = $query->getBuiltinOrders();
	$orders = ipull($orders, 'name');

	$form->appendControl(
	id(new AphrontFormSelectControl())
	->setLabel(pht('Order'))
	->setName('order')
	->setOptions($orders)
	->setValue($saved->getParameter('order')));
	}

	/* -( Paging and Executing Queries )--------------------------------------- */


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


	public function shouldUseOffsetPaging() {
	return false;
	}


	public function newPagerForSavedQuery(PhabricatorSavedQuery $saved) {
	if ($this->shouldUseOffsetPaging()) {
	$pager = new AphrontPagerView();
	} else {
	$pager = new AphrontCursorPagerView();
	}

	$page_size = $this->getPageSize($saved);
	if (is_finite($page_size)) {
	$pager->setPageSize($page_size);
	} else {
	// Consider an INF pagesize to mean a large finite pagesize.

	// TODO: It would be nice to handle this more gracefully, but math
	// with INF seems to vary across PHP versions, systems, and runtimes.
	$pager->setPageSize(0xFFFF);
	}

	return $pager;
	}


	public function executeQuery(
	PhabricatorPolicyAwareQuery $query,
	AphrontView $pager) {

	$query->setViewer($this->requireViewer());

	if ($this->shouldUseOffsetPaging()) {
	$objects = $query->executeWithOffsetPager($pager);
	} else {
	$objects = $query->executeWithCursorPager($pager);
	}

	return $objects;
	}


	/* -( Rendering )---------------------------------------------------------- */


	public function setRequest(AphrontRequest $request) {
	$this->request = $request;
	return $this;
	}

	public function getRequest() {
	return $this->request;
	}

	public function renderResults(
	array $objects,
	PhabricatorSavedQuery $query) {

	$phids = $this->getRequiredHandlePHIDsForResultList($objects, $query);

	if ($phids) {
	$handles = id(new PhabricatorHandleQuery())
	->setViewer($this->requireViewer())
	->witHPHIDs($phids)
	->execute();
	} else {
	$handles = array();
	}

	return $this->renderResultList($objects, $query, $handles);
	}

	protected function getRequiredHandlePHIDsForResultList(
	array $objects,
	PhabricatorSavedQuery $query) {
	return array();
	}

	protected function renderResultList(
	array $objects,
	PhabricatorSavedQuery $query,
	array $handles) {
	throw new Exception(pht('Not supported here yet!'));
	}


	/* -( 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);
	$fields->setViewer($this->requireViewer());
	} 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));
	}
	}

	protected function applyOrderByToQuery(
	PhabricatorCursorPagedPolicyAwareQuery $query,
	array $standard_values,
	$order) {

	if (substr($order, 0, 7) === 'custom:') {
	$list = $this->getCustomFieldList();
	if (!$list) {
	$query->setOrderBy(head($standard_values));
	return;
	}

	foreach ($list->getFields() as $field) {
	$key = $this->getKeyForCustomField($field);

	if ($key === $order) {
	$index = $field->buildOrderIndex();

	if ($index === null) {
	$query->setOrderBy(head($standard_values));
	return;
	}

	$query->withApplicationSearchOrder(
	$field,
	$index,
	false);
	break;
	}
	}
	} else {
	$order = idx($standard_values, $order);
	if ($order) {
	$query->setOrderBy($order);
	} else {
	$query->setOrderBy(head($standard_values));
	}
	}
	}


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

	$custom_order = array();
	foreach ($list->getFields() as $field) {
	if ($field->shouldAppearInApplicationSearch()) {
	if ($field->buildOrderIndex() !== null) {
	$key = $this->getKeyForCustomField($field);
	$custom_order[$key] = $field->getFieldName();
	}
	}
	}

	return $custom_order;
	}

	/**
	* 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: Wed, Jul 2, 6:55 PM (20 h, 8 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 165113
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions