/*---------------------------------------------------------------------------------------------

* Copyright (c) Microsoft Corporation. All rights reserved.

* Licensed under the MIT License. See License.txt in the project root for license information.

*--------------------------------------------------------------------------------------------*/

import * as nodePath from 'path';

import { bulkhead } from 'cockatiel';

import * as vscode from 'vscode';

import { OctokitCommon } from './common';

import { ConflictModel } from './conflictGuide';

import { ConflictResolutionCoordinator } from './conflictResolutionCoordinator';

import { Conflict, ConflictResolutionModel } from './conflictResolutionModel';

import { CredentialStore } from './credentials';

import { CopilotWorkingStatus, GitHubRepository, ItemsData, PULL_REQUEST_PAGE_SIZE, PullRequestChangeEvent, PullRequestData, TeamReviewerRefreshKind, ViewerPermission } from './githubRepository';

import { PullRequestResponse, PullRequestState } from './graphql';

import { IAccount, ILabel, IMilestone, IProject, IPullRequestsPagingOptions, Issue, ITeam, MergeMethod, PRType, PullRequestMergeability, RepoAccessAndMergeMethods, User } from './interface';

import { IssueModel } from './issueModel';

import { PullRequestGitHelper, PullRequestMetadata } from './pullRequestGitHelper';

import { IResolvedPullRequestModel, PullRequestModel } from './pullRequestModel';

import {

convertRESTIssueToRawPullRequest,

convertRESTPullRequestToRawPullRequest,

getOverrideBranch,

getPRFetchQuery,

getStateFromQuery,

loginComparator,

parseGraphQLPullRequest,

teamComparator,

variableSubstitution,

} from './utils';

import type { Branch, Commit, Repository, UpstreamRef } from '../api/api';

import { GitApiImpl, GitErrorCodes } from '../api/api1';

import { GitHubManager } from '../authentication/githubServer';

import { AuthProvider, GitHubServerType } from '../common/authentication';

import { commands, contexts } from '../common/executeCommands';

import { InMemFileChange, SlimFileChange } from '../common/file';

import { findLocalRepoRemoteFromGitHubRef } from '../common/githubRef';

import { unwrapCommitMessageBody } from '../common/gitUtils';

import { Disposable, disposeAll } from '../common/lifecycle';

import Logger from '../common/logger';

import { Protocol, ProtocolType } from '../common/protocol';

import { GitHubRemote, parseRemote, parseRepositoryRemotes, parseRepositoryRemotesAsync, Remote } from '../common/remote';

import {

ALLOW_FETCH,

AUTO_STASH,

CHAT_SETTINGS_NAMESPACE,

CHECKOUT_DEFAULT_BRANCH,

CHECKOUT_PULL_REQUEST_BASE_BRANCH,

DISABLE_AI_FEATURES,

GIT,

POST_DONE,

PR_SETTINGS_NAMESPACE,

PULL_BEFORE_CHECKOUT,

PULL_BRANCH,

REMOTES,

UPSTREAM_REMOTE,

} from '../common/settingKeys';

import { ITelemetry } from '../common/telemetry';

import { EventType } from '../common/timelineEvent';

import { Schemes } from '../common/uri';

import { AsyncPredicate, batchPromiseAll, compareIgnoreCase, formatError, Predicate } from '../common/utils';

import { PULL_REQUEST_OVERVIEW_VIEW_TYPE } from '../common/webview';

import { BRANCHES_ASSOCIATED_WITH_PRS, LAST_USED_EMAIL, NEVER_SHOW_PULL_NOTIFICATION, REPO_KEYS, ReposState } from '../extensionState';

import { git } from '../gitProviders/gitCommands';

import { IThemeWatcher } from '../themeWatcher';

import { CreatePullRequestHelper } from '../view/createPullRequestHelper';

async function createConflictResolutionModel(pullRequest: PullRequestModel): Promise<ConflictResolutionModel | undefined> {

const head = pullRequest.head;

if (!head) {

throw new Error('No head found for pull request');

}

const baseCommitSha = await pullRequest.getLatestBaseCommitSha();

const prBaseOwner = pullRequest.base.owner;

const prHeadOwner = head.owner;

const prHeadRef = head.ref;

const repositoryName = (await pullRequest.githubRepository.ensure()).remote.repositoryName;

const potentialMergeConflicts: Conflict[] = [];

if (pullRequest.item.mergeable === PullRequestMergeability.Conflict) {

const mergeBaseIntoPrCompareData = await pullRequest.compareBaseBranchForMerge(prHeadOwner, prHeadRef, prBaseOwner, baseCommitSha);

if ((pullRequest.item.mergeable === PullRequestMergeability.Conflict) && (mergeBaseIntoPrCompareData.length >= 300)) {

// API limitation: it only returns the first 300 files

return undefined;

}

const previousFilenames: Map<string, SlimFileChange | InMemFileChange> = new Map();

// We must also check all the previous file names of the files in the PR. Assemble a map with this info

for (const fileChange of pullRequest.fileChanges.values()) {

if (fileChange.previousFileName) {

previousFilenames.set(fileChange.previousFileName, fileChange);

}

}

const knownConflicts = new Set<string>(pullRequest.conflicts);

for (const mergeFile of mergeBaseIntoPrCompareData) {

const fileChange = pullRequest.fileChanges.get(mergeFile.filename) ?? previousFilenames.get(mergeFile.filename);

if (fileChange && (knownConflicts.size === 0 || knownConflicts.has(fileChange.fileName))) {

const prHeadFilePath = fileChange.fileName;

let contentsConflict = false;

let filePathConflict = false;

let modeConflict = false;

if (mergeFile.status === 'modified') {

contentsConflict = true;

}

if (mergeFile.previous_filename || fileChange.previousFileName) {

filePathConflict = true;

}

potentialMergeConflicts.push({ prHeadFilePath, contentsConflict, filePathConflict, modeConflict });

}

}

}

return new ConflictResolutionModel(potentialMergeConflicts, repositoryName, prBaseOwner, baseCommitSha, prHeadOwner, prHeadRef,

pullRequest.base.ref, pullRequest.mergeBase!);

}

