SONAR-17587 Allow project onboarding when multiple Github integrations are configured

server/sonar-web/src/main/js/api/mocks/AlmIntegrationsServiceMock.ts

 import { GitlabProject } from '../../types/alm-integration';
 import {
   checkPersonalAccessTokenIsValid,
+  getGithubClientId,
+  getGithubOrganizations,
   getGitlabProjects,
   setAlmPersonalAccessToken,
 } from '../alm-integrations';
   defaultAlmInstancePATMap: { [key: string]: boolean } = {
     'conf-final-1': false,
     'conf-final-2': true,
+    'conf-github-1': false,
+    'conf-github-2': true,
   };
 
   defaultGitlabProjects: GitlabProject[] = [
     mockGitlabProject({ name: 'Gitlab project 3', id: '3' }),
   ];
 
+  defaultOrganizations = {
+    paging: {
+      pageIndex: 1,
+      pageSize: 100,
+      total: 1,
+    },
+    organizations: [
+      {
+        key: 'org-1',
+        name: 'org-1',
+      },
+    ],
+  };
+
   constructor() {
     this.almInstancePATMap = cloneDeep(this.defaultAlmInstancePATMap);
     this.gitlabProjects = cloneDeep(this.defaultGitlabProjects);
     );
     (setAlmPersonalAccessToken as jest.Mock).mockImplementation(this.setAlmPersonalAccessToken);
     (getGitlabProjects as jest.Mock).mockImplementation(this.getGitlabProjects);
+    (getGithubClientId as jest.Mock).mockImplementation(this.getGithubClientId);
+    (getGithubOrganizations as jest.Mock).mockImplementation(this.getGithubOrganizations);
   }
 
   checkPersonalAccessTokenIsValid = (conf: string) => {
     this.gitlabProjects = gitlabProjects;
   }
 
+  getGithubClientId = () => {
+    return Promise.resolve({ clientId: 'clientId' });
+  };
+
+  getGithubOrganizations = () => {
+    return Promise.resolve(this.defaultOrganizations);
+  };
+
   reset = () => {
     this.almInstancePATMap = cloneDeep(this.defaultAlmInstancePATMap);
     this.gitlabProjects = cloneDeep(this.defaultGitlabProjects);

server/sonar-web/src/main/js/api/mocks/AlmSettingsServiceMock.ts

   defaultSetting: AlmSettingsInstance[] = [
     mockAlmSettingsInstance({ key: 'conf-final-1', alm: AlmKeys.GitLab }),
     mockAlmSettingsInstance({ key: 'conf-final-2', alm: AlmKeys.GitLab }),
+    mockAlmSettingsInstance({ key: 'conf-github-1', alm: AlmKeys.GitHub, url: 'url' }),
+    mockAlmSettingsInstance({ key: 'conf-github-2', alm: AlmKeys.GitHub, url: 'url' }),
   ];
 
   constructor() {

server/sonar-web/src/main/js/apps/create/project/AzureProjectCreate.tsx

     }
   };
 
-  onChangeConfig = (instance: AlmSettingsInstance) => {
+  onSelectedAlmInstanceChange = (instance: AlmSettingsInstance) => {
     this.setState({ selectedAlmInstance: instance }, () => this.fetchData());
   };
 
         showPersonalAccessTokenForm={!patIsValid || Boolean(location.query.resetPat)}
         submittingToken={submittingToken}
         tokenValidationFailed={tokenValidationFailed}
-        onChangeConfig={this.onChangeConfig}
+        onSelectedAlmInstanceChange={this.onSelectedAlmInstanceChange}
       />
     );
   }

server/sonar-web/src/main/js/apps/create/project/AzureProjectCreateRenderer.tsx

   showPersonalAccessTokenForm?: boolean;
   submittingToken?: boolean;
   tokenValidationFailed: boolean;
