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!);

items: T[];

hasMorePages: boolean;

hasUnsearchedRepositories: boolean;

constructor(public repository: Repository) {

super();

}

get message() {

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

}

constructor(public repository: Repository) {

super();

}

get message() {

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

}

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

super();

}

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

}

Initializing = 'Initializing',

NeedsAuthentication = 'NeedsAuthentication',

RepositoriesLoaded = 'RepositoriesLoaded',

owner: string;

repo: string;

base: string;

static ID = 'FolderRepositoryManager';

private _subs: vscode.Disposable[];

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 _onDidMergePullRequest = new vscode.EventEmitter<void>();

readonly onDidMergePullRequest = this._onDidMergePullRequest.event;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

constructor(

private _id: number,

public context: vscode.ExtensionContext,

private _repository: Repository,

public readonly telemetry: ITelemetry,

private _git: GitApiImpl,

private _credentialStore: CredentialStore,

public readonly createPullRequestHelper: CreatePullRequestHelper

) {

this._subs = [];

this._githubRepositories = [];

this._githubManager = new GitHubManager();

this._subs.push(

vscode.workspace.onDidChangeConfiguration(async e => {

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

await this.updateRepositories();

}

}),

);

this._subs.push(_credentialStore.onDidInitialize(() => this.updateRepositories()));

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 = parseRepositoryRemotes(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}`);

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 = parseRepositoryRemotes(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}`);

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`);

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

}

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 oldNumber = this._activePullRequest?.number;

if (this._activePullRequest) {

this._activePullRequest.isActive = false;

}

if (pullRequest) {

pullRequest.isActive = true;

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

}

const newNumber = pullRequest?.number;

this._activePullRequest = pullRequest;

this._onDidChangeActivePullRequest.fire({ old: oldNumber, new: newNumber });

}

get repository(): Repository {

return this._repository;

}

set repository(repository: Repository) {

this._repository = repository;

}

get credentialStore(): CredentialStore {

return this._credentialStore;

}

/**

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

} else {

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

}

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) {

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

isAuthenticated = false;

}

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

return isAuthenticated;

}

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

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

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

return false;

}

const activeRemotes = await this.getActiveRemotes();

const isAuthenticated = this.checkForAuthMatch(activeRemotes);

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

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

if (areAllNeverGitHub) {

this._onDidLoadRepositories.fire(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);

}

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

if (result.canceled) {

this.dispose();

return true;

} else {

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

const samlTest = await Promise.all(missingSaml.map(repo => repo.resolveRemote()));

if (samlTest.some(result => !result)) {

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

this.dispose();

return true;

}

}

}

this._githubRepositories = repositories;

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._onDidLoadRepositories.fire(ReposManagerState.RepositoriesLoaded);

} else if (!isAuthenticated) {

this._onDidLoadRepositories.fire(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}`);

// 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}.`);

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}.`);

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}.`);

}

// 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}.`);

return cache;

}

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

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)