interface PageInformation {

pullRequestPage: number;

hasMorePages: boolean | null;

}

export interface ItemsResponseResult<T> {

items: T[];

hasMorePages: boolean;

hasUnsearchedRepositories: boolean;

totalCount?: number;

}

export class NoGitHubReposError extends Error {

constructor(public readonly repository: Repository) {

super();

}

override get message() {

return vscode.l10n.t('{0} has no GitHub remotes', this.repository.rootUri.toString());

}

}

export class DetachedHeadError extends Error {

constructor(public readonly repository: Repository) {

super();

}

override get message() {

return vscode.l10n.t('{0} has a detached HEAD (create a branch first)', this.repository.rootUri.toString());

}

}

export class BadUpstreamError extends Error {

constructor(public readonly branchName: string, public readonly upstreamRef: UpstreamRef, public readonly problem: string) {

super();

}

override get message() {

const {

upstreamRef: { remote, name },

branchName,

problem,

} = this;

return vscode.l10n.t('The upstream ref {0} for branch {1} {2}.', `${remote}/${name}`, branchName, problem);

}

}

export const ReposManagerStateContext: string = 'ReposManagerStateContext';

export enum ReposManagerState {

Initializing = 'Initializing',

NeedsAuthentication = 'NeedsAuthentication',

RepositoriesLoaded = 'RepositoriesLoaded',

}

export interface PullRequestDefaults {

owner: string;

repo: string;

base: string;

}

enum PagedDataType {

PullRequest,

IssueSearch,

}

const CACHED_TEMPLATE_BODY = 'templateBody';