-  onChangeConfig: (instance: AlmSettingsInstance) => void;
+  onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
 }
 
 export default function AzureProjectCreateRenderer(props: AzureProjectCreateRendererProps) {
       <AlmSettingsInstanceDropdown
         almInstances={almInstances}
         selectedAlmInstance={selectedAlmInstance}
-        onChangeConfig={props.onChangeConfig}
+        onChangeConfig={props.onSelectedAlmInstanceChange}
       />
 
       {loading && <i className="spinner" />}

server/sonar-web/src/main/js/apps/create/project/CreateProjectPage.tsx

 import './style.css';
 import { CreateProjectModes } from './types';
 
-interface Props extends WithAvailableFeaturesProps {
+export interface CreateProjectPageProps extends WithAvailableFeaturesProps {
   appState: AppState;
   location: Location;
   router: Router;
   [AlmKeys.GitLab]: CreateProjectModes.GitLab,
 };
 
-export class CreateProjectPage extends React.PureComponent<Props, State> {
+export class CreateProjectPage extends React.PureComponent<CreateProjectPageProps, State> {
   mounted = false;
   state: State = {
     azureSettings: [],
             location={location}
             onProjectCreate={this.handleProjectCreate}
             router={router}
-            settings={githubSettings}
+            almInstances={githubSettings}
           />
         );
       }

server/sonar-web/src/main/js/apps/create/project/GitHubProjectCreate.tsx

   canAdmin: boolean;
   loadingBindings: boolean;
   onProjectCreate: (projectKey: string) => void;
-  settings: AlmSettingsInstance[];
+  almInstances: AlmSettingsInstance[];
   location: Location;
   router: Router;
 }
   searchQuery: string;
   selectedOrganization?: GithubOrganization;
   selectedRepository?: GithubRepository;
-  settings?: AlmSettingsInstance;
+  selectedAlmInstance?: AlmSettingsInstance;
 }
 
 const REPOSITORY_PAGE_SIZE = 30;
       repositories: [],
       repositoryPaging: { pageSize: REPOSITORY_PAGE_SIZE, total: 0, pageIndex: 1 },
       searchQuery: '',
-      settings: props.settings[0],
+      selectedAlmInstance: this.getInitialSelectedAlmInstance(),
     };
 
     this.triggerSearch = debounce(this.triggerSearch, 250);
 
   componentDidMount() {
     this.mounted = true;
-
     this.initialize();
   }
 
   componentDidUpdate(prevProps: Props) {
-    if (prevProps.settings.length === 0 && this.props.settings.length > 0) {
-      this.setState({ settings: this.props.settings[0] }, () => this.initialize());
+    if (prevProps.almInstances.length === 0 && this.props.almInstances.length > 0) {
+      this.setState({ selectedAlmInstance: this.getInitialSelectedAlmInstance() }, () =>
+        this.initialize()
+      );
     }
   }
 
     this.mounted = false;
   }
 
