Diffusion Phabricator (feature/better-testing) Browse

better-testing

PhabricatorProfileMenuEngine.php
View Options

			<?php

			abstract class PhabricatorProfileMenuEngine extends Phobject {

			private $viewer;
			private $profileObject;
			private $customPHID;
			private $items;
			private $defaultItem;
			private $controller;
			private $navigation;
			private $showNavigation = true;
			private $editMode;
			private $pageClasses = array();
			private $showContentCrumbs = true;

			const ITEM_CUSTOM_DIVIDER = 'engine.divider';
			const ITEM_MANAGE = 'item.configure';

			const MODE_COMBINED = 'combined';
			const MODE_GLOBAL = 'global';
			const MODE_CUSTOM = 'custom';

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

			public function getViewer() {
			return $this->viewer;
			}

			public function setProfileObject($profile_object) {
			$this->profileObject = $profile_object;
			return $this;
			}

			public function getProfileObject() {
			return $this->profileObject;
			}

			public function setCustomPHID($custom_phid) {
			$this->customPHID = $custom_phid;
			return $this;
			}

			public function getCustomPHID() {
			return $this->customPHID;
			}

			private function getEditModeCustomPHID() {
			$mode = $this->getEditMode();

			switch ($mode) {
			case self::MODE_CUSTOM:
			$custom_phid = $this->getCustomPHID();
			break;
			case self::MODE_GLOBAL:
			$custom_phid = null;
			break;
			}

			return $custom_phid;
			}

			public function setController(PhabricatorController $controller) {
			$this->controller = $controller;
			return $this;
			}

			public function getController() {
			return $this->controller;
			}

			private function setDefaultItem(
			PhabricatorProfileMenuItemConfiguration $default_item) {
			$this->defaultItem = $default_item;
			return $this;
			}

			public function getDefaultItem() {
			$this->getItems();
			return $this->defaultItem;
			}

			public function setShowNavigation($show) {
			$this->showNavigation = $show;
			return $this;
			}

			public function getShowNavigation() {
			return $this->showNavigation;
			}

			public function addContentPageClass($class) {
			$this->pageClasses[] = $class;
			return $this;
			}

			public function setShowContentCrumbs($show_content_crumbs) {
			$this->showContentCrumbs = $show_content_crumbs;
			return $this;
			}

			public function getShowContentCrumbs() {
			return $this->showContentCrumbs;
			}

			abstract public function getItemURI($path);
			abstract protected function isMenuEngineConfigurable();

			abstract protected function getBuiltinProfileItems($object);

			protected function getBuiltinCustomProfileItems(
			$object,
			$custom_phid) {
			return array();
			}

			protected function getEditMode() {
			return $this->editMode;
			}

			public function buildResponse() {
			$controller = $this->getController();

			$viewer = $controller->getViewer();
			$this->setViewer($viewer);

			$request = $controller->getRequest();

			$item_action = $request->getURIData('itemAction');
			if (!$item_action) {
			$item_action = 'view';
			}

			$is_view = ($item_action == 'view');

			// If the engine is not configurable, don't respond to any of the editing
			// or configuration routes.
			if (!$this->isMenuEngineConfigurable()) {
			if (!$is_view) {
			return new Aphront404Response();
			}
			}

			$item_id = $request->getURIData('itemID');

			// If we miss on the MenuEngine route, try the EditEngine route. This will
			// be populated while editing items.
			if (!$item_id) {
			$item_id = $request->getURIData('id');
			}

			$item_list = $this->getItems();

			$selected_item = null;
			if (strlen($item_id)) {
			$item_id_int = (int)$item_id;
			foreach ($item_list as $item) {
			if ($item_id_int) {
			if ((int)$item->getID() === $item_id_int) {
			$selected_item = $item;
			break;
			}
			}

			$builtin_key = $item->getBuiltinKey();
			if ($builtin_key === (string)$item_id) {
			$selected_item = $item;
			break;
			}
			}
			}

			if (!$selected_item) {
			if ($is_view) {
			$selected_item = $this->getDefaultItem();
			}
			}

			switch ($item_action) {
			case 'view':
			case 'info':
			case 'hide':
			case 'default':
			case 'builtin':
			if (!$selected_item) {
			return new Aphront404Response();
			}
			break;
			case 'edit':
			if (!$request->getURIData('id')) {
			// If we continue along the "edit" pathway without an ID, we hit an
			// unrelated exception because we can not build a new menu item out
			// of thin air. For menus, new items are created via the "new"
			// action. Just catch this case and 404 early since there's currently
			// no clean way to make EditEngine aware of this.
			return new Aphront404Response();
			}
			break;
			}

			$navigation = $this->buildNavigation();

			$crumbs = $controller->buildApplicationCrumbsForEditEngine();

			if (!$is_view) {
			$navigation->selectFilter(self::ITEM_MANAGE);

			if ($selected_item) {
			if ($selected_item->getCustomPHID()) {
			$edit_mode = 'custom';
			} else {
			$edit_mode = 'global';
			}
			} else {
			$edit_mode = $request->getURIData('itemEditMode');
			}

			$available_modes = $this->getViewerEditModes();
			if ($available_modes) {
			$available_modes = array_fuse($available_modes);
			if (isset($available_modes[$edit_mode])) {
			$this->editMode = $edit_mode;
			} else {
			if ($item_action != 'configure') {
			return new Aphront404Response();
			}
			}
			}
			$page_title = pht('Configure Menu');
			} else {
			$page_title = $selected_item->getDisplayName();
			}

			switch ($item_action) {
			case 'view':
			$navigation->selectFilter($selected_item->getDefaultMenuItemKey());

			try {
			$content = $this->buildItemViewContent($selected_item);
			} catch (Exception $ex) {
			$content = id(new PHUIInfoView())
			->setTitle(pht('Unable to Render Dashboard'))
			->setErrors(array($ex->getMessage()));
			}

			$crumbs->addTextCrumb($selected_item->getDisplayName());
			if (!$content) {
			return new Aphront404Response();
			}
			break;
			case 'configure':
			$mode = $this->getEditMode();
			if (!$mode) {
			$crumbs->addTextCrumb(pht('Configure Menu'));
			$content = $this->buildMenuEditModeContent();
			} else {
			if (count($available_modes) > 1) {
			$crumbs->addTextCrumb(
			pht('Configure Menu'),
			$this->getItemURI('configure/'));

			switch ($mode) {
			case self::MODE_CUSTOM:
			$crumbs->addTextCrumb(pht('Personal'));
			break;
			case self::MODE_GLOBAL:
			$crumbs->addTextCrumb(pht('Global'));
			break;
			}
			} else {
			$crumbs->addTextCrumb(pht('Configure Menu'));
			}
			$edit_list = $this->loadItems($mode);
			$content = $this->buildItemConfigureContent($edit_list);
			}
			break;
			case 'reorder':
			$mode = $this->getEditMode();
			$edit_list = $this->loadItems($mode);
			$content = $this->buildItemReorderContent($edit_list);
			break;
			case 'new':
			$item_key = $request->getURIData('itemKey');
			$mode = $this->getEditMode();
			$content = $this->buildItemNewContent($item_key, $mode);
			break;
			case 'builtin':
			$content = $this->buildItemBuiltinContent($selected_item);
			break;
			case 'hide':
			$content = $this->buildItemHideContent($selected_item);
			break;
			case 'default':
			if (!$this->isMenuEnginePinnable()) {
			return new Aphront404Response();
			}
			$content = $this->buildItemDefaultContent(
			$selected_item,
			$item_list);
			break;
			case 'edit':
			$content = $this->buildItemEditContent();
			break;
			default:
			throw new Exception(
			pht(
			'Unsupported item action "%s".',
			$item_action));
			}

			if ($content instanceof AphrontResponse) {
			return $content;
			}

			if ($content instanceof AphrontResponseProducerInterface) {
			return $content;
			}

			$crumbs->setBorder(true);

			$page = $controller->newPage()
			->setTitle($page_title)
			->appendChild($content);

			if (!$is_view \|\| $this->getShowContentCrumbs()) {
			$page->setCrumbs($crumbs);
			}

			if ($this->getShowNavigation()) {
			$page->setNavigation($navigation);
			}

			if ($is_view) {
			foreach ($this->pageClasses as $class) {
			$page->addClass($class);
			}
			}

			return $page;
			}

			public function buildNavigation() {
			if ($this->navigation) {
			return $this->navigation;
			}
			$nav = id(new AphrontSideNavFilterView())
			->setIsProfileMenu(true)
			->setBaseURI(new PhutilURI($this->getItemURI('')));

			$menu_items = $this->getItems();

			$filtered_items = array();
			foreach ($menu_items as $menu_item) {
			if ($menu_item->isDisabled()) {
			continue;
			}
			$filtered_items[] = $menu_item;
			}
			$filtered_groups = mgroup($filtered_items, 'getMenuItemKey');
			foreach ($filtered_groups as $group) {
			$first_item = head($group);
			$first_item->willBuildNavigationItems($group);
			}

			foreach ($menu_items as $menu_item) {
			if ($menu_item->isDisabled()) {
			continue;
			}

			$items = $menu_item->buildNavigationMenuItems();
			foreach ($items as $item) {
			$this->validateNavigationMenuItem($item);
			}

			// If the item produced only a single item which does not otherwise
			// have a key, try to automatically assign it a reasonable key. This
			// makes selecting the correct item simpler.

			if (count($items) == 1) {
			$item = head($items);
			if ($item->getKey() === null) {
			$default_key = $menu_item->getDefaultMenuItemKey();
			$item->setKey($default_key);
			}
			}

			foreach ($items as $item) {
			$nav->addMenuItem($item);
			}
			}

			$nav->selectFilter(null);

			$this->navigation = $nav;
			return $this->navigation;
			}

			private function getItems() {
			if ($this->items === null) {
			$this->items = $this->loadItems(self::MODE_COMBINED);
			}

			return $this->items;
			}

			private function loadItems($mode) {
			$viewer = $this->getViewer();
			$object = $this->getProfileObject();

			$items = $this->loadBuiltinProfileItems($mode);

			$query = id(new PhabricatorProfileMenuItemConfigurationQuery())
			->setViewer($viewer)
			->withProfilePHIDs(array($object->getPHID()));

			switch ($mode) {
			case self::MODE_GLOBAL:
			$query->withCustomPHIDs(array(), true);
			break;
			case self::MODE_CUSTOM:
			$query->withCustomPHIDs(array($this->getCustomPHID()), false);
			break;
			case self::MODE_COMBINED:
			$query->withCustomPHIDs(array($this->getCustomPHID()), true);
			break;
			}

			$stored_items = $query->execute();

			foreach ($stored_items as $stored_item) {
			$impl = $stored_item->getMenuItem();
			$impl->setViewer($viewer);
			$impl->setEngine($this);
			}

			// Merge the stored items into the builtin items. If a builtin item has
			// a stored version, replace the defaults with the stored changes.
			foreach ($stored_items as $stored_item) {
			if (!$stored_item->shouldEnableForObject($object)) {
			continue;
			}

			$builtin_key = $stored_item->getBuiltinKey();
			if ($builtin_key !== null) {
			// If this builtin actually exists, replace the builtin with the
			// stored configuration. Otherwise, we're just going to drop the
			// stored config: it corresponds to an out-of-date or uninstalled
			// item.
			if (isset($items[$builtin_key])) {
			$items[$builtin_key] = $stored_item;
			} else {
			continue;
			}
			} else {
			$items[] = $stored_item;
			}
			}

			$items = $this->arrangeItems($items, $mode);

			// Make sure exactly one valid item is marked as default.
			$default = null;
			$first = null;
			foreach ($items as $item) {
			if (!$item->canMakeDefault()) {
			continue;
			}

			// If this engine doesn't support pinning items, don't respect any
			// setting which might be present in the database.
			if ($this->isMenuEnginePinnable()) {
			if ($item->isDefault()) {
			$default = $item;
			break;
			}
			}

			if ($first === null) {
			$first = $item;
			}
			}

			if (!$default) {
			$default = $first;
			}

			if ($default) {
			$this->setDefaultItem($default);
			}

			return $items;
			}

			private function loadBuiltinProfileItems($mode) {
			$object = $this->getProfileObject();

			switch ($mode) {
			case self::MODE_GLOBAL:
			$builtins = $this->getBuiltinProfileItems($object);
			break;
			case self::MODE_CUSTOM:
			$builtins = $this->getBuiltinCustomProfileItems(
			$object,
			$this->getCustomPHID());
			break;
			case self::MODE_COMBINED:
			$builtins = array();
			$builtins[] = $this->getBuiltinCustomProfileItems(
			$object,
			$this->getCustomPHID());
			$builtins[] = $this->getBuiltinProfileItems($object);
			$builtins = array_mergev($builtins);
			break;
			}

			$items = PhabricatorProfileMenuItem::getAllMenuItems();
			$viewer = $this->getViewer();

			$order = 1;
			$map = array();
			foreach ($builtins as $builtin) {
			$builtin_key = $builtin->getBuiltinKey();

			if (!$builtin_key) {
			throw new Exception(
			pht(
			'Object produced a builtin item with no builtin item key! '.
			'Builtin items must have a unique key.'));
			}

			if (isset($map[$builtin_key])) {
			throw new Exception(
			pht(
			'Object produced two items with the same builtin key ("%s"). '.
			'Each item must have a unique builtin key.',
			$builtin_key));
			}

			$item_key = $builtin->getMenuItemKey();

			$item = idx($items, $item_key);
			if (!$item) {
			throw new Exception(
			pht(
			'Builtin item ("%s") specifies a bad item key ("%s"); there '.
			'is no corresponding item implementation available.',
			$builtin_key,
			$item_key));
			}

			$item = clone $item;
			$item->setViewer($viewer);
			$item->setEngine($this);

			$builtin
			->setProfilePHID($object->getPHID())
			->attachMenuItem($item)
			->attachProfileObject($object)
			->setMenuItemOrder($order);

			if (!$builtin->shouldEnableForObject($object)) {
			continue;
			}

			$map[$builtin_key] = $builtin;

			$order++;
			}

			return $map;
			}

			private function validateNavigationMenuItem($item) {
			if (!($item instanceof PHUIListItemView)) {
			throw new Exception(
			pht(
			'Expected buildNavigationMenuItems() to return a list of '.
			'PHUIListItemView objects, but got a surprise.'));
			}
			}

			public function getConfigureURI() {
			$mode = $this->getEditMode();

			switch ($mode) {
			case self::MODE_CUSTOM:
			return $this->getItemURI('configure/custom/');
			case self::MODE_GLOBAL:
			return $this->getItemURI('configure/global/');
			}

			return $this->getItemURI('configure/');
			}

			private function buildItemReorderContent(array $items) {
			$viewer = $this->getViewer();
			$object = $this->getProfileObject();

			// If you're reordering global items, you need to be able to edit the
			// object the menu appears on. If you're reordering custom items, you only
			// need to be able to edit the custom object. Currently, the custom object
			// is always the viewing user's own user object.
			$custom_phid = $this->getEditModeCustomPHID();

			if (!$custom_phid) {
			PhabricatorPolicyFilter::requireCapability(
			$viewer,
			$object,
			PhabricatorPolicyCapability::CAN_EDIT);
			} else {
			$policy_object = id(new PhabricatorObjectQuery())
			->setViewer($viewer)
			->withPHIDs(array($custom_phid))
			->executeOne();

			if (!$policy_object) {
			throw new Exception(
			pht(
			'Failed to load custom PHID "%s"!',
			$custom_phid));
			}

			PhabricatorPolicyFilter::requireCapability(
			$viewer,
			$policy_object,
			PhabricatorPolicyCapability::CAN_EDIT);
			}

			$controller = $this->getController();
			$request = $controller->getRequest();

			$request->validateCSRF();

			$order = $request->getStrList('order');

			$by_builtin = array();
			$by_id = array();

			foreach ($items as $key => $item) {
			$id = $item->getID();
			if ($id) {
			$by_id[$id] = $key;
			continue;
			}

			$builtin_key = $item->getBuiltinKey();
			if ($builtin_key) {
			$by_builtin[$builtin_key] = $key;
			continue;
			}
			}

			$key_order = array();
			foreach ($order as $order_item) {
			if (isset($by_id[$order_item])) {
			$key_order[] = $by_id[$order_item];
			continue;
			}
			if (isset($by_builtin[$order_item])) {
			$key_order[] = $by_builtin[$order_item];
			continue;
			}
			}

			$items = array_select_keys($items, $key_order) + $items;

			$type_order =
			PhabricatorProfileMenuItemConfigurationTransaction::TYPE_ORDER;

			$order = 1;
			foreach ($items as $item) {
			$xactions = array();

			$xactions[] = id(new PhabricatorProfileMenuItemConfigurationTransaction())
			->setTransactionType($type_order)
			->setNewValue($order);

			$editor = id(new PhabricatorProfileMenuEditor())
			->setContentSourceFromRequest($request)
			->setActor($viewer)
			->setContinueOnMissingFields(true)
			->setContinueOnNoEffect(true)
			->applyTransactions($item, $xactions);

			$order++;
			}

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

			protected function buildItemViewContent(
			PhabricatorProfileMenuItemConfiguration $item) {
			return $item->newPageContent();
			}

			private function getViewerEditModes() {
			$modes = array();

			$viewer = $this->getViewer();

			if ($viewer->isLoggedIn() && $this->isMenuEnginePersonalizable()) {
			$modes[] = self::MODE_CUSTOM;
			}

			$object = $this->getProfileObject();
			$can_edit = PhabricatorPolicyFilter::hasCapability(
			$viewer,
			$object,
			PhabricatorPolicyCapability::CAN_EDIT);

			if ($can_edit) {
			$modes[] = self::MODE_GLOBAL;
			}

			return $modes;
			}

			protected function isMenuEnginePersonalizable() {
			return true;
			}

			/**
			* Does this engine support pinning items?
			*
			* Personalizable menus disable pinning by default since it creates a number
			* of weird edge cases without providing many benefits for current menus.
			*
			* @return bool True if items may be pinned as default items.
			*/
			protected function isMenuEnginePinnable() {
			return !$this->isMenuEnginePersonalizable();
			}

			private function buildMenuEditModeContent() {
			$viewer = $this->getViewer();

			$modes = $this->getViewerEditModes();
			if (!$modes) {
			return new Aphront404Response();
			}

			if (count($modes) == 1) {
			$mode = head($modes);
			return id(new AphrontRedirectResponse())
			->setURI($this->getItemURI("configure/{$mode}/"));
			}

			$menu = id(new PHUIObjectItemListView())
			->setUser($viewer);

			$modes = array_fuse($modes);

			if (isset($modes['custom'])) {
			$menu->addItem(
			id(new PHUIObjectItemView())
			->setHeader(pht('Personal Menu Items'))
			->setHref($this->getItemURI('configure/custom/'))
			->setImageURI($viewer->getProfileImageURI())
			->addAttribute(pht('Edit the menu for your personal account.')));
			}

			if (isset($modes['global'])) {
			$icon = id(new PHUIIconView())
			->setIcon('fa-globe')
			->setBackground('bg-blue');

			$menu->addItem(
			id(new PHUIObjectItemView())
			->setHeader(pht('Global Menu Items'))
			->setHref($this->getItemURI('configure/global/'))
			->setImageIcon($icon)
			->addAttribute(pht('Edit the global default menu for all users.')));
			}

			$box = id(new PHUIObjectBoxView())
			->setObjectList($menu);

			$header = id(new PHUIHeaderView())
			->setHeader(pht('Manage Menu'))
			->setHeaderIcon('fa-list');

			return id(new PHUITwoColumnView())
			->setHeader($header)
			->setFooter($box);
			}

			private function buildItemConfigureContent(array $items) {
			$viewer = $this->getViewer();
			$object = $this->getProfileObject();

			$filtered_groups = mgroup($items, 'getMenuItemKey');
			foreach ($filtered_groups as $group) {
			$first_item = head($group);
			$first_item->willBuildNavigationItems($group);
			}

			// Users only need to be able to edit the object which this menu appears
			// on if they're editing global menu items. For example, users do not need
			// to be able to edit the Favorites application to add new items to the
			// Favorites menu.
			if (!$this->getCustomPHID()) {
			PhabricatorPolicyFilter::requireCapability(
			$viewer,
			$object,
			PhabricatorPolicyCapability::CAN_EDIT);
			}

			$list_id = celerity_generate_unique_node_id();

			$mode = $this->getEditMode();

			Javelin::initBehavior(
			'reorder-profile-menu-items',
			array(
			'listID' => $list_id,
			'orderURI' => $this->getItemURI("reorder/{$mode}/"),
			));

			$list = id(new PHUIObjectItemListView())
			->setID($list_id)
			->setNoDataString(pht('This menu currently has no items.'));

			foreach ($items as $item) {
			$id = $item->getID();
			$builtin_key = $item->getBuiltinKey();

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

			$view = id(new PHUIObjectItemView());

			$name = $item->getDisplayName();
			$type = $item->getMenuItemTypeName();
			if (!strlen(trim($name))) {
			$name = pht('Untitled "%s" Item', $type);
			}

			$view->setHeader($name);
			$view->addAttribute($type);

			if ($can_edit) {
			$view
			->setGrippable(true)
			->addSigil('profile-menu-item')
			->setMetadata(
			array(
			'key' => nonempty($id, $builtin_key),
			));

			if ($id) {
			$default_uri = $this->getItemURI("default/{$id}/");
			} else {
			$default_uri = $this->getItemURI("default/{$builtin_key}/");
			}

			$default_text = null;

			if ($this->isMenuEnginePinnable()) {
			if ($item->isDefault()) {
			$default_icon = 'fa-thumb-tack green';
			$default_text = pht('Current Default');
			} else if ($item->canMakeDefault()) {
			$default_icon = 'fa-thumb-tack';
			$default_text = pht('Make Default');
			}
			}

			if ($default_text !== null) {
			$view->addAction(
			id(new PHUIListItemView())
			->setHref($default_uri)
			->setWorkflow(true)
			->setName($default_text)
			->setIcon($default_icon));
			}

			if ($id) {
			$view->setHref($this->getItemURI("edit/{$id}/"));
			$hide_uri = $this->getItemURI("hide/{$id}/");
			} else {
			$view->setHref($this->getItemURI("builtin/{$builtin_key}/"));
			$hide_uri = $this->getItemURI("hide/{$builtin_key}/");
			}

			if ($item->isDisabled()) {
			$hide_icon = 'fa-plus';
			$hide_text = pht('Enable');
			} else if ($item->getBuiltinKey() !== null) {
			$hide_icon = 'fa-times';
			$hide_text = pht('Disable');
			} else {
			$hide_icon = 'fa-times';
			$hide_text = pht('Delete');
			}

			$can_disable = $item->canHideMenuItem();

			$view->addAction(
			id(new PHUIListItemView())
			->setHref($hide_uri)
			->setWorkflow(true)
			->setDisabled(!$can_disable)
			->setName($hide_text)
			->setIcon($hide_icon));
			}

			if ($item->isDisabled()) {
			$view->setDisabled(true);
			}

			$list->addItem($view);
			}

			$action_view = id(new PhabricatorActionListView())
			->setUser($viewer);

			$item_types = PhabricatorProfileMenuItem::getAllMenuItems();
			$object = $this->getProfileObject();

			$action_list = id(new PhabricatorActionListView())
			->setViewer($viewer);

			$action_list->addAction(
			id(new PhabricatorActionView())
			->setLabel(true)
			->setName(pht('Add New Menu Item...')));

			foreach ($item_types as $item_type) {
			if (!$item_type->canAddToObject($object)) {
			continue;
			}

			$item_key = $item_type->getMenuItemKey();
			$edit_mode = $this->getEditMode();

			$action_list->addAction(
			id(new PhabricatorActionView())
			->setIcon($item_type->getMenuItemTypeIcon())
			->setName($item_type->getMenuItemTypeName())
			->setHref($this->getItemURI("new/{$edit_mode}/{$item_key}/"))
			->setWorkflow(true));
			}

			$action_list->addAction(
			id(new PhabricatorActionView())
			->setLabel(true)
			->setName(pht('Documentation')));

			$doc_link = PhabricatorEnv::getDoclink('Profile Menu User Guide');
			$doc_name = pht('Profile Menu User Guide');

			$action_list->addAction(
			id(new PhabricatorActionView())
			->setIcon('fa-book')
			->setHref($doc_link)
			->setName($doc_name));

			$header = id(new PHUIHeaderView())
			->setHeader(pht('Menu Items'))
			->setHeaderIcon('fa-list');

			$box = id(new PHUIObjectBoxView())
			->setHeaderText(pht('Current Menu Items'))
			->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
			->setObjectList($list);

			$panel = id(new PHUICurtainPanelView())
			->appendChild($action_view);

			$curtain = id(new PHUICurtainView())
			->setViewer($viewer)
			->setActionList($action_list);

			$view = id(new PHUITwoColumnView())
			->setHeader($header)
			->setCurtain($curtain)
			->setMainColumn(
			array(
			$box,
			));

			return $view;
			}

			private function buildItemNewContent($item_key, $mode) {
			$item_types = PhabricatorProfileMenuItem::getAllMenuItems();
			$item_type = idx($item_types, $item_key);
			if (!$item_type) {
			return new Aphront404Response();
			}

			$object = $this->getProfileObject();
			if (!$item_type->canAddToObject($object)) {
			return new Aphront404Response();
			}

			$custom_phid = $this->getEditModeCustomPHID();

			$configuration = PhabricatorProfileMenuItemConfiguration::initializeNewItem(
			$object,
			$item_type,
			$custom_phid);

			$viewer = $this->getViewer();

			PhabricatorPolicyFilter::requireCapability(
			$viewer,
			$configuration,
			PhabricatorPolicyCapability::CAN_EDIT);

			$controller = $this->getController();

			return id(new PhabricatorProfileMenuEditEngine())
			->setMenuEngine($this)
			->setProfileObject($object)
			->setNewMenuItemConfiguration($configuration)
			->setCustomPHID($custom_phid)
			->setController($controller)
			->buildResponse();
			}

			private function buildItemEditContent() {
			$viewer = $this->getViewer();
			$object = $this->getProfileObject();
			$controller = $this->getController();
			$custom_phid = $this->getEditModeCustomPHID();

			return id(new PhabricatorProfileMenuEditEngine())
			->setMenuEngine($this)
			->setProfileObject($object)
			->setController($controller)
			->setCustomPHID($custom_phid)
			->buildResponse();
			}

			private function buildItemBuiltinContent(
			PhabricatorProfileMenuItemConfiguration $configuration) {

			// If this builtin item has already been persisted, redirect to the
			// edit page.
			$id = $configuration->getID();
			if ($id) {
			return id(new AphrontRedirectResponse())
			->setURI($this->getItemURI("edit/{$id}/"));
			}

			// Otherwise, act like we're creating a new item, we're just starting
			// with the builtin template.
			$viewer = $this->getViewer();

			PhabricatorPolicyFilter::requireCapability(
			$viewer,
			$configuration,
			PhabricatorPolicyCapability::CAN_EDIT);

			$object = $this->getProfileObject();
			$controller = $this->getController();
			$custom_phid = $this->getEditModeCustomPHID();

			return id(new PhabricatorProfileMenuEditEngine())
			->setIsBuiltin(true)
			->setMenuEngine($this)
			->setProfileObject($object)
			->setNewMenuItemConfiguration($configuration)
			->setController($controller)
			->setCustomPHID($custom_phid)
			->buildResponse();
			}

			private function buildItemHideContent(
			PhabricatorProfileMenuItemConfiguration $configuration) {

			$controller = $this->getController();
			$request = $controller->getRequest();
			$viewer = $this->getViewer();

			PhabricatorPolicyFilter::requireCapability(
			$viewer,
			$configuration,
			PhabricatorPolicyCapability::CAN_EDIT);

			if (!$configuration->canHideMenuItem()) {
			return $controller->newDialog()
			->setTitle(pht('Mandatory Item'))
			->appendParagraph(
			pht('This menu item is very important, and can not be disabled.'))
			->addCancelButton($this->getConfigureURI());
			}

			if ($configuration->getBuiltinKey() === null) {
			$new_value = null;

			$title = pht('Delete Menu Item');
			$body = pht('Delete this menu item?');
			$button = pht('Delete Menu Item');
			} else if ($configuration->isDisabled()) {
			$new_value = PhabricatorProfileMenuItemConfiguration::VISIBILITY_VISIBLE;

			$title = pht('Enable Menu Item');
			$body = pht(
			'Enable this menu item? It will appear in the menu again.');
			$button = pht('Enable Menu Item');
			} else {
			$new_value = PhabricatorProfileMenuItemConfiguration::VISIBILITY_DISABLED;

			$title = pht('Disable Menu Item');
			$body = pht(
			'Disable this menu item? It will no longer appear in the menu, but '.
			'you can re-enable it later.');
			$button = pht('Disable Menu Item');
			}

			$v_visibility = $configuration->getVisibility();
			if ($request->isFormPost()) {
			if ($new_value === null) {
			$configuration->delete();
			} else {
			$type_visibility =
			PhabricatorProfileMenuItemConfigurationTransaction::TYPE_VISIBILITY;

			$xactions = array();

			$xactions[] =
			id(new PhabricatorProfileMenuItemConfigurationTransaction())
			->setTransactionType($type_visibility)
			->setNewValue($new_value);

			$editor = id(new PhabricatorProfileMenuEditor())
			->setContentSourceFromRequest($request)
			->setActor($viewer)
			->setContinueOnMissingFields(true)
			->setContinueOnNoEffect(true)
			->applyTransactions($configuration, $xactions);
			}

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

			return $controller->newDialog()
			->setTitle($title)
			->appendParagraph($body)
			->addCancelButton($this->getConfigureURI())
			->addSubmitButton($button);
			}

			private function buildItemDefaultContent(
			PhabricatorProfileMenuItemConfiguration $configuration,
			array $items) {

			$controller = $this->getController();
			$request = $controller->getRequest();
			$viewer = $this->getViewer();

			PhabricatorPolicyFilter::requireCapability(
			$viewer,
			$configuration,
			PhabricatorPolicyCapability::CAN_EDIT);

			$done_uri = $this->getConfigureURI();

			if (!$configuration->canMakeDefault()) {
			return $controller->newDialog()
			->setTitle(pht('Not Defaultable'))
			->appendParagraph(
			pht(
			'This item can not be set as the default item. This is usually '.
			'because the item has no page of its own, or links to an '.
			'external page.'))
			->addCancelButton($done_uri);
			}

			if ($configuration->isDefault()) {
			return $controller->newDialog()
			->setTitle(pht('Already Default'))
			->appendParagraph(
			pht(
			'This item is already set as the default item for this menu.'))
			->addCancelButton($done_uri);
			}

			if ($request->isFormPost()) {
			$key = $configuration->getID();
			if (!$key) {
			$key = $configuration->getBuiltinKey();
			}

			$this->adjustDefault($key);

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

			return $controller->newDialog()
			->setTitle(pht('Make Default'))
			->appendParagraph(
			pht(
			'Set this item as the default for this menu? Users arriving on '.
			'this page will be shown the content of this item by default.'))
			->addCancelButton($done_uri)
			->addSubmitButton(pht('Make Default'));
			}

			protected function newItem() {
			return PhabricatorProfileMenuItemConfiguration::initializeNewBuiltin();
			}

			protected function newManageItem() {
			return $this->newItem()
			->setBuiltinKey(self::ITEM_MANAGE)
			->setMenuItemKey(PhabricatorManageProfileMenuItem::MENUITEMKEY);
			}

			public function adjustDefault($key) {
			$controller = $this->getController();
			$request = $controller->getRequest();
			$viewer = $request->getViewer();

			$items = $this->loadItems(self::MODE_COMBINED);

			// To adjust the default item, we first change any existing items that
			// are marked as defaults to "visible", then make the new default item
			// the default.

			$default = array();
			$visible = array();

			foreach ($items as $item) {
			$builtin_key = $item->getBuiltinKey();
			$id = $item->getID();

			$is_target =
			(($builtin_key !== null) && ($builtin_key === $key)) \|\|
			(($id !== null) && ((int)$id === (int)$key));

			if ($is_target) {
			if (!$item->isDefault()) {
			$default[] = $item;
			}
			} else {
			if ($item->isDefault()) {
			$visible[] = $item;
			}
			}
			}

			$type_visibility =
			PhabricatorProfileMenuItemConfigurationTransaction::TYPE_VISIBILITY;

			$v_visible = PhabricatorProfileMenuItemConfiguration::VISIBILITY_VISIBLE;
			$v_default = PhabricatorProfileMenuItemConfiguration::VISIBILITY_DEFAULT;

			$apply = array(
			array($v_visible, $visible),
			array($v_default, $default),
			);

			foreach ($apply as $group) {
			list($value, $items) = $group;
			foreach ($items as $item) {
			$xactions = array();

			$xactions[] =
			id(new PhabricatorProfileMenuItemConfigurationTransaction())
			->setTransactionType($type_visibility)
			->setNewValue($value);

			$editor = id(new PhabricatorProfileMenuEditor())
			->setContentSourceFromRequest($request)
			->setActor($viewer)
			->setContinueOnMissingFields(true)
			->setContinueOnNoEffect(true)
			->applyTransactions($item, $xactions);
			}
			}

			return $this;
			}

			private function arrangeItems(array $items, $mode) {
			// Sort the items.
			$items = msortv($items, 'getSortVector');

			$object = $this->getProfileObject();

			// If we have some global items and some custom items and are in "combined"
			// mode, put a hard-coded divider item between them.
			if ($mode == self::MODE_COMBINED) {
			$list = array();
			$seen_custom = false;
			$seen_global = false;
			foreach ($items as $item) {
			if ($item->getCustomPHID()) {
			$seen_custom = true;
			} else {
			if ($seen_custom && !$seen_global) {
			$list[] = $this->newItem()
			->setBuiltinKey(self::ITEM_CUSTOM_DIVIDER)
			->setMenuItemKey(PhabricatorDividerProfileMenuItem::MENUITEMKEY)
			->attachProfileObject($object)
			->attachMenuItem(
			new PhabricatorDividerProfileMenuItem());
			}
			$seen_global = true;
			}
			$list[] = $item;
			}
			$items = $list;
			}

			// Normalize keys since callers shouldn't rely on this array being
			// partially keyed.
			$items = array_values($items);

			return $items;
			}


			}

phab/src/applications/search/engine/PhabricatorProfileMenuEngine.phpd1842929afaafeature/better-testing

PhabricatorProfileMenuEngine.phpView Options

phab/src/applications/search/engine/PhabricatorProfileMenuEngine.php
d1842929afaafeature/better-testing

PhabricatorProfileMenuEngine.php
View Options