export class FolderRepositoryManager extends Disposable {

static ID = 'FolderRepositoryManager';

private _state: ReposManagerState = ReposManagerState.Initializing;

private _activePullRequest?: PullRequestModel;

private _activeIssue?: IssueModel;

private _githubRepositories: GitHubRepository[];

private _allGitHubRemotes: GitHubRemote[] = [];

private _mentionableUsers?: { [key: string]: IAccount[] };

private _fetchMentionableUsersPromise?: Promise<{ [key: string]: IAccount[] }>;

private _assignableUsers?: { [key: string]: IAccount[] };

private _teamReviewers?: { [key: string]: ITeam[] };

private _fetchAssignableUsersPromise?: Promise<{ [key: string]: IAccount[] }>;

private _fetchTeamReviewersPromise?: Promise<{ [key: string]: ITeam[] }>;

private _gitBlameCache: { [key: string]: string } = {};

private _githubManager: GitHubManager;

private _repositoryPageInformation: Map<string, PageInformation> = new Map<string, PageInformation>();

private _addedUpstreamCount: number = 0;

private _onDidChangeActivePullRequest = this._register(new vscode.EventEmitter<{ new: PullRequestModel | undefined, old: PullRequestModel | undefined }>());

readonly onDidChangeActivePullRequest: vscode.Event<{ new: PullRequestModel | undefined, old: PullRequestModel | undefined }> = this._onDidChangeActivePullRequest.event;

private _onDidChangeActiveIssue = this._register(new vscode.EventEmitter<void>());

readonly onDidChangeActiveIssue: vscode.Event<void> = this._onDidChangeActiveIssue.event;

private _onDidLoadRepositories = this._register(new vscode.EventEmitter<ReposManagerState>());

readonly onDidLoadRepositories: vscode.Event<ReposManagerState> = this._onDidLoadRepositories.event;

private _onDidChangeRepositories = this._register(new vscode.EventEmitter<{ added: boolean }>());

readonly onDidChangeRepositories: vscode.Event<{ added: boolean }> = this._onDidChangeRepositories.event;

private _onDidChangeAssignableUsers = this._register(new vscode.EventEmitter<IAccount[]>());

readonly onDidChangeAssignableUsers: vscode.Event<IAccount[]> = this._onDidChangeAssignableUsers.event;

private _onDidChangeGithubRepositories = this._register(new vscode.EventEmitter<GitHubRepository[]>());

readonly onDidChangeGithubRepositories: vscode.Event<GitHubRepository[]> = this._onDidChangeGithubRepositories.event;

private _onDidChangePullRequestsEvents: vscode.Disposable[] = [];

private readonly _onDidChangeAnyPullRequests = this._register(new vscode.EventEmitter<PullRequestChangeEvent[]>());

readonly onDidChangeAnyPullRequests: vscode.Event<PullRequestChangeEvent[]> = this._onDidChangeAnyPullRequests.event;

private readonly _onDidAddPullRequest = this._register(new vscode.EventEmitter<IssueModel>());

readonly onDidAddPullRequest: vscode.Event<IssueModel> = this._onDidAddPullRequest.event;

private _onDidDispose = this._register(new vscode.EventEmitter<void>());

readonly onDidDispose: vscode.Event<void> = this._onDidDispose.event;

private _sessionIgnoredRemoteNames: Set<string> = new Set();

constructor(

private readonly _id: number,

public readonly context: vscode.ExtensionContext,

private _repository: Repository,

public readonly telemetry: ITelemetry,

private readonly _git: GitApiImpl,

private readonly _credentialStore: CredentialStore,

public readonly createPullRequestHelper: CreatePullRequestHelper,

public readonly themeWatcher: IThemeWatcher

) {

super();

this._githubRepositories = [];

this._githubManager = new GitHubManager();

this._register(

vscode.workspace.onDidChangeConfiguration(async e => {

if (e.affectsConfiguration(`${PR_SETTINGS_NAMESPACE}.${REMOTES}`)) {

await this.updateRepositories();

}

}),

);

this._register(_credentialStore.onDidInitialize(() => this.updateRepositories()));

this._register({ dispose: () => disposeAll(this._onDidChangePullRequestsEvents) });

this.cleanStoredRepoState();

}

private cleanStoredRepoState() {

const deleteDate: number = new Date().valueOf() - 30 /*days*/ * 86400000 /*milliseconds in a day*/;

const reposState = this.context.globalState.get<ReposState>(REPO_KEYS);

if (reposState?.repos) {

let keysChanged = false;

Object.keys(reposState.repos).forEach(repo => {

const repoState = reposState.repos[repo];

if ((repoState.stateModifiedTime ?? 0) < deleteDate) {

keysChanged = true;

delete reposState.repos[repo];

}

});

if (keysChanged) {

this.context.globalState.update(REPO_KEYS, reposState);

}

}

}

private get id(): string {

return `${FolderRepositoryManager.ID}+${this._id}`;

}

get gitHubRepositories(): GitHubRepository[] {

return this._githubRepositories;

}

public async computeAllUnknownRemotes(): Promise<Remote[]> {

const remotes = await parseRepositoryRemotesAsync(this.repository);

const potentialRemotes = remotes.filter(remote => remote.host);

const serverTypes = await Promise.all(

potentialRemotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),

).catch(e => {

Logger.error(`Resolving GitHub remotes failed: ${e}`, this.id);

vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));

return [];

});

const unknownRemotes: Remote[] = [];

let i = 0;

for (const potentialRemote of potentialRemotes) {

if (serverTypes[i] === GitHubServerType.None) {

unknownRemotes.push(potentialRemote);

}

i++;

}

return unknownRemotes;

}

public async computeAllGitHubRemotes(): Promise<GitHubRemote[]> {

const remotes = await parseRepositoryRemotesAsync(this.repository);

const potentialRemotes = remotes.filter(remote => remote.host);

const serverTypes = await Promise.all(

potentialRemotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),

).catch(e => {

Logger.error(`Resolving GitHub remotes failed: ${e}`, this.id);

vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));

return [];

});

const githubRemotes: GitHubRemote[] = [];

let i = 0;

for (const potentialRemote of potentialRemotes) {

if (serverTypes[i] !== GitHubServerType.None) {

githubRemotes.push(GitHubRemote.remoteAsGitHub(potentialRemote, serverTypes[i]));

}

i++;

}

return githubRemotes;

}

public async getActiveGitHubRemotes(allGitHubRemotes: GitHubRemote[]): Promise<GitHubRemote[]> {

const remotesSetting = vscode.workspace.getConfiguration(PR_SETTINGS_NAMESPACE).get<string[]>(REMOTES);

if (!remotesSetting) {

Logger.error(`Unable to read remotes setting`, this.id);

return Promise.resolve([]);

}

const missingRemotes = remotesSetting.filter(remote => {

return !allGitHubRemotes.some(repo => repo.remoteName === remote);

});

if (missingRemotes.length === remotesSetting.length) {

Logger.warn(`No remotes found. The following remotes are missing: ${missingRemotes.join(', ')}`);

} else {

Logger.debug(`Not all remotes found. The following remotes are missing: ${missingRemotes.join(', ')}`, this.id);

}

Logger.debug(`Displaying configured remotes: ${remotesSetting.join(', ')}`, this.id);

return remotesSetting

.map(remote => allGitHubRemotes.find(repo => repo.remoteName === remote))

.filter((repo: GitHubRemote | undefined): repo is GitHubRemote => !!repo && !this._sessionIgnoredRemoteNames.has(repo.remoteName));

}