+  getInitialSelectedAlmInstance() {
+    const {
+      location: {
+        query: { almInstance: selectedAlmInstanceKey },
+      },
+      almInstances,
+    } = this.props;
+    const selectedAlmInstance = almInstances.find(
+      (instance) => instance.key === selectedAlmInstanceKey
+    );
+    if (selectedAlmInstance) {
+      return selectedAlmInstance;
+    }
+    return this.props.almInstances.length > 1 ? undefined : this.props.almInstances[0];
+  }
+
   async initialize() {
     const { location, router } = this.props;
-    const { settings } = this.state;
-
-    if (!settings || !settings.url) {
+    const { selectedAlmInstance } = this.state;
+    if (!selectedAlmInstance || !selectedAlmInstance.url) {
       this.setState({ error: true });
       return;
-    } else {
-      this.setState({ error: false });
     }
+    this.setState({ error: false });
 
     const code = location.query?.code;
-
     try {
       if (!code) {
-        await this.redirectToGithub(settings);
+        await this.redirectToGithub(selectedAlmInstance);
       } else {
         delete location.query.code;
         router.replace(location);
-        await this.fetchOrganizations(settings, code);
+        await this.fetchOrganizations(selectedAlmInstance, code);
       }
     } catch (e) {
       if (this.mounted) {
     }
   }
 
-  async redirectToGithub(settings: AlmSettingsInstance) {
-    if (!settings.url) {
+  async redirectToGithub(selectedAlmInstance: AlmSettingsInstance) {
+    if (!selectedAlmInstance.url) {
       return;
     }
 
-    const { clientId } = await getGithubClientId(settings.key);
+    const { clientId } = await getGithubClientId(selectedAlmInstance.key);
 
     if (!clientId) {
       this.setState({ error: true });
       return;
     }
-
     const queryParams = [
       { param: 'client_id', value: clientId },
-      { param: 'redirect_uri', value: `${getHostUrl()}/projects/create?mode=${AlmKeys.GitHub}` },
+      {
+        param: 'redirect_uri',
+        value: encodeURIComponent(
+          `${getHostUrl()}/projects/create?mode=${AlmKeys.GitHub}&almInstance=${
+            selectedAlmInstance.key
+          }`
+        ),
+      },
     ]
       .map(({ param, value }) => `${param}=${value}`)
       .join('&');
 
     let instanceRootUrl;
     // Strip the api section from the url, since we're not hitting the api here.
-    if (settings.url.includes('/api/v3')) {
+    if (selectedAlmInstance.url.includes('/api/v3')) {
       // GitHub Enterprise
-      instanceRootUrl = settings.url.replace('/api/v3', '');
+      instanceRootUrl = selectedAlmInstance.url.replace('/api/v3', '');
     } else {
       // github.com
-      instanceRootUrl = settings.url.replace('api.', '');
+      instanceRootUrl = selectedAlmInstance.url.replace('api.', '');
     }
 
     // strip the trailing /
     window.location.replace(`${instanceRootUrl}/login/oauth/authorize?${queryParams}`);
   }
 
-  async fetchOrganizations(settings: AlmSettingsInstance, token: string) {
-    const { organizations } = await getGithubOrganizations(settings.key, token);
+  async fetchOrganizations(selectedAlmInstance: AlmSettingsInstance, token: string) {
+    const { organizations } = await getGithubOrganizations(selectedAlmInstance.key, token);
 
     if (this.mounted) {
       this.setState({ loadingOrganizations: false, organizations });
 
   async fetchRepositories(params: { organizationKey: string; page?: number; query?: string }) {
     const { organizationKey, page = 1, query } = params;
-    const { settings } = this.state;
+    const { selectedAlmInstance } = this.state;
 
-    if (!settings) {
+    if (!selectedAlmInstance) {
       this.setState({ error: true });
       return;
     }
 
     try {
       const data = await getGithubRepositories({
-        almSetting: settings.key,
+        almSetting: selectedAlmInstance.key,
         organization: organizationKey,
         pageSize: REPOSITORY_PAGE_SIZE,
         page,
   };
 
   handleImportRepository = async () => {
-    const { selectedOrganization, selectedRepository, settings } = this.state;
+    const { selectedOrganization, selectedRepository, selectedAlmInstance } = this.state;
 
-    if (settings && selectedOrganization && selectedRepository) {
+    if (selectedAlmInstance && selectedOrganization && selectedRepository) {
       this.setState({ importing: true });
 
       try {
         const { project } = await importGithubRepository(
-          settings.key,
+          selectedAlmInstance.key,
           selectedOrganization.key,
           selectedRepository.key
         );
     }
   };
 
+  onSelectedAlmInstanceChange = (instance: AlmSettingsInstance) => {
+    this.setState({ selectedAlmInstance: instance }, () => this.initialize());
+  };
+
   render() {
-    const { canAdmin, loadingBindings } = this.props;
+    const { canAdmin, loadingBindings, almInstances } = this.props;
     const {
       error,
       importing,
       searchQuery,
       selectedOrganization,
       selectedRepository,
+      selectedAlmInstance,
     } = this.state;
 
     return (
         repositories={repositories}
         selectedOrganization={selectedOrganization}
         selectedRepository={selectedRepository}
+        almInstances={almInstances}
+        selectedAlmInstance={selectedAlmInstance}
+        onSelectedAlmInstanceChange={this.onSelectedAlmInstanceChange}
       />
     );
   }

server/sonar-web/src/main/js/apps/create/project/GitHubProjectCreateRenderer.tsx

 import { getBaseUrl } from '../../../helpers/system';
 import { getProjectUrl } from '../../../helpers/urls';
 import { GithubOrganization, GithubRepository } from '../../../types/alm-integration';
+import { AlmSettingsInstance } from '../../../types/alm-settings';
 import { ComponentQualifier } from '../../../types/component';
 import { Paging } from '../../../types/types';
+import AlmSettingsInstanceDropdown from './AlmSettingsInstanceDropdown';
 import CreateProjectPageHeader from './CreateProjectPageHeader';
 
 export interface GitHubProjectCreateRendererProps {
   searchQuery: string;
   selectedOrganization?: GithubOrganization;
   selectedRepository?: GithubRepository;
+  almInstances: AlmSettingsInstance[];
+  selectedAlmInstance?: AlmSettingsInstance;
+  onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
 }
 
 function orgToOption({ key, name }: GithubOrganization) {
     organizations,
     selectedOrganization,
     selectedRepository,
+    almInstances,
+    selectedAlmInstance,
   } = props;
 
   if (loadingBindings) {
         }
       />
 
-      {error ? (
+      <AlmSettingsInstanceDropdown
+        almInstances={almInstances}
+        selectedAlmInstance={selectedAlmInstance}
+        onChangeConfig={props.onSelectedAlmInstanceChange}
+      />
+
+      {error && selectedAlmInstance && (
         <div className="display-flex-justify-center">
           <div className="boxed-group padded width-50 huge-spacer-top">
             <h2 className="big-spacer-bottom">
             </Alert>
           </div>
         </div>
-      ) : (
+      )}
+
+      {!error && (
         <DeferredSpinner loading={loadingOrganizations}>
           <div className="form-field">
             <label>{translate('onboarding.create_project.github.choose_organization')}</label>

server/sonar-web/src/main/js/apps/create/project/GitlabProjectCreate.tsx

     await this.fetchInitialData();
   };
 
-  onChangeConfig = (instance: AlmSettingsInstance) => {
+  onSelectedAlmInstanceChange = (instance: AlmSettingsInstance) => {
     this.setState({
       selectedAlmInstance: instance,
       showPersonalAccessTokenForm: true,
         showPersonalAccessTokenForm={
           showPersonalAccessTokenForm || Boolean(location.query.resetPat)
         }
-        onChangeConfig={this.onChangeConfig}
+        onSelectedAlmInstanceChange={this.onSelectedAlmInstanceChange}
       />
     );
   }

server/sonar-web/src/main/js/apps/create/project/GitlabProjectCreateRenderer.tsx

   almInstances?: AlmSettingsInstance[];
   selectedAlmInstance?: AlmSettingsInstance;
   showPersonalAccessTokenForm?: boolean;
-  onChangeConfig: (instance: AlmSettingsInstance) => void;
+  onSelectedAlmInstanceChange: (instance: AlmSettingsInstance) => void;
 }
 
 export default function GitlabProjectCreateRenderer(props: GitlabProjectCreateRendererProps) {
       <AlmSettingsInstanceDropdown
         almInstances={almInstances}
         selectedAlmInstance={selectedAlmInstance}
-        onChangeConfig={props.onChangeConfig}
+        onChangeConfig={props.onSelectedAlmInstanceChange}
       />
 
       {loading && <i className="spinner" />}

server/sonar-web/src/main/js/apps/create/project/__tests__/AzureProjectCreateRenderer-test.tsx

       ]}
       showPersonalAccessTokenForm={false}
       submittingToken={false}
-      onChangeConfig={jest.fn()}
+      onSelectedAlmInstanceChange={jest.fn()}
       {...overrides}
     />
   );

server/sonar-web/src/main/js/apps/create/project/__tests__/CreateProject-it.tsx

 import AlmIntegrationsServiceMock from '../../../../api/mocks/AlmIntegrationsServiceMock';
 import AlmSettingsServiceMock from '../../../../api/mocks/AlmSettingsServiceMock';
 import { renderApp } from '../../../../helpers/testReactTestingUtils';
-import CreateProjectPage from '../CreateProjectPage';
+import CreateProjectPage, { CreateProjectPageProps } from '../CreateProjectPage';
 
 jest.mock('../../../../api/alm-integrations');
 jest.mock('../../../../api/alm-settings');
 
+const original = window.location;
+
 let almIntegrationHandler: AlmIntegrationsServiceMock;
 let almSettingsHandler: AlmSettingsServiceMock;
 
 const ui = {
   gitlabCreateProjectButton: byText('onboarding.create_project.select_method.gitlab'),
+  githubCreateProjectButton: byText('onboarding.create_project.select_method.github'),
   personalAccessTokenInput: byRole('textbox', {
     name: 'onboarding.create_project.enter_pat field_required',
   }),
 };
 
 beforeAll(() => {
+  Object.defineProperty(window, 'location', {
+    configurable: true,
+    value: { replace: jest.fn() },
+  });
   almIntegrationHandler = new AlmIntegrationsServiceMock();
   almSettingsHandler = new AlmSettingsServiceMock();
 });
   almSettingsHandler.reset();
 });
 
+afterAll(() => {
+  Object.defineProperty(window, 'location', { configurable: true, value: original });
+});
+
 describe('Gitlab onboarding page', () => {
   it('should ask for PAT when it is not set yet and show the import project feature afterwards', async () => {
     const user = userEvent.setup();
   });
 });
 
-function renderCreateProject() {
-  renderApp('project/create', <CreateProjectPage />);
+describe('Github onboarding page', () => {
+  it('should redirect to github authorization page when not already authorized', async () => {
+    const user = userEvent.setup();
+    renderCreateProject();
+    expect(ui.githubCreateProjectButton.get()).toBeInTheDocument();
+
+    await user.click(ui.githubCreateProjectButton.get());
+    expect(screen.getByText('onboarding.create_project.github.title')).toBeInTheDocument();
+    expect(screen.getByText('alm.configuration.selector.placeholder')).toBeInTheDocument();
+    expect(screen.getByText('alm.configuration.selector.label')).toBeInTheDocument();
+
+    await selectEvent.select(screen.getByLabelText('alm.configuration.selector.label'), [
+      /conf-github-1/,
+    ]);
+
+    expect(window.location.replace).toHaveBeenCalled();
+    expect(
+      screen.getByText('onboarding.create_project.github.choose_organization')
+    ).toBeInTheDocument();
+  });
+});
+
+function renderCreateProject(props: Partial<CreateProjectPageProps> = {}) {
+  renderApp('project/create', <CreateProjectPage {...props} />);
 }

server/sonar-web/src/main/js/apps/create/project/__tests__/GitHubProjectCreate-test.tsx

 });
 
 it('should handle no settings', async () => {
-  const wrapper = shallowRender({ settings: [] });
+  const wrapper = shallowRender({ almInstances: [] });
   await waitAndUpdate(wrapper);
   expect(wrapper.state().error).toBe(true);
 });
 
 it('should redirect when no code - github.com', async () => {
   const wrapper = shallowRender({
-    settings: [mockAlmSettingsInstance({ key: 'a', url: 'api.github.com' })],
+    almInstances: [mockAlmSettingsInstance({ key: 'a', url: 'api.github.com' })],
   });
   await waitAndUpdate(wrapper);
 
   expect(getGithubClientId).toHaveBeenCalled();
   expect(window.location.replace).toHaveBeenCalledWith(
-    'github.com/login/oauth/authorize?client_id=client-id-124&redirect_uri=http://localhost/projects/create?mode=github'
+    'github.com/login/oauth/authorize?client_id=client-id-124&redirect_uri=http%3A%2F%2Flocalhost%2Fprojects%2Fcreate%3Fmode%3Dgithub%26almInstance%3Da'
   );
 });
 
       location={mockLocation()}
       onProjectCreate={jest.fn()}
       router={mockRouter()}
-      settings={[mockAlmSettingsInstance({ key: 'a', url: 'geh.company.com/api/v3' })]}
+      almInstances={[mockAlmSettingsInstance({ key: 'a', url: 'geh.company.com/api/v3' })]}
       {...props}
     />
   );

server/sonar-web/src/main/js/apps/create/project/__tests__/GitHubProjectCreateRenderer-test.tsx

 import SearchBox from '../../../../components/controls/SearchBox';
 import Select from '../../../../components/controls/Select';
 import { mockGitHubRepository } from '../../../../helpers/mocks/alm-integrations';
+import { mockAlmSettingsInstance } from '../../../../helpers/mocks/alm-settings';
 import { GithubOrganization } from '../../../../types/alm-integration';
 import GitHubProjectCreateRenderer, {
   GitHubProjectCreateRendererProps,
       onSearch={jest.fn()}
       onSelectOrganization={jest.fn()}
       onSelectRepository={jest.fn()}
+      onSelectedAlmInstanceChange={jest.fn()}
+      almInstances={[mockAlmSettingsInstance(), mockAlmSettingsInstance()]}
       organizations={[]}
       repositoryPaging={{ total: 0, pageIndex: 1, pageSize: 30 }}
       searchQuery=""

server/sonar-web/src/main/js/apps/create/project/__tests__/GitlabProjectCreateRenderer-test.tsx

       onLoadMore={jest.fn()}
       onPersonalAccessTokenCreated={jest.fn()}
       onSearch={jest.fn()}
-      onChangeConfig={jest.fn()}
+      onSelectedAlmInstanceChange={jest.fn()}
       projects={undefined}
       projectsPaging={{ pageIndex: 1, pageSize: 30, total: 0 }}
       searching={false}

server/sonar-web/src/main/js/apps/create/project/__tests__/__snapshots__/AzureProjectCreate-test.tsx.snap

   importing={false}
   loading={true}
   loadingRepositories={Object {}}
-  onChangeConfig={[Function]}
   onImportRepository={[Function]}
   onOpenProject={[Function]}
   onPersonalAccessTokenCreate={[Function]}
   onSearch={[Function]}
   onSelectRepository={[Function]}
+  onSelectedAlmInstanceChange={[Function]}
   repositories={Object {}}
   selectedAlmInstance={
     Object {

server/sonar-web/src/main/js/apps/create/project/__tests__/__snapshots__/CreateProjectModeSelection-test.tsx.snap

       className="display-flex-column"
     >
       <button
-        className="button button-huge display-flex-column create-project-mode-type-alm disabled big-spacer-right"
-        disabled={true}
+        className="button button-huge display-flex-column create-project-mode-type-alm big-spacer-right"
+        disabled={false}
         onClick={[Function]}
         type="button"
       >
         >
           onboarding.create_project.select_method.github
         </div>
-        <p
-          className="text-muted small spacer-top"
-          style={
-            Object {
-              "lineHeight": 1.5,
-            }
-          }
-        >
-          onboarding.create_project.too_many_alm_instances_X.alm.github
-        </p>
       </button>
     </div>
     <div
       className="display-flex-column"
     >
       <button
-        className="button button-huge display-flex-column create-project-mode-type-alm disabled big-spacer-right"
-        disabled={true}
+        className="button button-huge display-flex-column create-project-mode-type-alm big-spacer-right"
+        disabled={false}
         onClick={[Function]}
         type="button"
       >
         >
           onboarding.create_project.select_method.github
         </div>
-        <p
-          className="text-muted small spacer-top"
-          style={
-            Object {
-              "lineHeight": 1.5,
-            }
-          }
-        >
-          onboarding.create_project.too_many_alm_instances_X.alm.github
-        </p>
       </button>
     </div>
     <div
       className="display-flex-column"
     >
       <button
-        className="button button-huge display-flex-column create-project-mode-type-alm disabled big-spacer-right"
-        disabled={true}
+        className="button button-huge display-flex-column create-project-mode-type-alm big-spacer-right"
+        disabled={false}
         onClick={[Function]}
         type="button"
       >
         >
           onboarding.create_project.select_method.github
         </div>
-        <p
-          className="text-muted small spacer-top"
-          style={
-            Object {
-              "lineHeight": 1.5,
-            }
-          }
-        >
-          onboarding.create_project.too_many_alm_instances_X.alm.github
-        </p>
       </button>
     </div>
     <div

server/sonar-web/src/main/js/apps/create/project/__tests__/__snapshots__/CreateProjectPage-test.tsx.snap

     id="create-project"
   >
     <GitHubProjectCreate
+      almInstances={Array []}
       canAdmin={false}
       loadingBindings={true}
       location={
           "setRouteLeaveHook": [MockFunction],
         }
       }
-      settings={Array []}
     />
   </div>
 </Fragment>

server/sonar-web/src/main/js/apps/create/project/__tests__/__snapshots__/GitHubProjectCreateRenderer-test.tsx.snap

       </span>
     }
   />
+  <AlmSettingsInstanceDropdown
+    almInstances={
+      Array [
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+      ]
+    }
+    onChangeConfig={[MockFunction]}
+  />
   <DeferredSpinner
     loading={false}
   >
       </span>
     }
   />
-  <div
-    className="display-flex-justify-center"
-  >
-    <div
-      className="boxed-group padded width-50 huge-spacer-top"
-    >
-      <h2
-        className="big-spacer-bottom"
-      >
-        onboarding.create_project.github.warning.title
-      </h2>
-      <Alert
-        variant="warning"
-      >
-        onboarding.create_project.github.warning.message
-      </Alert>
-    </div>
-  </div>
+  <AlmSettingsInstanceDropdown
+    almInstances={
+      Array [
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+      ]
+    }
+    onChangeConfig={[MockFunction]}
+  />
 </div>
 `;
 
       </span>
     }
   />
-  <div
-    className="display-flex-justify-center"
-  >
-    <div
-      className="boxed-group padded width-50 huge-spacer-top"
-    >
-      <h2
-        className="big-spacer-bottom"
-      >
-        onboarding.create_project.github.warning.title
-      </h2>
-      <Alert
-        variant="warning"
-      >
-        <FormattedMessage
-          defaultMessage="onboarding.create_project.github.warning.message_admin"
-          id="onboarding.create_project.github.warning.message_admin"
-          values={
-            Object {
-              "link": <ForwardRef(Link)
-                to="/admin/settings?category=almintegration"
-              >
-                onboarding.create_project.github.warning.message_admin.link
-              </ForwardRef(Link)>,
-            }
-          }
-        />
-      </Alert>
-    </div>
-  </div>
+  <AlmSettingsInstanceDropdown
+    almInstances={
+      Array [
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+      ]
+    }
+    onChangeConfig={[MockFunction]}
+  />
 </div>
 `;
 
       </span>
     }
   />
+  <AlmSettingsInstanceDropdown
+    almInstances={
+      Array [
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+      ]
+    }
+    onChangeConfig={[MockFunction]}
+  />
   <DeferredSpinner
     loading={false}
   >
       </span>
     }
   />
+  <AlmSettingsInstanceDropdown
+    almInstances={
+      Array [
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+      ]
+    }
+    onChangeConfig={[MockFunction]}
+  />
   <DeferredSpinner
     loading={false}
   >
       </span>
     }
   />
+  <AlmSettingsInstanceDropdown
+    almInstances={
+      Array [
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+        Object {
+          "alm": "github",
+          "key": "key",
+        },
+      ]
+    }
+    onChangeConfig={[MockFunction]}
+  />
   <DeferredSpinner
     loading={false}
   >

server/sonar-web/src/main/js/apps/create/project/__tests__/__snapshots__/GitlabProjectCreate-test.tsx.snap

   canAdmin={false}
   loading={false}
   loadingMore={false}
-  onChangeConfig={[Function]}
   onImport={[Function]}
   onLoadMore={[Function]}
   onPersonalAccessTokenCreated={[Function]}
   onSearch={[Function]}
+  onSelectedAlmInstanceChange={[Function]}
   projectsPaging={
     Object {
       "pageIndex": 1,

server/sonar-web/src/main/js/apps/create/project/constants.ts

 
 export const DEFAULT_BBS_PAGE_SIZE = 25;
 
-export const ALLOWED_MULTIPLE_CONFIGS = [AlmKeys.GitLab, AlmKeys.Azure];
+export const ALLOWED_MULTIPLE_CONFIGS = [AlmKeys.GitLab, AlmKeys.Azure, AlmKeys.GitHub];

server/sonar-web/src/main/js/apps/projects/components/__tests__/ProjectCreationMenu-test.tsx

 
   wrapper = shallowRender();
   await waitAndUpdate(wrapper);
-  expect(wrapper.state().boundAlms).toEqual([AlmKeys.Azure, AlmKeys.GitLab]);
+  expect(wrapper.state().boundAlms).toEqual([AlmKeys.Azure, AlmKeys.GitHub, AlmKeys.GitLab]);
 });
 
 function shallowRender(overrides: Partial<ProjectCreationMenu['props']> = {}) {

server/sonar-web/src/main/js/components/devops-platform/AlmSettingsInstanceSelector.tsx

  */
 import * as React from 'react';
 import { components, OptionProps, SingleValueProps } from 'react-select';
+import { translate } from '../../helpers/l10n';
 import { AlmSettingsInstance } from '../../types/alm-settings';
 import Select from '../controls/Select';
 
         Option: optionRenderer,
         SingleValue: singleValueRenderer,
       }}
+      placeholder={translate('alm.configuration.selector.placeholder')}
       getOptionValue={(opt) => opt.key}
       value={instances.find((inst) => inst.key === initialValue)}
     />

sonar-core/src/main/resources/org/sonar/l10n/core.properties

 alm.github.short=GitHub
 alm.gitlab=GitLab
 alm.gitlab.short=GitLab
-alm.configuration.selector.label=What DevOps platform do you want to import project from?
+alm.configuration.selector.label=What DevOps platform configuration do you want to import projects from?
+alm.configuration.selector.placeholder=Select a configuration
 
 #------------------------------------------------------------------------------
 #
 onboarding.create_project.bitbucketcloud.title=Which Bitbucket Cloud repository do you want to set up?
 onboarding.create_project.bitbucketcloud.no_projects=No projects could be fetched from Bitbucket. Contact your system administrator, or {link}.
 onboarding.create_project.bitbucketcloud.link=See on Bitbucket
-onboarding.create_project.github.title=Which GitHub repository do you want to set up?
+onboarding.create_project.github.title=Github project onboarding
 onboarding.create_project.github.choose_organization=Choose organization
 onboarding.create_project.github.warning.title=Could not connect to GitHub
 onboarding.create_project.github.warning.message=Please contact an administrator to configure GitHub integration.