DiffusionRepositoryCreateController.php
0a62f13464b8stable

DiffusionRepositoryCreateController.php
View Options

			<?php

			final class DiffusionRepositoryCreateController
			extends DiffusionRepositoryEditController {

			private $edit;
			private $repository;

			public function willProcessRequest(array $data) {
			parent::willProcessRequest($data);
			$this->edit = $data['edit'];
			}

			public function processRequest() {
			$request = $this->getRequest();
			$viewer = $request->getUser();

			// NOTE: We can end up here via either "Create Repository", or via
			// "Import Repository", or via "Edit Remote", or via "Edit Policies". In
			// the latter two cases, we show only a few of the pages.

			$repository = null;
			switch ($this->edit) {
			case 'remote':
			case 'policy':
			$repository = $this->getDiffusionRequest()->getRepository();

			// Make sure we have CAN_EDIT.
			PhabricatorPolicyFilter::requireCapability(
			$viewer,
			$repository,
			PhabricatorPolicyCapability::CAN_EDIT);

			$this->setRepository($repository);

			$cancel_uri = $this->getRepositoryControllerURI($repository, 'edit/');
			break;
			case 'import':
			case 'create':
			$this->requireApplicationCapability(
			DiffusionCapabilityCreateRepositories::CAPABILITY);

			$cancel_uri = $this->getApplicationURI('new/');
			break;
			default:
			throw new Exception('Invalid edit operation!');
			}

			$form = id(new PHUIPagedFormView())
			->setUser($viewer)
			->setCancelURI($cancel_uri);

			switch ($this->edit) {
			case 'remote':
			$title = pht('Edit Remote');
			$form
			->addPage('remote-uri', $this->buildRemoteURIPage())
			->addPage('auth', $this->buildAuthPage());
			break;
			case 'policy':
			$title = pht('Edit Policies');
			$form
			->addPage('policy', $this->buildPolicyPage());
			break;
			case 'create':
			$title = pht('Create Repository');
			$form
			->addPage('vcs', $this->buildVCSPage())
			->addPage('name', $this->buildNamePage())
			->addPage('policy', $this->buildPolicyPage())
			->addPage('done', $this->buildDonePage());
			break;
			case 'import':
			$title = pht('Import Repository');
			$form
			->addPage('vcs', $this->buildVCSPage())
			->addPage('name', $this->buildNamePage())
			->addPage('remote-uri', $this->buildRemoteURIPage())
			->addPage('auth', $this->buildAuthPage())
			->addPage('policy', $this->buildPolicyPage())
			->addPage('done', $this->buildDonePage());
			break;
			}

			if ($request->isFormPost()) {
			$form->readFromRequest($request);
			if ($form->isComplete()) {

			$is_create = ($this->edit === 'import' \|\| $this->edit === 'create');
			$is_auth = ($this->edit == 'import' \|\| $this->edit == 'remote');
			$is_policy = ($this->edit != 'remote');
			$is_init = ($this->edit == 'create');

			if ($is_create) {
			$repository = PhabricatorRepository::initializeNewRepository(
			$viewer);
			}

			$template = id(new PhabricatorRepositoryTransaction());

			$type_name = PhabricatorRepositoryTransaction::TYPE_NAME;
			$type_vcs = PhabricatorRepositoryTransaction::TYPE_VCS;
			$type_activate = PhabricatorRepositoryTransaction::TYPE_ACTIVATE;
			$type_local_path = PhabricatorRepositoryTransaction::TYPE_LOCAL_PATH;
			$type_remote_uri = PhabricatorRepositoryTransaction::TYPE_REMOTE_URI;
			$type_hosting = PhabricatorRepositoryTransaction::TYPE_HOSTING;
			$type_credential = PhabricatorRepositoryTransaction::TYPE_CREDENTIAL;
			$type_view = PhabricatorTransactions::TYPE_VIEW_POLICY;
			$type_edit = PhabricatorTransactions::TYPE_EDIT_POLICY;
			$type_push = PhabricatorRepositoryTransaction::TYPE_PUSH_POLICY;

			$xactions = array();

			// If we're creating a new repository, set all this core stuff.
			if ($is_create) {
			$callsign = $form->getPage('name')
			->getControl('callsign')->getValue();

			// We must set this to a unique value to save the repository
			// initially, and it's immutable, so we don't bother using
			// transactions to apply this change.
			$repository->setCallsign($callsign);

			// Put the repository in "Importing" mode until we finish
			// parsing it.
			$repository->setDetail('importing', true);

			$xactions[] = id(clone $template)
			->setTransactionType($type_name)
			->setNewValue(
			$form->getPage('name')->getControl('name')->getValue());

			$xactions[] = id(clone $template)
			->setTransactionType($type_vcs)
			->setNewValue(
			$form->getPage('vcs')->getControl('vcs')->getValue());

			$activate = $form->getPage('done')
			->getControl('activate')->getValue();
			$xactions[] = id(clone $template)
			->setTransactionType($type_activate)
			->setNewValue(
			($activate == 'start'));

			$default_local_path = PhabricatorEnv::getEnvConfig(
			'repository.default-local-path');

			$default_local_path = rtrim($default_local_path, '/');
			$default_local_path = $default_local_path.'/'.$callsign.'/';

			$xactions[] = id(clone $template)
			->setTransactionType($type_local_path)
			->setNewValue($default_local_path);
			}

			if ($is_init) {
			$xactions[] = id(clone $template)
			->setTransactionType($type_hosting)
			->setNewValue(true);
			}

			if ($is_auth) {
			$xactions[] = id(clone $template)
			->setTransactionType($type_remote_uri)
			->setNewValue(
			$form->getPage('remote-uri')->getControl('remoteURI')
			->getValue());

			$xactions[] = id(clone $template)
			->setTransactionType($type_credential)
			->setNewValue(
			$form->getPage('auth')->getControl('credential')->getValue());
			}

			if ($is_policy) {
			$xactions[] = id(clone $template)
			->setTransactionType($type_view)
			->setNewValue(
			$form->getPage('policy')->getControl('viewPolicy')->getValue());

			$xactions[] = id(clone $template)
			->setTransactionType($type_edit)
			->setNewValue(
			$form->getPage('policy')->getControl('editPolicy')->getValue());

			if ($is_init \|\| $repository->isHosted()) {
			$xactions[] = id(clone $template)
			->setTransactionType($type_push)
			->setNewValue(
			$form->getPage('policy')->getControl('pushPolicy')->getValue());
			}
			}

			id(new PhabricatorRepositoryEditor())
			->setContinueOnNoEffect(true)
			->setContentSourceFromRequest($request)
			->setActor($viewer)
			->applyTransactions($repository, $xactions);

			$repo_uri = $this->getRepositoryControllerURI($repository, 'edit/');
			return id(new AphrontRedirectResponse())->setURI($repo_uri);
			}
			} else {
			$dict = array();
			if ($repository) {
			$dict = array(
			'remoteURI' => $repository->getRemoteURI(),
			'credential' => $repository->getCredentialPHID(),
			'viewPolicy' => $repository->getViewPolicy(),
			'editPolicy' => $repository->getEditPolicy(),
			'pushPolicy' => $repository->getPushPolicy(),
			);
			}
			$form->readFromObject($dict);
			}

			$crumbs = $this->buildApplicationCrumbs();
			$crumbs->addTextCrumb($title);

			return $this->buildApplicationPage(
			array(
			$crumbs,
			$form,
			),
			array(
			'title' => $title,
			'device' => true,
			));
			}


			/* -( Page: VCS Type )----------------------------------------------------- */


			private function buildVCSPage() {

			$is_import = ($this->edit == 'import');

			if ($is_import) {
			$git_str = pht(
			'Import a Git repository (for example, a repository hosted '.
			'on GitHub).');
			$hg_str = pht(
			'Import a Mercurial repository (for example, a repository '.
			'hosted on Bitbucket).');
			$svn_str = pht('Import a Subversion repository.');
			} else {
			$git_str = pht('Create a new, empty Git repository.');
			$hg_str = pht('Create a new, empty Mercurial repository.');
			$svn_str = pht('Create a new, empty Subversion repository.');
			}

			$control = id(new AphrontFormRadioButtonControl())
			->setName('vcs')
			->setLabel(pht('Type'))
			->addButton(
			PhabricatorRepositoryType::REPOSITORY_TYPE_GIT,
			pht('Git'),
			$git_str)
			->addButton(
			PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL,
			pht('Mercurial'),
			$hg_str)
			->addButton(
			PhabricatorRepositoryType::REPOSITORY_TYPE_SVN,
			pht('Subversion'),
			$svn_str);

			if ($is_import) {
			$control->addButton(
			PhabricatorRepositoryType::REPOSITORY_TYPE_PERFORCE,
			pht('Perforce'),
			pht(
			'Perforce is not directly supported, but you can import '.
			'a Perforce repository as a Git repository using %s.',
			phutil_tag(
			'a',
			array(
			'href' =>
			'http://www.perforce.com/product/components/git-fusion',
			'target' => '_blank',
			),
			pht('Perforce Git Fusion'))),
			'disabled',
			$disabled = true);
			}

			return id(new PHUIFormPageView())
			->setPageName(pht('Repository Type'))
			->setUser($this->getRequest()->getUser())
			->setValidateFormPageCallback(array($this, 'validateVCSPage'))
			->addControl($control);
			}

			public function validateVCSPage(PHUIFormPageView $page) {
			$valid = array(
			PhabricatorRepositoryType::REPOSITORY_TYPE_GIT => true,
			PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL => true,
			PhabricatorRepositoryType::REPOSITORY_TYPE_SVN => true,
			);

			$c_vcs = $page->getControl('vcs');
			$v_vcs = $c_vcs->getValue();
			if (!$v_vcs) {
			$c_vcs->setError(pht('Required'));
			$page->addPageError(
			pht('You must select a version control system.'));
			} else if (empty($valid[$v_vcs])) {
			$c_vcs->setError(pht('Invalid'));
			$page->addPageError(
			pht('You must select a valid version control system.'));
			}

			return $c_vcs->isValid();
			}


			/* -( Page: Name and Callsign )-------------------------------------------- */


			private function buildNamePage() {
			return id(new PHUIFormPageView())
			->setUser($this->getRequest()->getUser())
			->setPageName(pht('Repository Name and Location'))
			->setValidateFormPageCallback(array($this, 'validateNamePage'))
			->addRemarkupInstructions(
			pht(
			'Choose a human-readable name for this repository, like '.
			'"CompanyName Mobile App" or "CompanyName Backend Server". You '.
			'can change this later.'))
			->addControl(
			id(new AphrontFormTextControl())
			->setName('name')
			->setLabel(pht('Name'))
			->setCaption(pht('Human-readable repository name.')))
			->addRemarkupInstructions(
			pht(
			'Choose a "Callsign" for the repository. This is a short, '.
			'unique string which identifies commits elsewhere in Phabricator. '.
			'For example, you might use `M` for your mobile app repository '.
			'and `B` for your backend repository.'.
			"\n\n".
			'Callsigns must be UPPERCASE, and can not be edited after the '.
			'repository is created. Generally, you should choose short '.
			'callsigns.'))
			->addControl(
			id(new AphrontFormTextControl())
			->setName('callsign')
			->setLabel(pht('Callsign'))
			->setCaption(pht('Short UPPERCASE identifier.')));
			}

			public function validateNamePage(PHUIFormPageView $page) {
			$c_name = $page->getControl('name');
			$v_name = $c_name->getValue();
			if (!strlen($v_name)) {
			$c_name->setError(pht('Required'));
			$page->addPageError(
			pht('You must choose a name for this repository.'));
			}

			$c_call = $page->getControl('callsign');
			$v_call = $c_call->getValue();
			if (!strlen($v_call)) {
			$c_call->setError(pht('Required'));
			$page->addPageError(
			pht('You must choose a callsign for this repository.'));
			} else if (!preg_match('/^[A-Z]+\z/', $v_call)) {
			$c_call->setError(pht('Invalid'));
			$page->addPageError(
			pht('The callsign must contain only UPPERCASE letters.'));
			} else {
			$exists = false;
			try {
			$repo = id(new PhabricatorRepositoryQuery())
			->setViewer($this->getRequest()->getUser())
			->withCallsigns(array($v_call))
			->executeOne();
			$exists = (bool)$repo;
			} catch (PhabricatorPolicyException $ex) {
			$exists = true;
			}
			if ($exists) {
			$c_call->setError(pht('Not Unique'));
			$page->addPageError(
			pht(
			'Another repository already uses that callsign. You must choose '.
			'a unique callsign.'));
			}
			}

			return $c_name->isValid() &&
			$c_call->isValid();
			}


			/* -( Page: Remote URI )--------------------------------------------------- */


			private function buildRemoteURIPage() {
			return id(new PHUIFormPageView())
			->setUser($this->getRequest()->getUser())
			->setPageName(pht('Repository Remote URI'))
			->setValidateFormPageCallback(array($this, 'validateRemoteURIPage'))
			->setAdjustFormPageCallback(array($this, 'adjustRemoteURIPage'))
			->addControl(
			id(new AphrontFormTextControl())
			->setName('remoteURI'));
			}

			public function adjustRemoteURIPage(PHUIFormPageView $page) {
			$form = $page->getForm();

			$is_git = false;
			$is_svn = false;
			$is_mercurial = false;

			if ($this->getRepository()) {
			$vcs = $this->getRepository()->getVersionControlSystem();
			} else {
			$vcs = $form->getPage('vcs')->getControl('vcs')->getValue();
			}

			switch ($vcs) {
			case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
			$is_git = true;
			break;
			case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
			$is_svn = true;
			break;
			case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
			$is_mercurial = true;
			break;
			default:
			throw new Exception('Unsupported VCS!');
			}

			$has_local = ($is_git \|\| $is_mercurial);
			if ($is_git) {
			$uri_label = pht('Remote URI');
			$instructions = pht(
			'Enter the URI to clone this Git repository from. It should usually '.
			'look like one of these examples:'.
			"\n\n".
			"\| Example Git Remote URIs \|\n".
			"\| ----------------------- \|\n".
			"\| `git@github.com:example/example.git` \|\n".
			"\| `ssh://user@host.com/git/example.git` \|\n".
			"\| `file:///local/path/to/repo` \|\n".
			"\| `https://example.com/repository.git` \|\n");
			} else if ($is_mercurial) {
			$uri_label = pht('Remote URI');
			$instructions = pht(
			'Enter the URI to clone this Mercurial repository from. It should '.
			'usually look like one of these examples:'.
			"\n\n".
			"\| Example Mercurial Remote URIs \|\n".
			"\| ----------------------- \|\n".
			"\| `ssh://hg@bitbucket.org/example/repository` \|\n".
			"\| `file:///local/path/to/repo` \|\n");
			} else if ($is_svn) {
			$uri_label = pht('Repository Root');
			$instructions = pht(
			'Enter the Repository Root for this Subversion repository. '.
			'You can figure this out by running `svn info` in a working copy '.
			'and looking at the value in the `Repository Root` field. It '.
			'should be a URI and will usually look like these:'.
			"\n\n".
			"\| Example Subversion Repository Root URIs \|\n".
			"\| ------------------------------ \|\n".
			"\| `http://svn.example.org/svnroot/` \|\n".
			"\| `svn+ssh://svn.example.com/svnroot/` \|\n".
			"\| `svn://svn.example.net/svnroot/` \|\n".
			"\| `file:///local/path/to/svnroot/` \|\n".
			"\n\n".
			"You MUST specify the root of the repository, not a ".
			"subdirectory. (If you want to import only part of a Subversion ".
			"repository, use the //Import Only// option at the end of this ".
			"workflow.)");
			} else {
			throw new Exception('Unsupported VCS!');
			}

			$page->addRemarkupInstructions($instructions, 'remoteURI');
			$page->getControl('remoteURI')->setLabel($uri_label);
			}

			public function validateRemoteURIPage(PHUIFormPageView $page) {
			$c_remote = $page->getControl('remoteURI');
			$v_remote = $c_remote->getValue();

			if (!strlen($v_remote)) {
			$c_remote->setError(pht('Required'));
			$page->addPageError(
			pht('You must specify a URI.'));
			} else {
			$proto = $this->getRemoteURIProtocol($v_remote);

			if ($proto === 'file') {
			if (!preg_match('@^file:///@', $v_remote)) {
			$c_remote->setError(pht('Invalid'));
			$page->addPageError(
			pht(
			"URIs using the 'file://' protocol should have three slashes ".
			"(e.g., 'file:///absolute/path/to/file'). You only have two. ".
			"Add another one."));
			}
			}

			// Catch confusion between Git/SCP-style URIs and normal URIs. See T3619
			// for discussion. This is usually a user adding "ssh://" to an implicit
			// SSH Git URI.
			if ($proto == 'ssh') {
			if (preg_match('(^[^:@]+://[^/:]+:[^\d])', $v_remote)) {
			$c_remote->setError(pht('Invalid'));
			$page->addPageError(
			pht(
			"The Remote URI is not formatted correctly. Remote URIs ".
			"with an explicit protocol should be in the form ".
			"'proto://domain/path', not 'proto://domain:/path'. ".
			"The ':/path' syntax is only valid in SCP-style URIs."));
			}
			}

			switch ($proto) {
			case 'ssh':
			case 'http':
			case 'https':
			case 'file':
			case 'git':
			case 'svn':
			case 'svn+ssh':
			break;
			default:
			$c_remote->setError(pht('Invalid'));
			$page->addPageError(
			pht(
			"The URI protocol is unrecognized. It should begin ".
			"'ssh://', 'http://', 'https://', 'file://', 'git://', ".
			"'svn://', 'svn+ssh://', or be in the form ".
			"'git@domain.com:path'."));
			break;
			}
			}

			return $c_remote->isValid();
			}


			/* -( Page: Authentication )----------------------------------------------- */


			public function buildAuthPage() {
			return id(new PHUIFormPageView())
			->setPageName(pht('Authentication'))
			->setUser($this->getRequest()->getUser())
			->setAdjustFormPageCallback(array($this, 'adjustAuthPage'))
			->addControl(
			id(new PassphraseCredentialControl())
			->setName('credential'));
			}


			public function adjustAuthPage($page) {
			$form = $page->getForm();

			if ($this->getRepository()) {
			$vcs = $this->getRepository()->getVersionControlSystem();
			} else {
			$vcs = $form->getPage('vcs')->getControl('vcs')->getValue();
			}

			$remote_uri = $form->getPage('remote-uri')
			->getControl('remoteURI')
			->getValue();
			$proto = $this->getRemoteURIProtocol($remote_uri);
			$remote_user = $this->getRemoteURIUser($remote_uri);

			$c_credential = $page->getControl('credential');
			$c_credential->setDefaultUsername($remote_user);

			if ($this->isSSHProtocol($proto)) {
			$c_credential->setLabel(pht('SSH Key'));
			$c_credential->setCredentialType(
			PassphraseCredentialTypeSSHPrivateKeyText::CREDENTIAL_TYPE);
			$provides_type = PassphraseCredentialTypeSSHPrivateKey::PROVIDES_TYPE;

			$page->addRemarkupInstructions(
			pht(
			'Choose or add the SSH credentials to use to connect to the the '.
			'repository hosted at:'.
			"\n\n".
			" lang=text\n".
			" %s",
			$remote_uri),
			'credential');
			} else if ($this->isUsernamePasswordProtocol($proto)) {
			$c_credential->setLabel(pht('Password'));
			$c_credential->setAllowNull(true);
			$c_credential->setCredentialType(
			PassphraseCredentialTypePassword::CREDENTIAL_TYPE);
			$provides_type = PassphraseCredentialTypePassword::PROVIDES_TYPE;

			$page->addRemarkupInstructions(
			pht(
			'Choose the username and password used to connect to the '.
			'repository hosted at:'.
			"\n\n".
			" lang=text\n".
			" %s".
			"\n\n".
			"If this repository does not require a username or password, ".
			"you can continue to the next step.",
			$remote_uri),
			'credential');
			} else if ($proto == 'file') {
			$c_credential->setHidden(true);
			$provides_type = null;

			$page->addRemarkupInstructions(
			pht(
			'You do not need to configure any credentials for repositories '.
			'accessed over the `file://` protocol. Continue to the next step.'),
			'credential');
			} else {
			throw new Exception('Unknown URI protocol!');
			}

			if ($provides_type) {
			$viewer = $this->getRequest()->getUser();

			$options = id(new PassphraseCredentialQuery())
			->setViewer($viewer)
			->withIsDestroyed(false)
			->withProvidesTypes(array($provides_type))
			->execute();

			$c_credential->setOptions($options);
			}

			}

			public function validateAuthPage(PHUIFormPageView $page) {
			$form = $page->getForm();
			$remote_uri = $form->getPage('remote')->getControl('remoteURI')->getValue();
			$proto = $this->getRemoteURIProtocol($remote_uri);

			$c_credential = $page->getControl('credential');
			$v_credential = $c_credential->getValue();

			// NOTE: We're using the omnipotent user here because the viewer might be
			// editing a repository they're allowed to edit which uses a credential they
			// are not allowed to see. This is fine, as long as they don't change it.
			$credential = id(new PassphraseCredentialQuery())
			->setViewer(PhabricatorUser::getOmnipotentUser())
			->withPHIDs(array($v_credential))
			->executeOne();

			if ($this->isSSHProtocol($proto)) {
			if (!$credential) {
			$c_credential->setError(pht('Required'));
			$page->addPageError(
			pht('You must choose an SSH credential to connect over SSH.'));
			}

			$ssh_type = PassphraseCredentialTypeSSHPrivateKey::PROVIDES_TYPE;
			if ($credential->getProvidesType() !== $ssh_type) {
			$c_credential->setError(pht('Invalid'));
			$page->addPageError(
			pht(
			'You must choose an SSH credential, not some other type '.
			'of credential.'));
			}

			} else if ($this->isUsernamePasswordProtocol($proto)) {
			if ($credential) {
			$password_type = PassphraseCredentialTypePassword::PROVIDES_TYPE;
			if ($credential->getProvidesType() !== $password_type) {
			$c_credential->setError(pht('Invalid'));
			$page->addPageError(
			pht(
			'You must choose a username/password credential, not some other '.
			'type of credential.'));
			}
			}

			return $c_credential->isValid();
			} else {
			return true;
			}
			}


			/* -( Page: Policy )------------------------------------------------------- */


			private function buildPolicyPage() {
			$viewer = $this->getRequest()->getUser();
			if ($this->getRepository()) {
			$repository = $this->getRepository();
			} else {
			$repository = PhabricatorRepository::initializeNewRepository($viewer);
			}

			$policies = id(new PhabricatorPolicyQuery())
			->setViewer($viewer)
			->setObject($repository)
			->execute();

			$view_policy = id(new AphrontFormPolicyControl())
			->setUser($viewer)
			->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
			->setPolicyObject($repository)
			->setPolicies($policies)
			->setName('viewPolicy');

			$edit_policy = id(new AphrontFormPolicyControl())
			->setUser($viewer)
			->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
			->setPolicyObject($repository)
			->setPolicies($policies)
			->setName('editPolicy');

			$push_policy = id(new AphrontFormPolicyControl())
			->setUser($viewer)
			->setCapability(DiffusionCapabilityPush::CAPABILITY)
			->setPolicyObject($repository)
			->setPolicies($policies)
			->setName('pushPolicy');

			return id(new PHUIFormPageView())
			->setPageName(pht('Policies'))
			->setValidateFormPageCallback(array($this, 'validatePolicyPage'))
			->setAdjustFormPageCallback(array($this, 'adjustPolicyPage'))
			->setUser($viewer)
			->addRemarkupInstructions(
			pht(
			'Select access policies for this repository.'))
			->addControl($view_policy)
			->addControl($edit_policy)
			->addControl($push_policy);
			}

			public function adjustPolicyPage(PHUIFormPageView $page) {
			if ($this->getRepository()) {
			$repository = $this->getRepository();
			$show_push = $repository->isHosted();
			} else {
			$show_push = ($this->edit == 'create');
			}

			if (!$show_push) {
			$c_push = $page->getControl('pushPolicy');
			$c_push->setHidden(true);
			}
			}

			public function validatePolicyPage(PHUIFormPageView $page) {
			$form = $page->getForm();
			$viewer = $this->getRequest()->getUser();

			$c_view = $page->getControl('viewPolicy');
			$c_edit = $page->getControl('editPolicy');
			$c_push = $page->getControl('pushPolicy');
			$v_view = $c_view->getValue();
			$v_edit = $c_edit->getValue();
			$v_push = $c_push->getValue();

			if ($this->getRepository()) {
			$repository = $this->getRepository();
			} else {
			$repository = PhabricatorRepository::initializeNewRepository($viewer);
			}

			$proxy = clone $repository;
			$proxy->setViewPolicy($v_view);
			$proxy->setEditPolicy($v_edit);

			$can_view = PhabricatorPolicyFilter::hasCapability(
			$viewer,
			$proxy,
			PhabricatorPolicyCapability::CAN_VIEW);

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

			if (!$can_view) {
			$c_view->setError(pht('Invalid'));
			$page->addPageError(
			pht(
			'You can not use the selected policy, because you would be unable '.
			'to see the repository.'));
			}

			if (!$can_edit) {
			$c_edit->setError(pht('Invalid'));
			$page->addPageError(
			pht(
			'You can not use the selected edit policy, because you would be '.
			'unable to edit the repository.'));
			}

			return $c_view->isValid() &&
			$c_edit->isValid();
			}

			/* -( Page: Done )--------------------------------------------------------- */


			private function buildDonePage() {

			$is_create = ($this->edit == 'create');
			if ($is_create) {
			$now_label = pht('Create Repository Now');
			$now_caption = pht(
			'Create the repository right away. This will create the repository '.
			'using default settings.');

			$wait_label = pht('Configure More Options First');
			$wait_caption = pht(
			'Configure more options before creating the repository. '.
			'This will let you fine-tune settings. You can create the repository '.
			'whenever you are ready.');
			} else {
			$now_label = pht('Start Import Now');
			$now_caption = pht(
			'Start importing the repository right away. This will import '.
			'the entire repository using default settings.');

			$wait_label = pht('Configure More Options First');
			$wait_caption = pht(
			'Configure more options before beginning the repository '.
			'import. This will let you fine-tune settings. You can '.
			'start the import whenever you are ready.');
			}

			return id(new PHUIFormPageView())
			->setPageName(pht('Repository Ready!'))
			->setValidateFormPageCallback(array($this, 'validateDonePage'))
			->setUser($this->getRequest()->getUser())
			->addControl(
			id(new AphrontFormRadioButtonControl())
			->setName('activate')
			->setLabel(pht('Start Now'))
			->addButton(
			'start',
			$now_label,
			$now_caption)
			->addButton(
			'wait',
			$wait_label,
			$wait_caption));
			}

			public function validateDonePage(PHUIFormPageView $page) {
			$c_activate = $page->getControl('activate');
			$v_activate = $c_activate->getValue();

			if ($v_activate != 'start' && $v_activate != 'wait') {
			$c_activate->setError(pht('Required'));
			$page->addPageError(
			pht('Make a choice about repository activation.'));
			}

			return $c_activate->isValid();
			}


			/* -( Internal )----------------------------------------------------------- */


			private function getRemoteURIProtocol($raw_uri) {
			$uri = new PhutilURI($raw_uri);
			if ($uri->getProtocol()) {
			return strtolower($uri->getProtocol());
			}

			$git_uri = new PhutilGitURI($raw_uri);
			if (strlen($git_uri->getDomain()) && strlen($git_uri->getPath())) {
			return 'ssh';
			}

			return null;
			}

			private function getRemoteURIUser($raw_uri) {
			$uri = new PhutilURI($raw_uri);
			if ($uri->getUser()) {
			return $uri->getUser();
			}

			$git_uri = new PhutilGitURI($raw_uri);
			if (strlen($git_uri->getDomain()) && strlen($git_uri->getPath())) {
			return $git_uri->getUser();
			}

			return null;
			}

			private function isSSHProtocol($proto) {
			return ($proto == 'git' \|\| $proto == 'ssh' \|\| $proto == 'svn+ssh');
			}

			private function isUsernamePasswordProtocol($proto) {
			return ($proto == 'http' \|\| $proto == 'https' \|\| $proto == 'svn');
			}

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

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


			}

phab/src/applications/diffusion/controller/DiffusionRepositoryCreateController.php0a62f13464b8stable

DiffusionRepositoryCreateController.phpView Options

phab/src/applications/diffusion/controller/DiffusionRepositoryCreateController.php
0a62f13464b8stable

DiffusionRepositoryCreateController.php
View Options