No OneTemporary
Actions

Size

24 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/base/PhabricatorApplication.php b/src/applications/base/PhabricatorApplication.php
	index e010d4491f..82b094c311 100644
	--- a/src/applications/base/PhabricatorApplication.php
	+++ b/src/applications/base/PhabricatorApplication.php
	@@ -1,643 +1,645 @@
	<?php

	/**
	* @task info Application Information
	* @task ui UI Integration
	* @task uri URI Routing
	* @task mail Email integration
	* @task fact Fact Integration
	* @task meta Application Management
	*/
	abstract class PhabricatorApplication
	extends Phobject
	implements PhabricatorPolicyInterface {

	const MAX_STATUS_ITEMS = 100;

	const GROUP_CORE = 'core';
	const GROUP_UTILITIES = 'util';
	const GROUP_ADMIN = 'admin';
	const GROUP_DEVELOPER = 'developer';

	final public static function getApplicationGroups() {
	return array(
	self::GROUP_CORE => pht('Core Applications'),
	self::GROUP_UTILITIES => pht('Utilities'),
	self::GROUP_ADMIN => pht('Administration'),
	self::GROUP_DEVELOPER => pht('Developer Tools'),
	);
	}


	/* -( Application Information )-------------------------------------------- */

	abstract public function getName();

	public function getShortDescription() {
	return pht('%s Application', $this->getName());
	}

	final public function isInstalled() {
	if (!$this->canUninstall()) {
	return true;
	}

	$prototypes = PhabricatorEnv::getEnvConfig('phabricator.show-prototypes');
	if (!$prototypes && $this->isPrototype()) {
	return false;
	}

	$uninstalled = PhabricatorEnv::getEnvConfig(
	'phabricator.uninstalled-applications');

	return empty($uninstalled[get_class($this)]);
	}


	public function isPrototype() {
	return false;
	}


	/**
	* Return `true` if this application should never appear in application lists
	* in the UI. Primarily intended for unit test applications or other
	* pseudo-applications.
	*
	* Few applications should be unlisted. For most applications, use
	* @{method:isLaunchable} to hide them from main launch views instead.
	*
	* @return bool True to remove application from UI lists.
	*/
	public function isUnlisted() {
	return false;
	}


	/**
	* Return `true` if this application is a normal application with a base
	* URI and a web interface.
	*
	* Launchable applications can be pinned to the home page, and show up in the
	* "Launcher" view of the Applications application. Making an application
	* unlauncahble prevents pinning and hides it from this view.
	*
	* Usually, an application should be marked unlaunchable if:
	*
	* - it is available on every page anyway (like search); or
	* - it does not have a web interface (like subscriptions); or
	* - it is still pre-release and being intentionally buried.
	*
	* To hide applications more completely, use @{method:isUnlisted}.
	*
	* @return bool True if the application is launchable.
	*/
	public function isLaunchable() {
	return true;
	}


	/**
	* Return `true` if this application should be pinned by default.
	*
	* Users who have not yet set preferences see a default list of applications.
	*
	* @param PhabricatorUser User viewing the pinned application list.
	* @return bool True if this application should be pinned by default.
	*/
	public function isPinnedByDefault(PhabricatorUser $viewer) {
	return false;
	}


	/**
	* Returns true if an application is first-party (developed by Phacility)
	* and false otherwise.
	*
	* @return bool True if this application is developed by Phacility.
	*/
	final public function isFirstParty() {
	$where = id(new ReflectionClass($this))->getFileName();
	$root = phutil_get_library_root('phabricator');

	if (!Filesystem::isDescendant($where, $root)) {
	return false;
	}

	if (Filesystem::isDescendant($where, $root.'/extensions')) {
	return false;
	}

	return true;
	}

	public function canUninstall() {
	return true;
	}

	final public function getPHID() {
	return 'PHID-APPS-'.get_class($this);
	}

	public function getTypeaheadURI() {
	return $this->isLaunchable() ? $this->getBaseURI() : null;
	}

	public function getBaseURI() {
	return null;
	}

	final public function getApplicationURI($path = '') {
	return $this->getBaseURI().ltrim($path, '/');
	}

	public function getIconURI() {
	return null;
	}

	public function getIcon() {
	return 'fa-puzzle-piece';
	}

	public function getApplicationOrder() {
	return PHP_INT_MAX;
	}

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

	public function getTitleGlyph() {
	return null;
	}

	final public function getHelpMenuItems(PhabricatorUser $viewer) {
	$items = array();

	$articles = $this->getHelpDocumentationArticles($viewer);
	if ($articles) {
	$items[] = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_LABEL)
	->setName(pht('%s Documentation', $this->getName()));
	foreach ($articles as $article) {
	$item = id(new PHUIListItemView())
	->setName($article['name'])
	->setIcon('fa-book')
	- ->setHref($article['href']);
	+ ->setHref($article['href'])
	+ ->setOpenInNewWindow(true);

	$items[] = $item;
	}
	}

	$command_specs = $this->getMailCommandObjects();
	if ($command_specs) {
	$items[] = id(new PHUIListItemView())
	->setType(PHUIListItemView::TYPE_LABEL)
	->setName(pht('Email Help'));
	foreach ($command_specs as $key => $spec) {
	$object = $spec['object'];

	$class = get_class($this);
	$href = '/applications/mailcommands/'.$class.'/'.$key.'/';

	$item = id(new PHUIListItemView())
	->setName($spec['name'])
	->setIcon('fa-envelope-o')
	- ->setHref($href);
	+ ->setHref($href)
	+ ->setOpenInNewWindow(true);
	$items[] = $item;
	}
	}

	return $items;
	}

	public function getHelpDocumentationArticles(PhabricatorUser $viewer) {
	return array();
	}

	public function getOverview() {
	return null;
	}

	public function getEventListeners() {
	return array();
	}

	public function getRemarkupRules() {
	return array();
	}

	public function getQuicksandURIPatternBlacklist() {
	return array();
	}

	public function getMailCommandObjects() {
	return array();
	}


	/* -( URI Routing )-------------------------------------------------------- */


	public function getRoutes() {
	return array();
	}

	public function getResourceRoutes() {
	return array();
	}


	/* -( Email Integration )-------------------------------------------------- */


	public function supportsEmailIntegration() {
	return false;
	}

	final protected function getInboundEmailSupportLink() {
	return PhabricatorEnv::getDocLink('Configuring Inbound Email');
	}

	public function getAppEmailBlurb() {
	throw new PhutilMethodNotImplementedException();
	}


	/* -( Fact Integration )--------------------------------------------------- */


	public function getFactObjectsForAnalysis() {
	return array();
	}


	/* -( UI Integration )----------------------------------------------------- */


	/**
	* Render status elements (like "3 Waiting Reviews") for application list
	* views. These provide a way to alert users to new or pending action items
	* in applications.
	*
	* @param PhabricatorUser Viewing user.
	* @return list<PhabricatorApplicationStatusView> Application status elements.
	* @task ui
	*/
	public function loadStatus(PhabricatorUser $user) {
	return array();
	}


	/**
	* You can provide an optional piece of flavor text for the application. This
	* is currently rendered in application launch views if the application has no
	* status elements.
	*
	* @return string\|null Flavor text.
	* @task ui
	*/
	public function getFlavorText() {
	return null;
	}


	/**
	* Build items for the main menu.
	*
	* @param PhabricatorUser The viewing user.
	* @param AphrontController The current controller. May be null for special
	* pages like 404, exception handlers, etc.
	* @return list<PHUIListItemView> List of menu items.
	* @task ui
	*/
	public function buildMainMenuItems(
	PhabricatorUser $user,
	PhabricatorController $controller = null) {
	return array();
	}


	/**
	* Build extra items for the main menu. Generally, this is used to render
	* static dropdowns.
	*
	* @param PhabricatorUser The viewing user.
	* @param AphrontController The current controller. May be null for special
	* pages like 404, exception handlers, etc.
	* @return view List of menu items.
	* @task ui
	*/
	public function buildMainMenuExtraNodes(
	PhabricatorUser $viewer,
	PhabricatorController $controller = null) {
	return array();
	}


	/* -( Application Management )--------------------------------------------- */


	final public static function getByClass($class_name) {
	$selected = null;
	$applications = self::getAllApplications();

	foreach ($applications as $application) {
	if (get_class($application) == $class_name) {
	$selected = $application;
	break;
	}
	}

	if (!$selected) {
	throw new Exception(pht("No application '%s'!", $class_name));
	}

	return $selected;
	}

	final public static function getAllApplications() {
	static $applications;

	if ($applications === null) {
	$apps = id(new PhutilClassMapQuery())
	->setAncestorClass(__CLASS__)
	->setSortMethod('getApplicationOrder')
	->execute();

	// Reorder the applications into "application order". Notably, this
	// ensures their event handlers register in application order.
	$apps = mgroup($apps, 'getApplicationGroup');

	$group_order = array_keys(self::getApplicationGroups());
	$apps = array_select_keys($apps, $group_order) + $apps;

	$apps = array_mergev($apps);

	$applications = $apps;
	}

	return $applications;
	}

	final public static function getAllInstalledApplications() {
	$all_applications = self::getAllApplications();
	$apps = array();
	foreach ($all_applications as $app) {
	if (!$app->isInstalled()) {
	continue;
	}

	$apps[] = $app;
	}

	return $apps;
	}


	/**
	* Determine if an application is installed, by application class name.
	*
	* To check if an application is installed //and// available to a particular
	* viewer, user @{method:isClassInstalledForViewer}.
	*
	* @param string Application class name.
	* @return bool True if the class is installed.
	* @task meta
	*/
	final public static function isClassInstalled($class) {
	return self::getByClass($class)->isInstalled();
	}


	/**
	* Determine if an application is installed and available to a viewer, by
	* application class name.
	*
	* To check if an application is installed at all, use
	* @{method:isClassInstalled}.
	*
	* @param string Application class name.
	* @param PhabricatorUser Viewing user.
	* @return bool True if the class is installed for the viewer.
	* @task meta
	*/
	final public static function isClassInstalledForViewer(
	$class,
	PhabricatorUser $viewer) {

	if ($viewer->isOmnipotent()) {
	return true;
	}

	$cache = PhabricatorCaches::getRequestCache();
	$viewer_phid = $viewer->getPHID();
	$key = 'app.'.$class.'.installed.'.$viewer_phid;

	$result = $cache->getKey($key);
	if ($result === null) {
	if (!self::isClassInstalled($class)) {
	$result = false;
	} else {
	$result = PhabricatorPolicyFilter::hasCapability(
	$viewer,
	self::getByClass($class),
	PhabricatorPolicyCapability::CAN_VIEW);
	}

	$cache->setKey($key, $result);
	}

	return $result;
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array_merge(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	),
	array_keys($this->getCustomCapabilities()));
	}

	public function getPolicy($capability) {
	$default = $this->getCustomPolicySetting($capability);
	if ($default) {
	return $default;
	}

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::getMostOpenPolicy();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return PhabricatorPolicies::POLICY_ADMIN;
	default:
	$spec = $this->getCustomCapabilitySpecification($capability);
	return idx($spec, 'default', PhabricatorPolicies::POLICY_USER);
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return false;
	}

	public function describeAutomaticCapability($capability) {
	return null;
	}


	/* -( Policies )----------------------------------------------------------- */

	protected function getCustomCapabilities() {
	return array();
	}

	final private function getCustomPolicySetting($capability) {
	if (!$this->isCapabilityEditable($capability)) {
	return null;
	}

	$policy_locked = PhabricatorEnv::getEnvConfig('policy.locked');
	if (isset($policy_locked[$capability])) {
	return $policy_locked[$capability];
	}

	$config = PhabricatorEnv::getEnvConfig('phabricator.application-settings');

	$app = idx($config, $this->getPHID());
	if (!$app) {
	return null;
	}

	$policy = idx($app, 'policy');
	if (!$policy) {
	return null;
	}

	return idx($policy, $capability);
	}


	final private function getCustomCapabilitySpecification($capability) {
	$custom = $this->getCustomCapabilities();
	if (!isset($custom[$capability])) {
	throw new Exception(pht("Unknown capability '%s'!", $capability));
	}
	return $custom[$capability];
	}

	final public function getCapabilityLabel($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return pht('Can Use Application');
	case PhabricatorPolicyCapability::CAN_EDIT:
	return pht('Can Configure Application');
	}

	$capobj = PhabricatorPolicyCapability::getCapabilityByKey($capability);
	if ($capobj) {
	return $capobj->getCapabilityName();
	}

	return null;
	}

	final public function isCapabilityEditable($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return $this->canUninstall();
	case PhabricatorPolicyCapability::CAN_EDIT:
	return false;
	default:
	$spec = $this->getCustomCapabilitySpecification($capability);
	return idx($spec, 'edit', true);
	}
	}

	final public function getCapabilityCaption($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	if (!$this->canUninstall()) {
	return pht(
	'This application is required for Phabricator to operate, so all '.
	'users must have access to it.');
	} else {
	return null;
	}
	case PhabricatorPolicyCapability::CAN_EDIT:
	return null;
	default:
	$spec = $this->getCustomCapabilitySpecification($capability);
	return idx($spec, 'caption');
	}
	}

	final public function getCapabilityTemplatePHIDType($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	case PhabricatorPolicyCapability::CAN_EDIT:
	return null;
	}

	$spec = $this->getCustomCapabilitySpecification($capability);
	return idx($spec, 'template');
	}

	final public function getDefaultObjectTypePolicyMap() {
	$map = array();

	foreach ($this->getCustomCapabilities() as $capability => $spec) {
	if (empty($spec['template'])) {
	continue;
	}
	if (empty($spec['capability'])) {
	continue;
	}
	$default = $this->getPolicy($capability);
	$map[$spec['template']][$spec['capability']] = $default;
	}

	return $map;
	}

	public function getApplicationSearchDocumentTypes() {
	return array();
	}

	protected function getEditRoutePattern($base = null) {
	return $base.'(?:'.
	'(?P<id>[0-9]\d*)/)?'.
	'(?:'.
	'(?:'.
	'(?P<editAction>parameters\|nodefault\|nocreate\|nomanage\|comment)/'.
	'\|'.
	'(?:form/(?P<formKey>[^/]+)/)?(?:page/(?P<pageKey>[^/]+)/)?'.
	')'.
	')?';
	}

	protected function getQueryRoutePattern($base = null) {
	return $base.'(?:query/(?P<queryKey>[^/]+)/)?';
	}

	protected function getPanelRouting($controller) {
	$edit_route = $this->getEditRoutePattern();

	return array(
	'(?P<panelAction>view)/(?P<panelID>[^/]+)/' => $controller,
	'(?P<panelAction>hide)/(?P<panelID>[^/]+)/' => $controller,
	'(?P<panelAction>default)/(?P<panelID>[^/]+)/' => $controller,
	'(?P<panelAction>configure)/' => $controller,
	'(?P<panelAction>reorder)/' => $controller,
	'(?P<panelAction>edit)/'.$edit_route => $controller,
	'(?P<panelAction>new)/(?<panelKey>[^/]+)/'.$edit_route => $controller,
	'(?P<panelAction>builtin)/(?<panelID>[^/]+)/'.$edit_route
	=> $controller,
	);
	}

	}
	diff --git a/src/view/phui/PHUIListItemView.php b/src/view/phui/PHUIListItemView.php
	index 4af02e572e..3a4909a1ee 100644
	--- a/src/view/phui/PHUIListItemView.php
	+++ b/src/view/phui/PHUIListItemView.php
	@@ -1,307 +1,318 @@
	<?php

	final class PHUIListItemView extends AphrontTagView {

	const TYPE_LINK = 'type-link';
	const TYPE_SPACER = 'type-spacer';
	const TYPE_LABEL = 'type-label';
	const TYPE_BUTTON = 'type-button';
	const TYPE_CUSTOM = 'type-custom';
	const TYPE_DIVIDER = 'type-divider';
	const TYPE_ICON = 'type-icon';

	const STATUS_WARN = 'phui-list-item-warn';
	const STATUS_FAIL = 'phui-list-item-fail';

	private $name;
	private $href;
	private $type = self::TYPE_LINK;
	private $isExternal;
	private $key;
	private $icon;
	private $selected;
	private $disabled;
	private $renderNameAsTooltip;
	private $statusColor;
	private $order;
	private $aural;
	private $profileImage;
	private $indented;
	private $hideInApplicationMenu;
	private $icons = array();
	+ private $openInNewWindow = false;

	- public function setHideInApplicationMenu($hide) {
	+ public function setOpenInNewWindow($open_in_new_window) {
	+ $this->openInNewWindow = $open_in_new_window;
	+ return $this;
	+ }
	+
	+ public function getOpenInNewWindow() {
	+ return $this->openInNewWindow;
	+ }
	+
	+ public function setHideInApplicationMenu($hide) {
	$this->hideInApplicationMenu = $hide;
	return $this;
	}

	public function getHideInApplicationMenu() {
	return $this->hideInApplicationMenu;
	}

	public function setDropdownMenu(PhabricatorActionListView $actions) {
	Javelin::initBehavior('phui-dropdown-menu');

	$this->addSigil('phui-dropdown-menu');
	$this->setMetadata($actions->getDropdownMenuMetadata());

	return $this;
	}

	public function setAural($aural) {
	$this->aural = $aural;
	return $this;
	}

	public function getAural() {
	return $this->aural;
	}

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

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

	public function setRenderNameAsTooltip($render_name_as_tooltip) {
	$this->renderNameAsTooltip = $render_name_as_tooltip;
	return $this;
	}

	public function getRenderNameAsTooltip() {
	return $this->renderNameAsTooltip;
	}

	public function setSelected($selected) {
	$this->selected = $selected;
	return $this;
	}

	public function getSelected() {
	return $this->selected;
	}

	public function setIcon($icon) {
	$this->icon = $icon;
	return $this;
	}

	public function setProfileImage($image) {
	$this->profileImage = $image;
	return $this;
	}

	public function getIcon() {
	return $this->icon;
	}

	public function setIndented($indented) {
	$this->indented = $indented;
	return $this;
	}

	public function getIndented() {
	return $this->indented;
	}

	public function setKey($key) {
	$this->key = (string)$key;
	return $this;
	}

	public function getKey() {
	return $this->key;
	}

	public function setType($type) {
	$this->type = $type;
	return $this;
	}

	public function getType() {
	return $this->type;
	}

	public function setHref($href) {
	$this->href = $href;
	return $this;
	}

	public function getHref() {
	return $this->href;
	}

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

	public function getName() {
	return $this->name;
	}

	public function setIsExternal($is_external) {
	$this->isExternal = $is_external;
	return $this;
	}

	public function getIsExternal() {
	return $this->isExternal;
	}

	public function setStatusColor($color) {
	$this->statusColor = $color;
	return $this;
	}

	public function addIcon($icon) {
	$this->icons[] = $icon;
	return $this;
	}

	public function getIcons() {
	return $this->icons;
	}

	protected function getTagName() {
	return 'li';
	}

	protected function getTagAttributes() {
	$classes = array();
	$classes[] = 'phui-list-item-view';
	$classes[] = 'phui-list-item-'.$this->type;

	if ($this->icon) {
	$classes[] = 'phui-list-item-has-icon';
	}

	if ($this->selected) {
	$classes[] = 'phui-list-item-selected';
	}

	if ($this->disabled) {
	$classes[] = 'phui-list-item-disabled';
	}

	if ($this->statusColor) {
	$classes[] = $this->statusColor;
	}

	return array(
	'class' => $classes,
	);
	}

	public function setDisabled($disabled) {
	$this->disabled = $disabled;
	return $this;
	}

	public function getDisabled() {
	return $this->disabled;
	}

	protected function getTagContent() {
	$name = null;
	$icon = null;
	$meta = null;
	$sigil = null;

	if ($this->name) {
	if ($this->getRenderNameAsTooltip()) {
	Javelin::initBehavior('phabricator-tooltips');
	$sigil = 'has-tooltip';
	$meta = array(
	'tip' => $this->name,
	'align' => 'E',
	);
	} else {
	$external = null;
	if ($this->isExternal) {
	$external = " \xE2\x86\x97";
	}

	// If this element has an aural representation, make any name visual
	// only. This is primarily dealing with the links in the main menu like
	// "Profile" and "Logout". If we don't hide the name, the mobile
	// version of these elements will have two redundant names.

	$classes = array();
	$classes[] = 'phui-list-item-name';
	if ($this->aural !== null) {
	$classes[] = 'visual-only';
	}

	$name = phutil_tag(
	'span',
	array(
	'class' => implode(' ', $classes),
	),
	array(
	$this->name,
	$external,
	));
	}
	}

	$aural = null;
	if ($this->aural !== null) {
	$aural = javelin_tag(
	'span',
	array(
	'aural' => true,
	),
	$this->aural);
	}

	if ($this->icon) {
	$icon_name = $this->icon;
	if ($this->getDisabled()) {
	$icon_name .= ' grey';
	}

	$icon = id(new PHUIIconView())
	->addClass('phui-list-item-icon')
	->setIcon($icon_name);
	}

	if ($this->profileImage) {
	$icon = id(new PHUIIconView())
	->setHeadSize(PHUIIconView::HEAD_SMALL)
	->addClass('phui-list-item-icon')
	->setImage($this->profileImage);
	}

	$classes = array();
	if ($this->href) {
	$classes[] = 'phui-list-item-href';
	}

	if ($this->indented) {
	$classes[] = 'phui-list-item-indented';
	}

	$icons = $this->getIcons();

	return javelin_tag(
	$this->href ? 'a' : 'div',
	array(
	'href' => $this->href,
	'class' => implode(' ', $classes),
	'meta' => $meta,
	'sigil' => $sigil,
	+ 'target' => $this->getOpenInNewWindow() ? '_blank' : null,
	),
	array(
	$aural,
	$icon,
	$icons,
	$this->renderChildren(),
	$name,
	));
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Fri, Mar 14, 12:49 PM (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 71879
Default Alt Text: (24 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions