No OneTemporary
Actions

Size

37 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/controller/DiffusionRepositoryManagePanelsController.php b/src/applications/diffusion/controller/DiffusionRepositoryManagePanelsController.php
	index 8a9f258ebe..a5541acabc 100644
	--- a/src/applications/diffusion/controller/DiffusionRepositoryManagePanelsController.php
	+++ b/src/applications/diffusion/controller/DiffusionRepositoryManagePanelsController.php
	@@ -1,133 +1,138 @@
	<?php

	final class DiffusionRepositoryManagePanelsController
	extends DiffusionRepositoryManageController {

	private $navigation;

	public function buildApplicationMenu() {
	// TODO: This is messy for now; the mobile menu should be set automatically
	// when the body content is a two-column view with navigation.
	if ($this->navigation) {
	return $this->navigation->getMenu();
	}
	return parent::buildApplicationMenu();
	}


	public function handleRequest(AphrontRequest $request) {
	$response = $this->loadDiffusionContext();
	if ($response) {
	return $response;
	}

	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();

	$panels = DiffusionRepositoryManagementPanel::getAllPanels();

	- foreach ($panels as $panel) {
	+ foreach ($panels as $key => $panel) {
	$panel
	->setViewer($viewer)
	->setRepository($repository)
	->setController($this);
	+
	+ if (!$panel->shouldEnableForRepository($repository)) {
	+ unset($panels[$key]);
	+ continue;
	+ }
	}

	$selected = $request->getURIData('panel');
	if (!strlen($selected)) {
	$selected = head_key($panels);
	}

	if (empty($panels[$selected])) {
	return new Aphront404Response();
	}

	$nav = $this->renderSideNav($repository, $panels, $selected);
	$this->navigation = $nav;

	$panel = $panels[$selected];

	$content = $panel->buildManagementPanelContent();

	$title = array(
	$panel->getManagementPanelLabel(),
	$repository->getDisplayName(),
	);

	$crumbs = $this->buildApplicationCrumbs();
	$crumbs->addTextCrumb($panel->getManagementPanelLabel());

	$header_text = pht(
	'%s: %s',
	$repository->getDisplayName(),
	$panel->getManagementPanelLabel());

	$header = id(new PHUIHeaderView())
	->setHeader($header_text)
	->setHeaderIcon('fa-pencil');
	if ($repository->isTracked()) {
	$header->setStatus('fa-check', 'bluegrey', pht('Active'));
	} else {
	$header->setStatus('fa-ban', 'dark', pht('Inactive'));
	}

	$view = id(new PHUITwoColumnView())
	->setHeader($header)
	->setNavigation($nav)
	->setMainColumn($content);

	$curtain = $panel->buildManagementPanelCurtain();
	if ($curtain) {
	$view->setCurtain($curtain);
	}

	return $this->newPage()
	->setTitle($title)
	->setCrumbs($crumbs)
	->appendChild($view);
	}

	private function renderSideNav(
	PhabricatorRepository $repository,
	array $panels,
	$selected) {

	$base_uri = $repository->getPathURI('manage/');
	$base_uri = new PhutilURI($base_uri);

	$nav = id(new AphrontSideNavFilterView())
	->setBaseURI($base_uri);

	foreach ($panels as $panel) {
	$key = $panel->getManagementPanelKey();
	$label = $panel->getManagementPanelLabel();
	$icon = $panel->getManagementPanelIcon();
	$href = $panel->getPanelNavigationURI();

	$item = id(new PHUIListItemView())
	->setKey($key)
	->setName($label)
	->setType(PHUIListItemView::TYPE_LINK)
	->setHref($href)
	->setIcon($icon);

	$nav->addMenuItem($item);
	}

	$nav->selectFilter($selected);

	return $nav;
	}

	public function newTimeline(PhabricatorRepository $repository) {
	$timeline = $this->buildTransactionTimeline(
	$repository,
	new PhabricatorRepositoryTransactionQuery());
	$timeline->setShouldTerminate(true);

	return $timeline;
	}


	}
	diff --git a/src/applications/diffusion/management/DiffusionRepositoryAutomationManagementPanel.php b/src/applications/diffusion/management/DiffusionRepositoryAutomationManagementPanel.php
	index 764f58c5bd..14182a0444 100644
	--- a/src/applications/diffusion/management/DiffusionRepositoryAutomationManagementPanel.php
	+++ b/src/applications/diffusion/management/DiffusionRepositoryAutomationManagementPanel.php
	@@ -1,97 +1,102 @@
	<?php

	final class DiffusionRepositoryAutomationManagementPanel
	extends DiffusionRepositoryManagementPanel {

	const PANELKEY = 'automation';

	public function getManagementPanelLabel() {
	return pht('Automation');
	}

	public function getManagementPanelOrder() {
	return 800;
	}

	+ public function shouldEnableForRepository(
	+ PhabricatorRepository $repository) {
	+ return $repository->isGit();
	+ }
	+
	protected function getEditEngineFieldKeys() {
	return array(
	'automationBlueprintPHIDs',
	);
	}

	public function getManagementPanelIcon() {
	$repository = $this->getRepository();

	if (!$repository->canPerformAutomation()) {
	return 'fa-truck grey';
	}

	$blueprint_phids = $repository->getAutomationBlueprintPHIDs();
	if (!$blueprint_phids) {
	return 'fa-truck grey';
	}

	$is_authorized = DrydockAuthorizationQuery::isFullyAuthorized(
	$repository->getPHID(),
	$blueprint_phids);
	if (!$is_authorized) {
	return 'fa-exclamation-triangle yellow';
	}

	return 'fa-truck';
	}

	protected function buildManagementPanelActions() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();

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

	$can_test = $can_edit && $repository->canPerformAutomation();

	$automation_uri = $this->getEditPageURI();
	$test_uri = $repository->getPathURI('edit/testautomation/');

	return array(
	id(new PhabricatorActionView())
	->setIcon('fa-pencil')
	->setName(pht('Edit Automation'))
	->setHref($automation_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit),
	id(new PhabricatorActionView())
	->setIcon('fa-gamepad')
	->setName(pht('Test Configuration'))
	->setWorkflow(true)
	->setDisabled(!$can_test)
	->setHref($test_uri),
	);
	}

	public function buildManagementPanelContent() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();

	$view = id(new PHUIPropertyListView())
	->setViewer($viewer)
	->setActionList($this->newActions());

	$blueprint_phids = $repository->getAutomationBlueprintPHIDs();
	if (!$blueprint_phids) {
	$blueprint_view = phutil_tag('em', array(), pht('Not Configured'));
	} else {
	$blueprint_view = id(new DrydockObjectAuthorizationView())
	->setUser($viewer)
	->setObjectPHID($repository->getPHID())
	->setBlueprintPHIDs($blueprint_phids);
	}

	$view->addProperty(pht('Automation'), $blueprint_view);

	return $this->newBox(pht('Automation'), $view);
	}

	}
	diff --git a/src/applications/diffusion/management/DiffusionRepositoryBranchesManagementPanel.php b/src/applications/diffusion/management/DiffusionRepositoryBranchesManagementPanel.php
	index 66ac0877dd..b3e7926cfc 100644
	--- a/src/applications/diffusion/management/DiffusionRepositoryBranchesManagementPanel.php
	+++ b/src/applications/diffusion/management/DiffusionRepositoryBranchesManagementPanel.php
	@@ -1,91 +1,96 @@
	<?php

	final class DiffusionRepositoryBranchesManagementPanel
	extends DiffusionRepositoryManagementPanel {

	const PANELKEY = 'branches';

	public function getManagementPanelLabel() {
	return pht('Branches');
	}

	public function getManagementPanelOrder() {
	return 1000;
	}

	+ public function shouldEnableForRepository(
	+ PhabricatorRepository $repository) {
	+ return ($repository->isGit() \|\| $repository->isHg());
	+ }
	+
	public function getManagementPanelIcon() {
	$repository = $this->getRepository();

	$has_any =
	$repository->getDetail('default-branch') \|\|
	$repository->getDetail('branch-filter') \|\|
	$repository->getDetail('close-commits-filter');

	if ($has_any) {
	return 'fa-code-fork';
	} else {
	return 'fa-code-fork grey';
	}
	}

	protected function getEditEngineFieldKeys() {
	return array(
	'defaultBranch',
	'trackOnly',
	'autocloseOnly',
	);
	}

	protected function buildManagementPanelActions() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();

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

	$branches_uri = $this->getEditPageURI();

	return array(
	id(new PhabricatorActionView())
	->setIcon('fa-pencil')
	->setName(pht('Edit Branches'))
	->setHref($branches_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit),
	);
	}

	public function buildManagementPanelContent() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();

	$view = id(new PHUIPropertyListView())
	->setViewer($viewer)
	->setActionList($this->newActions());

	$default_branch = nonempty(
	$repository->getHumanReadableDetail('default-branch'),
	phutil_tag('em', array(), $repository->getDefaultBranch()));
	$view->addProperty(pht('Default Branch'), $default_branch);

	$track_only = nonempty(
	$repository->getHumanReadableDetail('branch-filter', array()),
	phutil_tag('em', array(), pht('Track All Branches')));
	$view->addProperty(pht('Track Only'), $track_only);

	$autoclose_only = nonempty(
	$repository->getHumanReadableDetail('close-commits-filter', array()),
	phutil_tag('em', array(), pht('Autoclose On All Branches')));

	if ($repository->getDetail('disable-autoclose')) {
	$autoclose_only = phutil_tag('em', array(), pht('Disabled'));
	}

	$view->addProperty(pht('Autoclose Only'), $autoclose_only);

	return $this->newBox(pht('Branches'), $view);
	}

	}
	diff --git a/src/applications/diffusion/management/DiffusionRepositoryManagementPanel.php b/src/applications/diffusion/management/DiffusionRepositoryManagementPanel.php
	index 8d23e87406..34047cdb89 100644
	--- a/src/applications/diffusion/management/DiffusionRepositoryManagementPanel.php
	+++ b/src/applications/diffusion/management/DiffusionRepositoryManagementPanel.php
	@@ -1,146 +1,151 @@
	<?php

	abstract class DiffusionRepositoryManagementPanel
	extends Phobject {

	private $viewer;
	private $repository;
	private $controller;

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

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

	final public function setRepository(PhabricatorRepository $repository) {
	$this->repository = $repository;
	return $this;
	}

	final public function getRepository() {
	return $this->repository;
	}

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

	final public function getManagementPanelKey() {
	return $this->getPhobjectClassConstant('PANELKEY');
	}

	abstract public function getManagementPanelLabel();
	abstract public function getManagementPanelOrder();
	abstract public function buildManagementPanelContent();

	public function getManagementPanelIcon() {
	return 'fa-pencil';
	}

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

	+ public function shouldEnableForRepository(
	+ PhabricatorRepository $repository) {
	+ return true;
	+ }
	+
	final protected function newActions() {
	$actions = $this->buildManagementPanelActions();
	if (!$actions) {
	return null;
	}

	$viewer = $this->getViewer();

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

	foreach ($actions as $action) {
	$action_list->addAction($action);
	}

	return $action_list;
	}

	public function buildManagementPanelCurtain() {
	// TODO: Delete or fix this, curtains always render in the left gutter
	// at the moment.
	return null;

	$actions = $this->newActions();
	if (!$actions) {
	return null;
	}

	$viewer = $this->getViewer();

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

	return $curtain;
	}

	public static function getAllPanels() {
	return id(new PhutilClassMapQuery())
	->setAncestorClass(__CLASS__)
	->setUniqueMethod('getManagementPanelKey')
	->setSortMethod('getManagementPanelOrder')
	->execute();
	}

	final protected function newBox($header_text, $body) {
	return id(new PHUIObjectBoxView())
	->setHeaderText($header_text)
	->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
	->appendChild($body);
	}

	final protected function newTimeline() {
	return $this->controller->newTimeline($this->getRepository());
	}

	final public function getPanelURI() {
	$repository = $this->getRepository();
	$key = $this->getManagementPanelKey();
	return $repository->getPathURI("manage/{$key}/");
	}

	final public function newEditEnginePage() {
	$field_keys = $this->getEditEngineFieldKeys();
	if (!$field_keys) {
	return null;
	}

	$key = $this->getManagementPanelKey();
	$label = $this->getManagementPanelLabel();
	$panel_uri = $this->getPanelURI();

	return id(new PhabricatorEditPage())
	->setKey($key)
	->setLabel($label)
	->setViewURI($panel_uri)
	->setFieldKeys($field_keys);
	}

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

	protected function getEditPageURI($page = null) {
	if ($page === null) {
	$page = $this->getManagementPanelKey();
	}

	$repository = $this->getRepository();
	$id = $repository->getID();
	return "/diffusion/edit/{$id}/page/{$page}/";
	}

	public function getPanelNavigationURI() {
	return $this->getPanelURI();
	}

	}
	diff --git a/src/applications/diffusion/management/DiffusionRepositoryStagingManagementPanel.php b/src/applications/diffusion/management/DiffusionRepositoryStagingManagementPanel.php
	index 0d8f9379be..79b716e82a 100644
	--- a/src/applications/diffusion/management/DiffusionRepositoryStagingManagementPanel.php
	+++ b/src/applications/diffusion/management/DiffusionRepositoryStagingManagementPanel.php
	@@ -1,73 +1,79 @@
	<?php

	final class DiffusionRepositoryStagingManagementPanel
	extends DiffusionRepositoryManagementPanel {

	const PANELKEY = 'staging';

	public function getManagementPanelLabel() {
	return pht('Staging Area');
	}

	public function getManagementPanelOrder() {
	return 700;
	}

	+ public function shouldEnableForRepository(
	+ PhabricatorRepository $repository) {
	+ return $repository->isGit();
	+ }
	+
	+
	public function getManagementPanelIcon() {
	$repository = $this->getRepository();

	$staging_uri = $repository->getStagingURI();

	if ($staging_uri) {
	return 'fa-upload';
	} else {
	return 'fa-upload grey';
	}
	}

	protected function getEditEngineFieldKeys() {
	return array(
	'stagingAreaURI',
	);
	}

	protected function buildManagementPanelActions() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();

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

	$staging_uri = $this->getEditPageURI();

	return array(
	id(new PhabricatorActionView())
	->setIcon('fa-pencil')
	->setName(pht('Edit Staging'))
	->setHref($staging_uri)
	->setDisabled(!$can_edit)
	->setWorkflow(!$can_edit),
	);
	}

	public function buildManagementPanelContent() {
	$repository = $this->getRepository();
	$viewer = $this->getViewer();

	$view = id(new PHUIPropertyListView())
	->setViewer($viewer)
	->setActionList($this->newActions());

	$staging_uri = $repository->getStagingURI();
	if (!$staging_uri) {
	$staging_uri = phutil_tag('em', array(), pht('No Staging Area'));
	}

	$view->addProperty(pht('Staging Area URI'), $staging_uri);

	return $this->newBox(pht('Staging Area'), $view);
	}

	}
	diff --git a/src/applications/repository/storage/PhabricatorRepositoryURI.php b/src/applications/repository/storage/PhabricatorRepositoryURI.php
	index 227b13012f..21fc791de5 100644
	--- a/src/applications/repository/storage/PhabricatorRepositoryURI.php
	+++ b/src/applications/repository/storage/PhabricatorRepositoryURI.php
	@@ -1,715 +1,722 @@
	<?php

	final class PhabricatorRepositoryURI
	extends PhabricatorRepositoryDAO
	implements
	PhabricatorApplicationTransactionInterface,
	PhabricatorPolicyInterface,
	PhabricatorExtendedPolicyInterface,
	PhabricatorConduitResultInterface {

	protected $repositoryPHID;
	protected $uri;
	protected $builtinProtocol;
	protected $builtinIdentifier;
	protected $credentialPHID;
	protected $ioType;
	protected $displayType;
	protected $isDisabled;

	private $repository = self::ATTACHABLE;

	const BUILTIN_PROTOCOL_SSH = 'ssh';
	const BUILTIN_PROTOCOL_HTTP = 'http';
	const BUILTIN_PROTOCOL_HTTPS = 'https';

	const BUILTIN_IDENTIFIER_ID = 'id';
	const BUILTIN_IDENTIFIER_SHORTNAME = 'shortname';
	const BUILTIN_IDENTIFIER_CALLSIGN = 'callsign';

	const DISPLAY_DEFAULT = 'default';
	const DISPLAY_NEVER = 'never';
	const DISPLAY_ALWAYS = 'always';

	const IO_DEFAULT = 'default';
	const IO_OBSERVE = 'observe';
	const IO_MIRROR = 'mirror';
	const IO_NONE = 'none';
	const IO_READ = 'read';
	const IO_READWRITE = 'readwrite';

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'uri' => 'text255',
	'builtinProtocol' => 'text32?',
	'builtinIdentifier' => 'text32?',
	'credentialPHID' => 'phid?',
	'ioType' => 'text32',
	'displayType' => 'text32',
	'isDisabled' => 'bool',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_builtin' => array(
	'columns' => array(
	'repositoryPHID',
	'builtinProtocol',
	'builtinIdentifier',
	),
	'unique' => true,
	),
	),
	) + parent::getConfiguration();
	}

	public static function initializeNewURI() {
	return id(new self())
	->setIoType(self::IO_DEFAULT)
	->setDisplayType(self::DISPLAY_DEFAULT)
	->setIsDisabled(0);
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorRepositoryURIPHIDType::TYPECONST);
	}

	public function attachRepository(PhabricatorRepository $repository) {
	$this->repository = $repository;
	return $this;
	}

	public function getRepository() {
	return $this->assertAttached($this->repository);
	}

	public function getRepositoryURIBuiltinKey() {
	if (!$this->getBuiltinProtocol()) {
	return null;
	}

	$parts = array(
	$this->getBuiltinProtocol(),
	$this->getBuiltinIdentifier(),
	);

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

	public function isBuiltin() {
	return (bool)$this->getBuiltinProtocol();
	}

	public function getEffectiveDisplayType() {
	$display = $this->getDisplayType();

	if ($display != self::DISPLAY_DEFAULT) {
	return $display;
	}

	return $this->getDefaultDisplayType();
	}

	public function getDefaultDisplayType() {
	switch ($this->getEffectiveIOType()) {
	case self::IO_MIRROR:
	case self::IO_OBSERVE:
	case self::IO_NONE:
	return self::DISPLAY_NEVER;
	case self::IO_READ:
	case self::IO_READWRITE:
	// By default, only show the "best" version of the builtin URI, not the
	// other redundant versions.
	$repository = $this->getRepository();
	$other_uris = $repository->getURIs();

	$identifier_value = array(
	self::BUILTIN_IDENTIFIER_CALLSIGN => 3,
	self::BUILTIN_IDENTIFIER_SHORTNAME => 2,
	self::BUILTIN_IDENTIFIER_ID => 1,
	);

	$have_identifiers = array();
	foreach ($other_uris as $other_uri) {
	if ($other_uri->getIsDisabled()) {
	continue;
	}

	$identifier = $other_uri->getBuiltinIdentifier();
	if (!$identifier) {
	continue;
	}

	$have_identifiers[$identifier] = $identifier_value[$identifier];
	}

	$best_identifier = max($have_identifiers);
	$this_identifier = $identifier_value[$this->getBuiltinIdentifier()];

	if ($this_identifier < $best_identifier) {
	return self::DISPLAY_NEVER;
	}

	return self::DISPLAY_ALWAYS;
	}

	return self::DISPLAY_NEVER;
	}


	public function getEffectiveIOType() {
	$io = $this->getIoType();

	if ($io != self::IO_DEFAULT) {
	return $io;
	}

	return $this->getDefaultIOType();
	}

	public function getDefaultIOType() {
	if ($this->isBuiltin()) {
	$repository = $this->getRepository();
	$other_uris = $repository->getURIs();

	$any_observe = false;
	foreach ($other_uris as $other_uri) {
	if ($other_uri->getIoType() == self::IO_OBSERVE) {
	$any_observe = true;
	break;
	}
	}

	if ($any_observe) {
	return self::IO_READ;
	} else {
	return self::IO_READWRITE;
	}
	}

	return self::IO_NONE;
	}


	public function getDisplayURI() {
	return $this->getURIObject(false);
	}

	public function getEffectiveURI() {
	return $this->getURIObject(true);
	}

	public function getURIEnvelope() {
	$uri = $this->getEffectiveURI();

	$command_engine = $this->newCommandEngine();

	$is_http = $command_engine->isAnyHTTPProtocol();
	// For SVN, we use `--username` and `--password` flags separately in the
	// CommandEngine, so we don't need to add any credentials here.
	$is_svn = $this->getRepository()->isSVN();
	$credential_phid = $this->getCredentialPHID();

	if ($is_http && !$is_svn && $credential_phid) {
	$key = PassphrasePasswordKey::loadFromPHID(
	$credential_phid,
	PhabricatorUser::getOmnipotentUser());

	$uri->setUser($key->getUsernameEnvelope()->openEnvelope());
	$uri->setPass($key->getPasswordEnvelope()->openEnvelope());
	}

	return new PhutilOpaqueEnvelope((string)$uri);
	}

	private function getURIObject($normalize) {
	// Users can provide Git/SCP-style URIs in the form "user@host:path".
	// These are equivalent to "ssh://user@host/path". We use the more standard
	// form internally, and convert to it if we need to specify a port number,
	// but try to preserve what the user typed when displaying the URI.

	if ($this->isBuiltin()) {
	$builtin_protocol = $this->getForcedProtocol();
	$builtin_domain = $this->getForcedHost();
	$raw_uri = "{$builtin_protocol}://{$builtin_domain}";
	} else {
	$raw_uri = $this->getURI();
	}

	$port = $this->getForcedPort();

	$default_ports = array(
	'ssh' => 22,
	'http' => 80,
	'https' => 443,
	);

	$uri = new PhutilURI($raw_uri);

	// Make sure to remove any password from the URI before we do anything
	// with it; this should always be provided by the associated credential.
	$uri->setPass(null);

	if (!$uri->getProtocol()) {
	$git_uri = new PhutilGitURI($raw_uri);

	// We must normalize this Git-style URI into a normal URI
	$must_normalize = ($port && ($port != $default_ports['ssh']));
	if ($must_normalize \|\| $normalize) {
	$domain = $git_uri->getDomain();


	$uri = id(new PhutilURI("ssh://{$domain}"))
	->setUser($git_uri->getUser())
	->setPath($git_uri->getPath());
	} else {
	$uri = $git_uri;
	}
	}

	$is_normal = ($uri instanceof PhutilURI);

	if ($is_normal) {
	$protocol = $this->getForcedProtocol();
	if ($protocol) {
	$uri->setProtocol($protocol);
	}

	if ($port) {
	$uri->setPort($port);
	}

	// Remove any explicitly set default ports.
	$uri_port = $uri->getPort();
	$uri_protocol = $uri->getProtocol();

	$uri_default = idx($default_ports, $uri_protocol);
	if ($uri_default && ($uri_default == $uri_port)) {
	$uri->setPort(null);
	}
	}

	$user = $this->getForcedUser();
	if ($user) {
	$uri->setUser($user);
	}

	$host = $this->getForcedHost();
	if ($host) {
	$uri->setDomain($host);
	}

	$path = $this->getForcedPath();
	if ($path) {
	$uri->setPath($path);
	}

	return $uri;
	}


	private function getForcedProtocol() {
	+ $repository = $this->getRepository();
	+
	switch ($this->getBuiltinProtocol()) {
	case self::BUILTIN_PROTOCOL_SSH:
	- return 'ssh';
	+ if ($repository->isSVN()) {
	+ return 'svn+ssh';
	+ } else {
	+ return 'ssh';
	+ }
	case self::BUILTIN_PROTOCOL_HTTP:
	return 'http';
	case self::BUILTIN_PROTOCOL_HTTPS:
	return 'https';
	default:
	return null;
	}
	}

	private function getForcedUser() {
	switch ($this->getBuiltinProtocol()) {
	case self::BUILTIN_PROTOCOL_SSH:
	return AlmanacKeys::getClusterSSHUser();
	default:
	return null;
	}
	}

	private function getForcedHost() {
	$phabricator_uri = PhabricatorEnv::getURI('/');
	$phabricator_uri = new PhutilURI($phabricator_uri);

	$phabricator_host = $phabricator_uri->getDomain();

	switch ($this->getBuiltinProtocol()) {
	case self::BUILTIN_PROTOCOL_SSH:
	$ssh_host = PhabricatorEnv::getEnvConfig('diffusion.ssh-host');
	if ($ssh_host !== null) {
	return $ssh_host;
	}
	return $phabricator_host;
	case self::BUILTIN_PROTOCOL_HTTP:
	case self::BUILTIN_PROTOCOL_HTTPS:
	return $phabricator_host;
	default:
	return null;
	}
	}

	private function getForcedPort() {
	switch ($this->getBuiltinProtocol()) {
	case self::BUILTIN_PROTOCOL_SSH:
	return PhabricatorEnv::getEnvConfig('diffusion.ssh-port');
	case self::BUILTIN_PROTOCOL_HTTP:
	case self::BUILTIN_PROTOCOL_HTTPS:
	default:
	return null;
	}
	}

	private function getForcedPath() {
	if (!$this->isBuiltin()) {
	return null;
	}

	$repository = $this->getRepository();

	$id = $repository->getID();
	$callsign = $repository->getCallsign();
	$short_name = $repository->getRepositorySlug();

	$clone_name = $repository->getCloneName();

	if ($repository->isGit()) {
	$suffix = '.git';
	} else if ($repository->isHg()) {
	$suffix = '/';
	} else {
	$suffix = '';
	+ $clone_name = '';
	}

	switch ($this->getBuiltinIdentifier()) {
	case self::BUILTIN_IDENTIFIER_ID:
	return "/diffusion/{$id}/{$clone_name}{$suffix}";
	case self::BUILTIN_IDENTIFIER_SHORTNAME:
	return "/source/{$short_name}{$suffix}";
	case self::BUILTIN_IDENTIFIER_CALLSIGN:
	return "/diffusion/{$callsign}/{$clone_name}{$suffix}";
	default:
	return null;
	}
	}

	public function getViewURI() {
	$id = $this->getID();
	return $this->getRepository()->getPathURI("uri/view/{$id}/");
	}

	public function getEditURI() {
	$id = $this->getID();
	return $this->getRepository()->getPathURI("uri/edit/{$id}/");
	}

	public function getAvailableIOTypeOptions() {
	$options = array(
	self::IO_DEFAULT,
	self::IO_NONE,
	);

	if ($this->isBuiltin()) {
	$options[] = self::IO_READ;
	$options[] = self::IO_READWRITE;
	} else {
	$options[] = self::IO_OBSERVE;
	$options[] = self::IO_MIRROR;
	}

	$map = array();
	$io_map = self::getIOTypeMap();
	foreach ($options as $option) {
	$spec = idx($io_map, $option, array());

	$label = idx($spec, 'label', $option);
	$short = idx($spec, 'short');

	$name = pht('%s: %s', $label, $short);
	$map[$option] = $name;
	}

	return $map;
	}

	public function getAvailableDisplayTypeOptions() {
	$options = array(
	self::DISPLAY_DEFAULT,
	self::DISPLAY_ALWAYS,
	self::DISPLAY_NEVER,
	);

	$map = array();
	$display_map = self::getDisplayTypeMap();
	foreach ($options as $option) {
	$spec = idx($display_map, $option, array());

	$label = idx($spec, 'label', $option);
	$short = idx($spec, 'short');

	$name = pht('%s: %s', $label, $short);
	$map[$option] = $name;
	}

	return $map;
	}

	public static function getIOTypeMap() {
	return array(
	self::IO_DEFAULT => array(
	'label' => pht('Default'),
	'short' => pht('Use default behavior.'),
	),
	self::IO_OBSERVE => array(
	'icon' => 'fa-download',
	'color' => 'green',
	'label' => pht('Observe'),
	'note' => pht(
	'Phabricator will observe changes to this URI and copy them.'),
	'short' => pht('Copy from a remote.'),
	),
	self::IO_MIRROR => array(
	'icon' => 'fa-upload',
	'color' => 'green',
	'label' => pht('Mirror'),
	'note' => pht(
	'Phabricator will push a copy of any changes to this URI.'),
	'short' => pht('Push a copy to a remote.'),
	),
	self::IO_NONE => array(
	'icon' => 'fa-times',
	'color' => 'grey',
	'label' => pht('No I/O'),
	'note' => pht(
	'Phabricator will not push or pull any changes to this URI.'),
	'short' => pht('Do not perform any I/O.'),
	),
	self::IO_READ => array(
	'icon' => 'fa-folder',
	'color' => 'blue',
	'label' => pht('Read Only'),
	'note' => pht(
	'Phabricator will serve a read-only copy of the repository from '.
	'this URI.'),
	'short' => pht('Serve repository in read-only mode.'),
	),
	self::IO_READWRITE => array(
	'icon' => 'fa-folder-open',
	'color' => 'blue',
	'label' => pht('Read/Write'),
	'note' => pht(
	'Phabricator will serve a read/write copy of the repository from '.
	'this URI.'),
	'short' => pht('Serve repository in read/write mode.'),
	),
	);
	}

	public static function getDisplayTypeMap() {
	return array(
	self::DISPLAY_DEFAULT => array(
	'label' => pht('Default'),
	'short' => pht('Use default behavior.'),
	),
	self::DISPLAY_ALWAYS => array(
	'icon' => 'fa-eye',
	'color' => 'green',
	'label' => pht('Visible'),
	'note' => pht('This URI will be shown to users as a clone URI.'),
	'short' => pht('Show as a clone URI.'),
	),
	self::DISPLAY_NEVER => array(
	'icon' => 'fa-eye-slash',
	'color' => 'grey',
	'label' => pht('Hidden'),
	'note' => pht(
	'This URI will be hidden from users.'),
	'short' => pht('Do not show as a clone URI.'),
	),
	);
	}

	public function newCommandEngine() {
	$repository = $this->getRepository();
	$protocol = $this->getEffectiveURI()->getProtocol();

	return DiffusionCommandEngine::newCommandEngine($repository)
	->setCredentialPHID($this->getCredentialPHID())
	->setProtocol($protocol);
	}

	public function getURIScore() {
	$score = 0;

	$io_points = array(
	self::IO_READWRITE => 20,
	self::IO_READ => 10,
	);
	$score += idx($io_points, $this->getEffectiveIoType(), 0);

	$protocol_points = array(
	self::BUILTIN_PROTOCOL_SSH => 3,
	self::BUILTIN_PROTOCOL_HTTPS => 2,
	self::BUILTIN_PROTOCOL_HTTP => 1,
	);
	$score += idx($protocol_points, $this->getBuiltinProtocol(), 0);

	return $score;
	}



	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new DiffusionURIEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhabricatorRepositoryURITransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {
	return $timeline;
	}


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


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	case PhabricatorPolicyCapability::CAN_EDIT:
	return PhabricatorPolicies::getMostOpenPolicy();
	}
	}

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

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


	/* -( PhabricatorExtendedPolicyInterface )--------------------------------- */


	public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
	$extended = array();

	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_EDIT:
	// To edit a repository URI, you must be able to edit the
	// corresponding repository.
	$extended[] = array($this->getRepository(), $capability);
	break;
	}

	return $extended;
	}


	/* -( PhabricatorConduitResultInterface )---------------------------------- */


	public function getFieldSpecificationsForConduit() {
	return array(
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('repositoryPHID')
	->setType('phid')
	->setDescription(pht('The associated repository PHID.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('uri')
	->setType('map<string, string>')
	->setDescription(pht('The raw and effective URI.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('io')
	->setType('map<string, const>')
	->setDescription(
	pht('The raw, default, and effective I/O Type settings.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('display')
	->setType('map<string, const>')
	->setDescription(
	pht('The raw, default, and effective Display Type settings.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('credentialPHID')
	->setType('phid?')
	->setDescription(
	pht('The associated credential PHID, if one exists.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('disabled')
	->setType('bool')
	->setDescription(pht('True if the URI is disabled.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('builtin')
	->setType('map<string, string>')
	->setDescription(
	pht('Information about builtin URIs.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('dateCreated')
	->setType('int')
	->setDescription(
	pht('Epoch timestamp when the object was created.')),
	id(new PhabricatorConduitSearchFieldSpecification())
	->setKey('dateModified')
	->setType('int')
	->setDescription(
	pht('Epoch timestamp when the object was last updated.')),
	);
	}

	public function getFieldValuesForConduit() {
	return array(
	'repositoryPHID' => $this->getRepositoryPHID(),
	'uri' => array(
	'raw' => $this->getURI(),
	'display' => (string)$this->getDisplayURI(),
	'effective' => (string)$this->getEffectiveURI(),
	),
	'io' => array(
	'raw' => $this->getIOType(),
	'default' => $this->getDefaultIOType(),
	'effective' => $this->getEffectiveIOType(),
	),
	'display' => array(
	'raw' => $this->getDisplayType(),
	'default' => $this->getDefaultDisplayType(),
	'effective' => $this->getEffectiveDisplayType(),
	),
	'credentialPHID' => $this->getCredentialPHID(),
	'disabled' => (bool)$this->getIsDisabled(),
	'builtin' => array(
	'protocol' => $this->getBuiltinProtocol(),
	'identifier' => $this->getBuiltinIdentifier(),
	),
	'dateCreated' => $this->getDateCreated(),
	'dateModified' => $this->getDateModified(),
	);
	}

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

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 21, 12:57 PM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 123675
Default Alt Text: (37 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions