DiffusionRepositoryCreateController.php
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Jun 2, 21:37

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


	}

DiffusionRepositoryCreateController.phpNo OneTemporaryActions

File Metadata

DiffusionRepositoryCreateController.phpView Options

Event Timeline

DiffusionRepositoryCreateController.php
No OneTemporary
Actions

DiffusionRepositoryCreateController.php
View Options