get activeIssue(): IssueModel | undefined {

return this._activeIssue;

}

set activeIssue(issue: IssueModel | undefined) {

this._activeIssue = issue;

this._onDidChangeActiveIssue.fire();

}

get activePullRequest(): PullRequestModel | undefined {

return this._activePullRequest;

}

set activePullRequest(pullRequest: PullRequestModel | undefined) {

if (pullRequest === this._activePullRequest) {

return;

}

const oldPR = this._activePullRequest;

if (this._activePullRequest) {

this._activePullRequest.isActive = false;

}

if (pullRequest) {

pullRequest.isActive = true;

pullRequest.githubRepository.commentsHandler?.unregisterCommentController(pullRequest.number);

}

this._activePullRequest = pullRequest;

this._onDidChangeActivePullRequest.fire({ old: oldPR, new: pullRequest });

}

get repository(): Repository {

return this._repository;

}

set repository(repository: Repository) {

this._repository = repository;

}

get credentialStore(): CredentialStore {

return this._credentialStore;

}

/**

* Using these contexts is fragile in a multi-root workspace where multiple PRs are checked out.

* If you have two active PRs that have the same file path relative to their rootdir, then these context can get confused.

*/

public setFileViewedContext() {

const states = this.activePullRequest?.getViewedFileStates();

if (states) {

commands.setContext(contexts.VIEWED_FILES, Array.from(states.viewed));

commands.setContext(contexts.UNVIEWED_FILES, Array.from(states.unviewed));

} else {

this.clearFileViewedContext();

}

}

private clearFileViewedContext() {

commands.setContext(contexts.VIEWED_FILES, []);

commands.setContext(contexts.UNVIEWED_FILES, []);

}

public async loginAndUpdate() {

if (!this._credentialStore.isAnyAuthenticated()) {

const waitForRepos = new Promise<void>(c => {

const onReposChange = this.onDidChangeRepositories(() => {

onReposChange.dispose();

c();

});

});

await this._credentialStore.login(AuthProvider.github);

await waitForRepos;

}

}

private async getActiveRemotes(): Promise<GitHubRemote[]> {

this._allGitHubRemotes = await this.computeAllGitHubRemotes();

const activeRemotes = await this.getActiveGitHubRemotes(this._allGitHubRemotes);

if (activeRemotes.length) {

await vscode.commands.executeCommand('setContext', 'github:hasGitHubRemotes', true);

Logger.appendLine(`Found GitHub remote for folder ${this.repository.rootUri.fsPath}`, this.id);

if (this._allGitHubRemotes.length > 1) {

await vscode.commands.executeCommand('setContext', 'github:hasMultipleGitHubRemotes', true);

}

} else {

Logger.appendLine(`No GitHub remotes found for folder ${this.repository.rootUri.fsPath}`, this.id);

}

return activeRemotes;

}

private _updatingRepositories: Promise<boolean> | undefined;

async updateRepositories(silent: boolean = false): Promise<boolean> {

if (this._updatingRepositories) {

await this._updatingRepositories;

}

this._updatingRepositories = this.doUpdateRepositories(silent);

return this._updatingRepositories;

}

private checkForAuthMatch(activeRemotes: GitHubRemote[]): boolean {

// Check that our auth matches the remote.

let dotComCount = 0;

let enterpriseCount = 0;

for (const remote of activeRemotes) {

if (remote.githubServerType === GitHubServerType.GitHubDotCom) {

dotComCount++;

} else if (remote.githubServerType === GitHubServerType.Enterprise) {

enterpriseCount++;

}

}

let isAuthenticated = this._credentialStore.isAuthenticated(AuthProvider.github) || this._credentialStore.isAuthenticated(AuthProvider.githubEnterprise);

if ((dotComCount > 0) && this._credentialStore.isAuthenticated(AuthProvider.github)) {

// good

} else if ((enterpriseCount > 0) && this._credentialStore.isAuthenticated(AuthProvider.githubEnterprise)) {

// also good

} else if (isAuthenticated && ((dotComCount > 0) || (enterpriseCount > 0))) {

// Not good. We have a mismatch between auth type and server type.

isAuthenticated = false;

}

vscode.commands.executeCommand('setContext', 'github:authenticated', isAuthenticated);

return isAuthenticated;

}

get state(): ReposManagerState {

return this._state;

}

private set state(state: ReposManagerState) {

if (state !== this._state) {

this._state = state;

this._onDidLoadRepositories.fire(state);

}

}

