/// <inheritdoc/>
public async Task CloneRepository(
string cloneUrl,
string repositoryPath,
object progress = null)
{
Guard.ArgumentNotEmptyString(cloneUrl, nameof(cloneUrl));
Guard.ArgumentNotEmptyString(repositoryPath, nameof(repositoryPath));
// Switch to a thread pool thread for IO then back to the main thread to call
// vsGitServices.Clone() as this must be called on the main thread.
await ThreadingHelper.SwitchToPoolThreadAsync();
operatingSystem.Directory.CreateDirectory(repositoryPath);
await ThreadingHelper.SwitchToMainThreadAsync();
try
{
await vsGitServices.Clone(cloneUrl, repositoryPath, true, progress);
await usageTracker.IncrementCounter(x => x.NumberOfClones);
if (repositoryPath.StartsWith(DefaultClonePath, StringComparison.OrdinalIgnoreCase))
{
// Count the number of times users clone into the Default Repository Location
await usageTracker.IncrementCounter(x => x.NumberOfClonesToDefaultClonePath);
}
}
catch (Exception ex)
{
log.Error(ex, "Could not clone {CloneUrl} to {Path}", cloneUrl, repositoryPath);
throw;
}
}
public IObservable <Unit> CloneRepository(string cloneUrl, string repositoryName, string repositoryPath)
{
Guard.ArgumentNotEmptyString(cloneUrl, nameof(cloneUrl));
Guard.ArgumentNotEmptyString(repositoryName, nameof(repositoryName));
Guard.ArgumentNotEmptyString(repositoryPath, nameof(repositoryPath));
return(Observable.StartAsync(async() =>
{
string path = Path.Combine(repositoryPath, repositoryName);
operatingSystem.Directory.CreateDirectory(path);
// Once we've done IO switch to the main thread to call vsGitServices.Clone() as this must be
// called on the main thread.
await ThreadingHelper.SwitchToMainThreadAsync();
try
{
// this will throw if it can't find it
vsGitServices.Clone(cloneUrl, path, true);
}
catch (Exception ex)
{
log.Error("Could not clone {0} to {1}. {2}", cloneUrl, path, ex);
throw;
}
return Unit.Default;
}));
}
/// <summary>
/// Refreshes the contents of the view model.
/// </summary>
public override async Task Refresh()
{
try
{
await ThreadingHelper.SwitchToMainThreadAsync();
Error = null;
OperationError = null;
IsBusy = true;
var pullRequest = await modelService.GetPullRequest(RemoteRepositoryOwner, LocalRepository.Name, Number);
await Load(pullRequest);
}
catch (Exception ex)
{
log.Error(
ex,
"Error loading pull request {Owner}/{Repo}/{Number} from {Address}",
RemoteRepositoryOwner,
LocalRepository.Name,
Number,
modelService.ApiClient.HostAddress.Title);
Error = ex;
IsBusy = false;
}
}
/// <inheritdoc/>
public async Task CloneRepository(
string cloneUrl,
string repositoryName,
string repositoryPath,
object progress = null)
{
Guard.ArgumentNotEmptyString(cloneUrl, nameof(cloneUrl));
Guard.ArgumentNotEmptyString(repositoryName, nameof(repositoryName));
Guard.ArgumentNotEmptyString(repositoryPath, nameof(repositoryPath));
string path = Path.Combine(repositoryPath, repositoryName);
// Switch to a thread pool thread for IO then back to the main thread to call
// vsGitServices.Clone() as this must be called on the main thread.
await ThreadingHelper.SwitchToPoolThreadAsync();
operatingSystem.Directory.CreateDirectory(path);
await ThreadingHelper.SwitchToMainThreadAsync();
try
{
await vsGitServices.Clone(cloneUrl, path, true, progress);
await usageTracker.IncrementCloneCount();
}
catch (Exception ex)
{
log.Error(ex, "Could not clone {CloneUrl} to {Path}", cloneUrl, path);
throw;
}
}
private void LoadResources()
{
Licenses.Clear();
Licenses.Add(string.Empty, Strings.Common_ChooseALicense);
SelectedLicense = string.Empty;
foreach (var line in _git.GetLicenses())
{
Licenses.Add(line, line);
}
Owners.Clear();
var user = _storage.GetUser();
if (user != null)
{
Owners.Add(new Ownership(user.Username, user.FullName, OwnershipTypes.User));
}
Task.Run(async() =>
{
var owners = await _web.GetUserOrginizationsAsync();
await ThreadingHelper.SwitchToMainThreadAsync();
foreach (var owner in owners)
{
Owners.Add(owner);
}
});
}
/// <inheritdoc/>
public async Task Refresh()
{
await ThreadingHelper.SwitchToPoolThreadAsync();
var list = vsGitServices.GetKnownRepositories();
await ThreadingHelper.SwitchToMainThreadAsync();
repositories.Except(list).ToList().ForEach(x => repositories.Remove(x));
list.Except(repositories).ToList().ForEach(x => repositories.Add(x));
}
async Task RepoChanged(ILocalRepositoryModel repository)
{
try
{
await ThreadingHelper.SwitchToMainThreadAsync();
await EnsureLoggedIn(repository);
if (repository != this.repository)
{
this.repository = repository;
CurrentSession = null;
sessions.Clear();
}
if (string.IsNullOrWhiteSpace(repository?.CloneUrl))
{
return;
}
var modelService = hosts.LookupHost(HostAddress.Create(repository.CloneUrl))?.ModelService;
var session = CurrentSession;
if (modelService != null)
{
var pr = await service.GetPullRequestForCurrentBranch(repository).FirstOrDefaultAsync();
if (pr?.Item1 != (CurrentSession?.PullRequest.Base.RepositoryCloneUrl.Owner) &&
pr?.Item2 != (CurrentSession?.PullRequest.Number))
{
var pullRequest = await GetPullRequestForTip(modelService, repository);
if (pullRequest != null)
{
var newSession = await GetSessionInternal(pullRequest);
if (newSession != null)
{
newSession.IsCheckedOut = true;
}
session = newSession;
}
}
}
else
{
session = null;
}
CurrentSession = session;
}
catch
{
// TODO: Log
}
}
async Task RepoChanged(ILocalRepositoryModel localRepositoryModel)
{
try
{
await ThreadingHelper.SwitchToMainThreadAsync();
if (localRepositoryModel != repository)
{
repository = localRepositoryModel;
CurrentSession = null;
sessions.Clear();
}
if (string.IsNullOrWhiteSpace(localRepositoryModel?.CloneUrl))
{
return;
}
var modelService = await connectionManager.GetModelService(repository, modelServiceFactory);
var session = CurrentSession;
if (modelService != null)
{
var pr = await service.GetPullRequestForCurrentBranch(localRepositoryModel).FirstOrDefaultAsync();
if (pr?.Item1 != (CurrentSession?.PullRequest.Base.RepositoryCloneUrl.Owner) &&
pr?.Item2 != (CurrentSession?.PullRequest.Number))
{
var pullRequest = await GetPullRequestForTip(modelService, localRepositoryModel);
if (pullRequest != null)
{
var newSession = await GetSessionInternal(pullRequest);
if (newSession != null)
{
newSession.IsCheckedOut = true;
}
session = newSession;
}
}
}
else
{
session = null;
}
CurrentSession = session;
}
catch (Exception e)
{
log.Error(e, "Error changing repository");
}
}
private void GitExt_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (e.PropertyName == "ActiveRepositories")
{
Task.Run(async() =>
{
await ThreadingHelper.SwitchToMainThreadAsync();
Refresh();
});
}
}
async void ActiveRepositoriesChanged()
{
try
{
await ThreadingHelper.SwitchToMainThreadAsync();
await Refresh();
}
catch (Exception ex)
{
log.Error(ex, "Error refreshing in ActiveRepositoriesChanged.");
}
}
async Task RunModalDialogForAuthentication(UIControllerFlow flow, IObservable <LoadData> listener, LoadData initiaLoadData)
{
await ThreadingHelper.SwitchToMainThreadAsync();
windowController = new WindowController(listener,
(v, f) => f == flow,
(v, f) => f != flow);
windowController.WindowStartupLocation = WindowStartupLocation.CenterOwner;
windowController.Load(initiaLoadData.View);
windowController.ShowModal();
windowController = null;
}
/// <summary>
/// Initialize the PR status UI on Visual Studio's status bar.
/// </summary>
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
var usageTracker = (IUsageTracker) await GetServiceAsync(typeof(IUsageTracker));
var serviceProvider = (IGitHubServiceProvider) await GetServiceAsync(typeof(IGitHubServiceProvider));
var barManager = new PullRequestStatusBarManager(usageTracker, serviceProvider);
await ThreadingHelper.SwitchToMainThreadAsync();
barManager.StartShowingStatus();
}
async Task Initialize()
{
if (storePath == null)
{
await ThreadingHelper.SwitchToMainThreadAsync();
var program = serviceProvider.GetService <IProgram>();
storePath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
program.ApplicationName,
StoreFileName);
}
}
protected override async Task InitializeAsync(
CancellationToken cancellationToken,
IProgress <ServiceProgressData> progress)
{
var menuService = (IMenuCommandService)(await GetServiceAsync(typeof(IMenuCommandService)));
var componentModel = (IComponentModel)(await GetServiceAsync(typeof(SComponentModel)));
var exports = componentModel.DefaultExportProvider;
await ThreadingHelper.SwitchToMainThreadAsync();
menuService.AddCommands(
exports.GetExportedValue <INextInlineCommentCommand>(),
exports.GetExportedValue <IPreviousInlineCommentCommand>());
}
async Task Initialize()
{
// The services needed by the usage tracker are loaded when they are first needed to
// improve the startup time of the extension.
if (!initialized)
{
await ThreadingHelper.SwitchToMainThreadAsync();
client = gitHubServiceProvider.TryGetService <IMetricsService>();
connectionManager = gitHubServiceProvider.GetService <IConnectionManager>();
vsservices = gitHubServiceProvider.GetService <IVSServices>();
initialized = true;
}
}
public async Task <TwoFactorChallengeResult> HandleTwoFactorException(TwoFactorAuthorizationException exception)
{
await ThreadingHelper.SwitchToMainThreadAsync();
var userError = new TwoFactorRequiredUserError(exception);
var result = await twoFactorDialog.Show(userError);
if (result != null)
{
return(result);
}
else
{
throw exception;
}
}
async Task InitializeMenus()
{
var menus = await GetServiceAsync(typeof(IMenuProvider)) as IMenuProvider;
await ThreadingHelper.SwitchToMainThreadAsync();
foreach (var menu in menus.Menus)
{
serviceProvider.AddCommandHandler(menu.Guid, menu.CmdId, (s, e) => menu.Activate());
}
foreach (var menu in menus.DynamicMenus)
{
serviceProvider.AddCommandHandler(menu.Guid, menu.CmdId, menu.CanShow, () => menu.Activate());
}
}
async Task InitializeMenus()
{
var menuService = (IMenuCommandService)(await GetServiceAsync(typeof(IMenuCommandService)));
var componentModel = (IComponentModel)(await GetServiceAsync(typeof(SComponentModel)));
var exports = componentModel.DefaultExportProvider;
await ThreadingHelper.SwitchToMainThreadAsync();
menuService.AddCommands(
exports.GetExportedValue <IAddConnectionCommand>(),
exports.GetExportedValue <IBlameLinkCommand>(),
exports.GetExportedValue <ICopyLinkCommand>(),
exports.GetExportedValue <ICreateGistCommand>(),
exports.GetExportedValue <IOpenLinkCommand>(),
exports.GetExportedValue <IOpenPullRequestsCommand>(),
exports.GetExportedValue <IShowCurrentPullRequestCommand>(),
exports.GetExportedValue <IShowGitHubPaneCommand>());
}
private void LoadResources()
{
Owners.Clear();
var user = _storage.GetUser();
Owners.Add(new Ownership(user.Username, user.FullName, OwnershipTypes.User));
SelectedOwner = Owners[0];
Task.Run(async() =>
{
var owners = await _web.GetUserOrginizationsAsync();
await ThreadingHelper.SwitchToMainThreadAsync();
foreach (var owner in owners)
{
Owners.Add(owner);
}
});
GitIgnores.Add(string.Empty, Strings.Common_ChooseAGitIgnore);
SelectedGitIgnore = string.Empty;
foreach (var line in _git.GetGitIgnores())
{
GitIgnores.Add(line, $"{line} - .gitignore");
}
Licenses.Add(string.Empty, Strings.Common_ChooseALicense);
SelectedLicense = string.Empty;
foreach (var line in _git.GetLicenses())
{
Licenses.Add(line, line);
}
string defaultnamespace = _storage.GetUser().Username;
foreach (var path in _web.GetNamespacesPathList())
{
Namespaces.Add(path.id.ToString(), $"{path.name} - {path.full_path}");
if (path.full_path == defaultnamespace)
{
SelectedNamespaces = path.id.ToString();
}
}
}
async Task Initialize()
{
// The services needed by the usage tracker are loaded when they are first needed to
// improve the startup time of the extension.
if (userSettings == null)
{
await ThreadingHelper.SwitchToMainThreadAsync();
client = gitHubServiceProvider.GetService <IMetricsService>();
connectionManager = gitHubServiceProvider.GetService <IConnectionManager>();
userSettings = gitHubServiceProvider.GetService <IPackageSettings>();
vsservices = gitHubServiceProvider.GetService <IVSServices>();
var program = gitHubServiceProvider.GetService <IProgram>();
storePath = System.IO.Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
program.ApplicationName,
StoreFileName);
}
}
async Task InitializeMenus()
{
var menus = await GetServiceAsync(typeof(IMenuProvider)) as IMenuProvider;
if (menus == null)
{
// Ignore if null because Expression Blend doesn't support custom services or menu extensibility.
return;
}
await ThreadingHelper.SwitchToMainThreadAsync();
foreach (var menu in menus.Menus)
{
serviceProvider.AddCommandHandler(menu.Guid, menu.CmdId, (s, e) => menu.Activate());
}
foreach (var menu in menus.DynamicMenus)
{
serviceProvider.AddCommandHandler(menu.Guid, menu.CmdId, menu.CanShow, () => menu.Activate());
}
}
/// <inheritdoc/>
public async Task CloneRepository(
string cloneUrl,
string repositoryPath,
object progress = null)
{
Guard.ArgumentNotEmptyString(cloneUrl, nameof(cloneUrl));
Guard.ArgumentNotEmptyString(repositoryPath, nameof(repositoryPath));
// Switch to a thread pool thread for IO then back to the main thread to call
// vsGitServices.Clone() as this must be called on the main thread.
await ThreadingHelper.SwitchToPoolThreadAsync();
operatingSystem.Directory.CreateDirectory(repositoryPath);
await ThreadingHelper.SwitchToMainThreadAsync();
try
{
await vsGitServices.Clone(cloneUrl, repositoryPath, true, progress);
await usageTracker.IncrementCounter(x => x.NumberOfClones);
var repositoryUrl = new UriString(cloneUrl).ToRepositoryUrl();
var isDotCom = HostAddress.IsGitHubDotComUri(repositoryUrl);
if (isDotCom)
{
await usageTracker.IncrementCounter(x => x.NumberOfGitHubClones);
}
else
{
// If it isn't a GitHub URL, assume it's an Enterprise URL
await usageTracker.IncrementCounter(x => x.NumberOfEnterpriseClones);
}
}
catch (Exception ex)
{
log.Error(ex, "Could not clone {CloneUrl} to {Path}", cloneUrl, repositoryPath);
throw;
}
}
public async Task ChallengeFailed(Exception exception)
{
await ThreadingHelper.SwitchToMainThreadAsync();
await twoFactorDialog.Cancel.ExecuteAsync(null);
}