private async doUpdateRepositories(silent: boolean): Promise<boolean> {

if (this._git.state === 'uninitialized') {

Logger.appendLine('Cannot updates repositories as git is uninitialized', this.id);

return false;

}

const activeRemotes = await this.getActiveRemotes();

const isAuthenticated = this.checkForAuthMatch(activeRemotes);

if (this.credentialStore.isAnyAuthenticated() && (activeRemotes.length === 0)) {

const allUnknownRemotes = await this.computeAllUnknownRemotes();

const areAllNeverGitHub = allUnknownRemotes.every(remote => GitHubManager.isNeverGitHub(vscode.Uri.parse(remote.normalizedHost).authority));

if ((allUnknownRemotes.length > 0) && areAllNeverGitHub) {

Logger.appendLine('No GitHub remotes found and all remotes are marked as never GitHub.', this.id);

this.state = ReposManagerState.RepositoriesLoaded;

return true;

}

}

const repositories: GitHubRepository[] = [];

const resolveRemotePromises: Promise<boolean>[] = [];

const oldRepositories: GitHubRepository[] = [];

this._githubRepositories.forEach(repo => oldRepositories.push(repo));

const authenticatedRemotes = activeRemotes.filter(remote => this._credentialStore.isAuthenticated(remote.authProviderId));

for (const remote of authenticatedRemotes) {

const repository = await this.createGitHubRepository(remote, this._credentialStore);

resolveRemotePromises.push(repository.resolveRemote());

repositories.push(repository);

}

const cleanUpMissingSaml = async (missingSaml: GitHubRepository[]) => {

for (const missing of missingSaml) {

this._sessionIgnoredRemoteNames.add(missing.remote.remoteName);

this.removeGitHubRepository(missing.remote);

const index = repositories.indexOf(missing);

if (index > -1) {

repositories.splice(index, 1);

}

}

};

return Promise.all(resolveRemotePromises).then(async (remoteResults: boolean[]) => {

const missingSaml: GitHubRepository[] = [];

for (let i = 0; i < remoteResults.length; i++) {

if (!remoteResults[i]) {

missingSaml.push(repositories[i]);

}

}

if (missingSaml.length > 0) {

const result = await this._credentialStore.showSamlMessageAndAuth(missingSaml.map(repo => repo.remote.owner));

// Make a test call to see if the user has SAML enabled.

const samlTest = result.canceled ? [] : await Promise.all(missingSaml.map(repo => repo.resolveRemote()));

const stillMissing = result.canceled ? missingSaml : samlTest.map((result, index) => !result ? missingSaml[index] : undefined).filter((repo): repo is GitHubRepository => !!repo);

// Make a test call to see if the user has SAML enabled.

if (stillMissing.length > 0) {

if (stillMissing.length === repositories.length) {

await vscode.window.showErrorMessage(vscode.l10n.t('SAML access was not provided. GitHub Pull Requests will not work.'), { modal: true });

this.dispose();

return true;

}

await vscode.window.showErrorMessage(vscode.l10n.t('SAML access was not provided. Some GitHub repositories will not be available.'), { modal: true });

cleanUpMissingSaml(stillMissing);

}

}

disposeAll(this._onDidChangePullRequestsEvents);

this._githubRepositories = repositories;

for (const repo of this._githubRepositories) {

this._onDidChangePullRequestsEvents.push(repo.onDidChangePullRequests(e => this._onDidChangeAnyPullRequests.fire(e)));

this._onDidChangePullRequestsEvents.push(repo.onDidAddPullRequest(e => this._onDidAddPullRequest.fire(e)));

}

oldRepositories.filter(old => this._githubRepositories.indexOf(old) < 0).forEach(repo => repo.dispose());

const repositoriesAdded =

oldRepositories.length !== this._githubRepositories.length ?

this.gitHubRepositories.filter(repo =>

!oldRepositories.some(oldRepo => oldRepo.remote.equals(repo.remote)),

) : [];

if (repositoriesAdded.length > 0) {

this._onDidChangeGithubRepositories.fire(this._githubRepositories);

}

if (this._githubRepositories.length && repositoriesAdded.length > 0) {

if (await this.checkIfMissingUpstream()) {

this.updateRepositories(silent);

return true;

}

}

if (this.activePullRequest) {

this.getMentionableUsers(repositoriesAdded.length > 0);

}

this.getAssignableUsers(repositoriesAdded.length > 0);

if (isAuthenticated && activeRemotes.length) {

this.state = ReposManagerState.RepositoriesLoaded;

// On first activation, associate local branches with PRs

// Do this asynchronously to not block the main flow

this.associateLocalBranchesWithPRsOnFirstActivation().catch(e => {

Logger.error(`Failed to associate branches with PRs: ${e}`, this.id);

});

} else if (!isAuthenticated) {

this.state = ReposManagerState.NeedsAuthentication;

}

if (!silent) {

this._onDidChangeRepositories.fire({ added: repositoriesAdded.length > 0 });

}

return true;

});

}

private async checkIfMissingUpstream(): Promise<boolean> {

try {

const origin = await this.getOrigin();

const metadata = await origin.getMetadata();

const configuration = vscode.workspace.getConfiguration(PR_SETTINGS_NAMESPACE);

if (metadata.fork && metadata.parent && (configuration.get<'add' | 'never'>(UPSTREAM_REMOTE, 'add') === 'add')) {

const parentUrl = new Protocol(metadata.parent.git_url);

const missingParentRemote = !this._githubRepositories.some(

repo =>

(compareIgnoreCase(repo.remote.owner, parentUrl.owner) === 0) &&

(compareIgnoreCase(repo.remote.repositoryName, parentUrl.repositoryName) === 0),

);

if (missingParentRemote) {

const upstreamAvailable = !this.repository.state.remotes.some(remote => remote.name === 'upstream');

const remoteName = upstreamAvailable ? 'upstream' : metadata.parent.owner?.login;

if (remoteName) {

// check the remotes to see what protocol is being used

const isSSH = this.gitHubRepositories[0].remote.gitProtocol.type === ProtocolType.SSH;

if (isSSH) {

await this.repository.addRemote(remoteName, metadata.parent.ssh_url);

} else {

await this.repository.addRemote(remoteName, metadata.parent.clone_url);

}

this._addedUpstreamCount++;

if (this._addedUpstreamCount > 1) {

// We've already added this remote, which means the user likely removed it. Let the user know they can disable this feature.

const neverOption = vscode.l10n.t('Set to `never`');

vscode.window.showInformationMessage(vscode.l10n.t('An `upstream` remote has been added for this repository. You can disable this feature by setting `githubPullRequests.upstreamRemote` to `never`.'), neverOption)

.then(choice => {

if (choice === neverOption) {

configuration.update(UPSTREAM_REMOTE, 'never', vscode.ConfigurationTarget.Global);

}

});

}

return true;

}

}

}

} catch (e) {

Logger.appendLine(`Missing upstream check failed: ${e}`, this.id);

// ignore

}

return false;

}

getAllAssignableUsers(): IAccount[] | undefined {

if (this._assignableUsers) {

const allAssignableUsers: IAccount[] = [];

Object.keys(this._assignableUsers).forEach(k => {

allAssignableUsers.push(...this._assignableUsers![k]);

});

return allAssignableUsers;

}

return undefined;

}

private async getCachedFromGlobalState<T>(userKind: 'assignableUsers' | 'teamReviewers' | 'mentionableUsers' | 'orgProjects'): Promise<{ [key: string]: T[] } | undefined> {

Logger.appendLine(`Trying to use globalState for ${userKind}.`, this.id);

const usersCacheLocation = vscode.Uri.joinPath(this.context.globalStorageUri, userKind);

let usersCacheExists;

try {

usersCacheExists = await vscode.workspace.fs.stat(usersCacheLocation);

} catch (e) {

// file doesn't exit

}

if (!usersCacheExists) {

Logger.appendLine(`GlobalState does not exist for ${userKind}.`, this.id);

return undefined;

}

const cache: { [key: string]: T[] } = {};

const hasAllRepos = (await Promise.all(this._githubRepositories.map(async (repo) => {

const key = `${repo.remote.owner}/${repo.remote.repositoryName}.json`;

const repoSpecificFile = vscode.Uri.joinPath(usersCacheLocation, key);

let repoSpecificCache;

let cacheAsJson;

try {

repoSpecificCache = await vscode.workspace.fs.readFile(repoSpecificFile);

cacheAsJson = JSON.parse(repoSpecificCache.toString());

} catch (e) {

if (e instanceof Error && e.message.includes('Unexpected non-whitespace character after JSON')) {

Logger.error(`Error parsing ${userKind} cache for ${repo.remote.remoteName}.`, this.id);

}

// file doesn't exist

}

if (repoSpecificCache && repoSpecificCache.toString()) {

cache[repo.remote.remoteName] = cacheAsJson ?? [];

return true;

}

}))).every(value => value);

if (hasAllRepos) {

Logger.appendLine(`Using globalState ${userKind} for ${Object.keys(cache).length}.`, this.id);

return cache;

}

Logger.appendLine(`No globalState for ${userKind}.`, this.id);

return undefined;

}

private async saveInGlobalState<T>(userKind: 'assignableUsers' | 'teamReviewers' | 'mentionableUsers' | 'orgProjects', cache: { [key: string]: T[] }): Promise<void> {

const cacheLocation = vscode.Uri.joinPath(this.context.globalStorageUri, userKind);

await Promise.all(this._githubRepositories.map(async (repo) => {

const key = `${repo.remote.owner}/${repo.remote.repositoryName}.json`;

const repoSpecificFile = vscode.Uri.joinPath(cacheLocation, key);

await vscode.workspace.fs.writeFile(repoSpecificFile, new TextEncoder().encode(JSON.stringify(cache[repo.remote.remoteName])));

}));

}

private createFetchMentionableUsersPromise(): Promise<{ [key: string]: IAccount[] }> {

const cache: { [key: string]: IAccount[] } = {};

return new Promise<{ [key: string]: IAccount[] }>(resolve => {

const promises = this._githubRepositories.map(async githubRepository => {

const data = await githubRepository.getMentionableUsers();

cache[githubRepository.remote.remoteName] = data;

return;

});

Promise.all(promises).then(() => {

this._mentionableUsers = cache;

this._fetchMentionableUsersPromise = undefined;

this.saveInGlobalState('mentionableUsers', cache)

.then(() => resolve(cache));

});

});

}

async getMentionableUsers(clearCache?: boolean): Promise<{ [key: string]: IAccount[] }> {

if (clearCache) {

delete this._mentionableUsers;

}

if (this._mentionableUsers) {

Logger.appendLine('Using in-memory cached mentionable users.', this.id);

return this._mentionableUsers;

}

const globalStateMentionableUsers = await this.getCachedFromGlobalState<IAccount>('mentionableUsers');

if (!this._fetchMentionableUsersPromise) {

this._fetchMentionableUsersPromise = this.createFetchMentionableUsersPromise();

return globalStateMentionableUsers ?? this._fetchMentionableUsersPromise;

}

return this._fetchMentionableUsersPromise;

}

async getAssignableUsers(clearCache?: boolean): Promise<{ [key: string]: IAccount[] }> {

if (clearCache) {

delete this._assignableUsers;

}

if (this._assignableUsers) {

Logger.appendLine('Using in-memory cached assignable users.', this.id);

return this._assignableUsers;

}

const globalStateAssignableUsers = await this.getCachedFromGlobalState<IAccount>('assignableUsers');

if (!this._fetchAssignableUsersPromise) {

const cache: { [key: string]: IAccount[] } = {};

const allAssignableUsers: IAccount[] = [];

this._fetchAssignableUsersPromise = new Promise(resolve => {

const promises = this._githubRepositories.map(async githubRepository => {

const data = await githubRepository.getAssignableUsers();

cache[githubRepository.remote.remoteName] = data.sort(loginComparator);

allAssignableUsers.push(...data);

return;

});

Promise.all(promises).then(() => {

this._assignableUsers = cache;

this._fetchAssignableUsersPromise = undefined;

this.saveInGlobalState('assignableUsers', cache);

resolve(cache);

this._onDidChangeAssignableUsers.fire(allAssignableUsers);

});

});

return globalStateAssignableUsers ?? this._fetchAssignableUsersPromise;

}

return this._fetchAssignableUsersPromise;

}

async getTeamReviewers(refreshKind: TeamReviewerRefreshKind): Promise<{ [key: string]: ITeam[] }> {

if (refreshKind === TeamReviewerRefreshKind.Force) {

delete this._teamReviewers;

}

if (this._teamReviewers) {

Logger.appendLine('Using in-memory cached team reviewers.', this.id);

return this._teamReviewers;

}

const globalStateTeamReviewers = (refreshKind === TeamReviewerRefreshKind.Force) ? undefined : await this.getCachedFromGlobalState<ITeam>('teamReviewers');

if (globalStateTeamReviewers) {

this._teamReviewers = globalStateTeamReviewers;

return globalStateTeamReviewers || {};

}

if (!this._fetchTeamReviewersPromise) {

const cache: { [key: string]: ITeam[] } = {};

return (this._fetchTeamReviewersPromise = new Promise(async (resolve) => {

// Keep track of the org teams we have already gotten so we don't make duplicate calls

const orgTeams: Map<string, (ITeam & { repositoryNames: string[] })[]> = new Map();

// Go through one github repo at a time so that we don't make overlapping auth calls

for (const githubRepository of this._githubRepositories) {

if (!orgTeams.has(githubRepository.remote.owner)) {

try {

const data = await githubRepository.getOrgTeams(refreshKind);

orgTeams.set(githubRepository.remote.owner, data);

} catch (e) {

break;

}

}

const allTeamsForOrg = orgTeams.get(githubRepository.remote.owner) ?? [];

cache[githubRepository.remote.remoteName] = allTeamsForOrg.filter(team => team.repositoryNames.includes(githubRepository.remote.repositoryName)).sort(teamComparator);

}

this._teamReviewers = cache;

this._fetchTeamReviewersPromise = undefined;

this.saveInGlobalState('teamReviewers', cache);

resolve(cache);

}));

}

return this._fetchTeamReviewersPromise;

}

private createFetchOrgProjectsPromise(): Promise<{ [key: string]: IProject[] }> {

const cache: { [key: string]: IProject[] } = {};

return new Promise<{ [key: string]: IProject[] }>(async resolve => {

// Keep track of the org teams we have already gotten so we don't make duplicate calls

const orgProjects: Map<string, IProject[]> = new Map();

// Go through one github repo at a time so that we don't make overlapping auth calls

for (const githubRepository of this._githubRepositories) {

if (!orgProjects.has(githubRepository.remote.owner)) {

try {

const data = await githubRepository.getOrgProjects();

orgProjects.set(githubRepository.remote.owner, data);

} catch (e) {

break;

}

}

cache[githubRepository.remote.remoteName] = orgProjects.get(githubRepository.remote.owner) ?? [];

}

await this.saveInGlobalState('orgProjects', cache);

resolve(cache);

});

}

async getOrgProjects(clearCache?: boolean): Promise<{ [key: string]: IProject[] }> {

if (clearCache) {

return this.createFetchOrgProjectsPromise();

}

const globalStateProjects = await this.getCachedFromGlobalState<IProject>('orgProjects');

return globalStateProjects ?? this.createFetchOrgProjectsPromise();

}

async getAllProjects(githubRepository: GitHubRepository, clearOrgCache?: boolean): Promise<IProject[]> {

const isInOrganization = !!(await githubRepository.getMetadata()).organization;

const [repoProjects, orgProjects] = (await Promise.all([githubRepository.getProjects(), (isInOrganization ? this.getOrgProjects(clearOrgCache) : undefined)]));

return [...(repoProjects ?? []), ...(orgProjects ? orgProjects[githubRepository.remote.remoteName] : [])];

}

async getOrgTeamsCount(repository: GitHubRepository): Promise<number> {

if ((await repository.getMetadata()).organization) {

return repository.getOrgTeamsCount();

}

return 0;

}

async getPullRequestParticipants(githubRepository: GitHubRepository, pullRequestNumber: number): Promise<{ participants: IAccount[], viewer: IAccount }> {

return {

participants: await githubRepository.getPullRequestParticipants(pullRequestNumber),

viewer: await this.getCurrentUser(githubRepository)

};

}

/**

* Returns the remotes that are currently active, which is those that are important by convention (origin, upstream),

* or the remotes configured by the setting githubPullRequests.remotes

*/

async getGitHubRemotes(): Promise<GitHubRemote[]> {

const githubRepositories = this._githubRepositories;

if (!githubRepositories || !githubRepositories.length) {

return [];

}

const remotes = githubRepositories.map(repo => repo.remote).flat();

const serverTypes = await Promise.all(

remotes.map(remote => this._githubManager.isGitHub(remote.gitProtocol.normalizeUri()!)),

).catch(e => {

Logger.error(`Resolving GitHub remotes failed: ${e}`, this.id);

vscode.window.showErrorMessage(vscode.l10n.t('Resolving GitHub remotes failed: {0}', formatError(e)));

return [];

});

const githubRemotes = remotes.map((remote, index) => GitHubRemote.remoteAsGitHub(remote, serverTypes[index]));

if (this.checkForAuthMatch(githubRemotes)) {

return githubRemotes;

}

return [];

}

/**

* Returns all remotes from the repository.

*/

async getAllGitHubRemotes(): Promise<GitHubRemote[]> {

return await this.computeAllGitHubRemotes();

}

async getLocalPullRequests(): Promise<PullRequestModel[]> {

const githubRepositories = this._githubRepositories;

if (!githubRepositories || !githubRepositories.length || !this.repository.getRefs) {

return [];

}

const localBranches = (await this.repository.getRefs({ pattern: 'refs/heads/' }))

.filter(r => r.name !== undefined)

.map(r => r.name!);

// Chunk localBranches into chunks of 100 to avoid hitting the GitHub API rate limit

const chunkedLocalBranches: string[][] = [];

const chunkSize = 100;

for (let i = 0; i < localBranches.length; i += chunkSize) {

const chunk = localBranches.slice(i, i + chunkSize);

chunkedLocalBranches.push(chunk);

}

const models: (PullRequestModel | undefined)[] = [];

for (const chunk of chunkedLocalBranches) {

models.push(...await Promise.all(chunk.map(async localBranchName => {

const matchingPRMetadata = await PullRequestGitHelper.getMatchingPullRequestMetadataForBranch(

this.repository,

localBranchName,

);

if (matchingPRMetadata) {

const { owner, prNumber } = matchingPRMetadata;

const githubRepo = githubRepositories.find(

repo => repo.remote.owner.toLocaleLowerCase() === owner.toLocaleLowerCase(),

);

if (githubRepo) {

const pullRequest: PullRequestModel | undefined = await githubRepo.getPullRequest(prNumber);

if (pullRequest) {

pullRequest.localBranchName = localBranchName;

return pullRequest;

}

}

}

})));

}

return models.filter(value => value !== undefined) as PullRequestModel[];

}

/**

* On first activation, iterate through local branches and associate them with PRs if they match.

* This helps discover PRs that were created before the extension was installed or in other ways.

*/

private async associateLocalBranchesWithPRsOnFirstActivation(): Promise<void> {

const stateKey = `${BRANCHES_ASSOCIATED_WITH_PRS}.${this.repository.rootUri.fsPath}`;

const hasRun = this.context.globalState.get<boolean>(stateKey, false);

if (hasRun) {

Logger.debug('Branch association has already run for this workspace folder', this.id);

return;

}

Logger.appendLine('First activation: associating local branches with PRs', this.id);

const githubRepositories = this._githubRepositories;

if (!githubRepositories || !githubRepositories.length || !this.repository.getRefs) {

Logger.debug('No GitHub repositories or getRefs not available, skipping branch association', this.id);

await this.context.globalState.update(stateKey, true);

return;

}

try {

// Only check the 3 most recently used branches to minimize API calls

const localBranches = (await this.repository.getRefs({

pattern: 'refs/heads/',

sort: 'committerdate',

count: 10

}))

.filter(r => r.name !== undefined)

.map(r => r.name!);

Logger.debug(`Found ${localBranches.length} local branches to check`, this.id);