RepositoryCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem, notificationService)
{ }
/// <summary>
/// This returns a service provider with everything mocked except for
/// RepositoryCloneService and RepositoryCreationService, which are real
/// instances.
/// </summary>
/// <param name="cloneService"></param>
/// <param name="creationService"></param>
/// <returns></returns>
public static IServiceProvider GetServiceProvider(
IRepositoryCloneService cloneService = null,
IRepositoryCreationService creationService = null,
IAvatarProvider avatarProvider = null)
{
var ret = Substitute.For<IServiceProvider, IUIProvider>();
var os = OperatingSystem;
var git = IGitRepositoriesExt;
var vs = IVSServices;
var clone = cloneService ?? new RepositoryCloneService(os, vs);
var create = creationService ?? new RepositoryCreationService(clone);
var hosts = RepositoryHosts;
var exports = ExportFactoryProvider;
var connection = Connection;
var connectionManager = ConnectionManager;
var twoFactorChallengeHandler = TwoFactorChallengeHandler;
avatarProvider = avatarProvider ?? Substitute.For<IAvatarProvider>();
ret.GetService(typeof(IGitRepositoriesExt)).Returns(git);
ret.GetService(typeof(IVSServices)).Returns(vs);
ret.GetService(typeof(IOperatingSystem)).Returns(os);
ret.GetService(typeof(IRepositoryCloneService)).Returns(clone);
ret.GetService(typeof(IRepositoryCreationService)).Returns(create);
ret.GetService(typeof(IRepositoryHosts)).Returns(hosts);
ret.GetService(typeof(IExportFactoryProvider)).Returns(exports);
ret.GetService(typeof(IConnection)).Returns(connection);
ret.GetService(typeof(IConnectionManager)).Returns(connectionManager);
ret.GetService(typeof(IAvatarProvider)).Returns(avatarProvider);
ret.GetService(typeof(ITwoFactorChallengeHandler)).Returns(twoFactorChallengeHandler);
return ret;
}
/// <summary>
/// This returns a service provider with everything mocked except for
/// RepositoryCloneService and RepositoryCreationService, which are real
/// instances.
/// </summary>
/// <param name="cloneService"></param>
/// <param name="creationService"></param>
/// <returns></returns>
public static IServiceProvider GetServiceProvider(
IRepositoryCloneService cloneService = null,
IRepositoryCreationService creationService = null,
IAvatarProvider avatarProvider = null)
{
var ret = Substitute.For <IServiceProvider, IUIProvider>();
var gitservice = IGitService;
var cm = Substitute.For <SComponentModel, IComponentModel>();
var cc = new CompositionContainer(CompositionOptions.IsThreadSafe | CompositionOptions.DisableSilentRejection);
cc.ComposeExportedValue(gitservice);
((IComponentModel)cm).DefaultExportProvider.Returns(cc);
ret.GetService(typeof(SComponentModel)).Returns(cm);
var os = OperatingSystem;
var vs = IVSServices;
var clone = cloneService ?? new RepositoryCloneService(os, vs);
var create = creationService ?? new RepositoryCreationService(clone);
avatarProvider = avatarProvider ?? Substitute.For <IAvatarProvider>();
ret.GetService(typeof(IGitRepositoriesExt)).Returns(IGitRepositoriesExt);
ret.GetService(typeof(IGitService)).Returns(gitservice);
ret.GetService(typeof(IVSServices)).Returns(vs);
ret.GetService(typeof(IOperatingSystem)).Returns(os);
ret.GetService(typeof(IRepositoryCloneService)).Returns(clone);
ret.GetService(typeof(IRepositoryCreationService)).Returns(create);
ret.GetService(typeof(IRepositoryHosts)).Returns(RepositoryHosts);
ret.GetService(typeof(IExportFactoryProvider)).Returns(ExportFactoryProvider);
ret.GetService(typeof(IConnection)).Returns(Connection);
ret.GetService(typeof(IConnectionManager)).Returns(ConnectionManager);
ret.GetService(typeof(IAvatarProvider)).Returns(avatarProvider);
ret.GetService(typeof(ITwoFactorChallengeHandler)).Returns(TwoFactorChallengeHandler);
return(ret);
}
public StartPageCloneViewModel(
IGlobalConnection connection,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
: this(connection.Get(), cloneService, operatingSystem)
{
}
RepositoryCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem,
IVSServices vsServices)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem, vsServices)
{ }
static RepositoryCloneViewModel CreateTarget(
IOperatingSystem os = null,
IConnectionManager connectionManager = null,
IRepositoryCloneService service = null,
IUsageService usageService = null,
IUsageTracker usageTracker = null,
IRepositorySelectViewModel gitHubTab = null,
IRepositorySelectViewModel enterpriseTab = null,
IGitService gitService = null,
IRepositoryUrlViewModel urlTab = null,
string defaultClonePath = defaultPath)
{
os = os ?? Substitute.For <IOperatingSystem>();
connectionManager = connectionManager ?? CreateConnectionManager("https://github.com");
service = service ?? CreateRepositoryCloneService(defaultClonePath);
usageService = usageService ?? CreateUsageService();
usageTracker = usageTracker ?? Substitute.For <IUsageTracker>();
gitHubTab = gitHubTab ?? CreateSelectViewModel();
enterpriseTab = enterpriseTab ?? CreateSelectViewModel();
gitService = gitService ?? CreateGitService(true, "https://github.com/owner/repo");
urlTab = urlTab ?? CreateRepositoryUrlViewModel();
return(new RepositoryCloneViewModel(
os,
connectionManager,
service,
gitService,
usageService,
usageTracker,
gitHubTab,
enterpriseTab,
urlTab));
}
RepositoryCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem)
{
}
/// <summary>
/// This returns a service provider with everything mocked except for
/// RepositoryCloneService and RepositoryCreationService, which are real
/// instances.
/// </summary>
/// <param name="cloneService"></param>
/// <param name="creationService"></param>
/// <returns></returns>
public static IServiceProvider GetServiceProvider(
IRepositoryCloneService cloneService = null,
IRepositoryCreationService creationService = null,
IAvatarProvider avatarProvider = null)
{
var ret = Substitute.For <IServiceProvider, IUIProvider>();
var os = OperatingSystem;
var git = IGitRepositoriesExt;
var vs = IVSServices;
var clone = cloneService ?? new RepositoryCloneService(os, vs);
var create = creationService ?? new RepositoryCreationService(clone);
var hosts = RepositoryHosts;
var exports = ExportFactoryProvider;
var connection = Connection;
var connectionManager = ConnectionManager;
var twoFactorChallengeHandler = TwoFactorChallengeHandler;
avatarProvider = avatarProvider ?? Substitute.For <IAvatarProvider>();
ret.GetService(typeof(IGitRepositoriesExt)).Returns(git);
ret.GetService(typeof(IVSServices)).Returns(vs);
ret.GetService(typeof(IOperatingSystem)).Returns(os);
ret.GetService(typeof(IRepositoryCloneService)).Returns(clone);
ret.GetService(typeof(IRepositoryCreationService)).Returns(create);
ret.GetService(typeof(IRepositoryHosts)).Returns(hosts);
ret.GetService(typeof(IExportFactoryProvider)).Returns(exports);
ret.GetService(typeof(IConnection)).Returns(connection);
ret.GetService(typeof(IConnectionManager)).Returns(connectionManager);
ret.GetService(typeof(IAvatarProvider)).Returns(avatarProvider);
ret.GetService(typeof(ITwoFactorChallengeHandler)).Returns(twoFactorChallengeHandler);
return(ret);
}
/// <summary>
/// This returns a service provider with everything mocked except for
/// RepositoryCloneService and RepositoryCreationService, which are real
/// instances.
/// </summary>
/// <param name="cloneService"></param>
/// <param name="creationService"></param>
/// <returns></returns>
public static IServiceProvider GetServiceProvider(
IRepositoryCloneService cloneService = null,
IRepositoryCreationService creationService = null,
IAvatarProvider avatarProvider = null)
{
var ret = Substitute.For<IServiceProvider, IUIProvider>();
var gitservice = IGitService;
var cm = Substitute.For<SComponentModel, IComponentModel>();
var cc = new CompositionContainer(CompositionOptions.IsThreadSafe | CompositionOptions.DisableSilentRejection);
cc.ComposeExportedValue(gitservice);
((IComponentModel)cm).DefaultExportProvider.Returns(cc);
ret.GetService(typeof(SComponentModel)).Returns(cm);
var os = OperatingSystem;
var vs = IVSServices;
var clone = cloneService ?? new RepositoryCloneService(os, vs);
var create = creationService ?? new RepositoryCreationService(clone);
avatarProvider = avatarProvider ?? Substitute.For<IAvatarProvider>();
ret.GetService(typeof(IGitRepositoriesExt)).Returns(IGitRepositoriesExt);
ret.GetService(typeof(IGitService)).Returns(gitservice);
ret.GetService(typeof(IVSServices)).Returns(vs);
ret.GetService(typeof(IOperatingSystem)).Returns(os);
ret.GetService(typeof(IRepositoryCloneService)).Returns(clone);
ret.GetService(typeof(IRepositoryCreationService)).Returns(create);
ret.GetService(typeof(IRepositoryHosts)).Returns(RepositoryHosts);
ret.GetService(typeof(IExportFactoryProvider)).Returns(ExportFactoryProvider);
ret.GetService(typeof(IConnection)).Returns(Connection);
ret.GetService(typeof(IConnectionManager)).Returns(ConnectionManager);
ret.GetService(typeof(IAvatarProvider)).Returns(avatarProvider);
ret.GetService(typeof(ITwoFactorChallengeHandler)).Returns(TwoFactorChallengeHandler);
return ret;
}
public StartPageCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
{
this.operatingSystem = operatingSystem;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.Create(canCloneObservable);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public RepositoryRecloneViewModel(
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
{
Guard.ArgumentNotNull(cloneService, nameof(cloneService));
Guard.ArgumentNotNull(operatingSystem, nameof(operatingSystem));
this.operatingSystem = operatingSystem;
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.Create(() => { }, canCloneObservable);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public GitHubConnectSection(IGitHubServiceProvider serviceProvider,
ISimpleApiClientFactory apiFactory,
ITeamExplorerServiceHolder holder,
IConnectionManager manager,
IPackageSettings packageSettings,
IVSServices vsServices,
IRepositoryCloneService cloneService,
IDialogService dialogService,
int index)
: base(serviceProvider, apiFactory, holder, manager)
{
Title = "GitHub";
IsEnabled = true;
IsVisible = false;
LoggedIn = false;
sectionIndex = index;
this.packageSettings = packageSettings;
this.vsServices = vsServices;
this.cloneService = cloneService;
this.dialogService = dialogService;
Clone = CreateAsyncCommandHack(DoClone);
connectionManager.Connections.CollectionChanged += RefreshConnections;
PropertyChanged += OnPropertyChange;
UpdateConnection();
}
public RepositoryCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService)
{
this.repositoryHost = repositoryHost;
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.notificationService = notificationService;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
Repositories = new ReactiveList <IRepositoryModel>();
loadRepositoriesCommand = ReactiveCommand.CreateAsyncObservable(OnLoadRepositories);
isLoading = this.WhenAny(x => x.LoadingFailed, x => x.Value)
.CombineLatest(loadRepositoriesCommand.IsExecuting, (failed, loading) => !failed && loading)
.ToProperty(this, x => x.IsLoading);
loadRepositoriesCommand.Subscribe(Repositories.AddRange);
filterTextIsEnabled = this.WhenAny(x => x.Repositories.Count, x => x.Value > 0)
.ToProperty(this, x => x.FilterTextIsEnabled);
noRepositoriesFound = this.WhenAny(x => x.FilterTextIsEnabled, x => x.IsLoading, x => x.LoadingFailed
, (any, loading, failed) => !any.Value && !loading.Value && !failed.Value)
.ToProperty(this, x => x.NoRepositoriesFound);
var filterResetSignal = this.WhenAny(x => x.FilterText, x => x.Value)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler);
FilteredRepositories = Repositories.CreateDerivedCollection(
x => x,
filter: FilterRepository,
signalReset: filterResetSignal
);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty("Please enter a repository path")
.IfTrue(x => x.Length > 200, "Path too long")
.IfContainsInvalidPathChars("Path contains invalid characters")
.IfPathNotRooted("Please enter a valid path")
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public RepositoryCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService,
IUsageTracker usageTracker)
{
this.repositoryHost = repositoryHost;
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.notificationService = notificationService;
this.usageTracker = usageTracker;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
Repositories = new TrackingCollection<IRemoteRepositoryModel>();
repositories.ProcessingDelay = TimeSpan.Zero;
repositories.Comparer = OrderedComparer<IRemoteRepositoryModel>.OrderBy(x => x.Owner).ThenBy(x => x.Name).Compare;
repositories.Filter = FilterRepository;
repositories.NewerComparer = OrderedComparer<IRemoteRepositoryModel>.OrderByDescending(x => x.UpdatedAt).Compare;
filterTextIsEnabled = this.WhenAny(x => x.IsLoading,
loading => loading.Value || repositories.UnfilteredCount > 0 && !LoadingFailed)
.ToProperty(this, x => x.FilterTextIsEnabled);
this.WhenAny(x => x.IsLoading, x => x.LoadingFailed,
(loading, failed) => !loading.Value && !failed.Value && repositories.UnfilteredCount == 0)
.Subscribe(x => NoRepositoriesFound = x);
this.WhenAny(x => x.FilterText, x => x.Value)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler)
.Subscribe(_ => repositories.Filter = FilterRepository);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
NoRepositoriesFound = true;
}
public RepositoryCloneViewModel(
IGlobalConnection connection,
IModelServiceFactory modelServiceFactory,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
: this(connection.Get(), modelServiceFactory, cloneService, operatingSystem)
{
}
StartPageCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService,
IUsageTracker usageTracker)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem, notificationService, usageTracker)
{ }
RepositoryCloneViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IRepositoryCloneService repositoryCloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService,
IUsageTracker usageTracker)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, repositoryCloneService, operatingSystem, notificationService, usageTracker)
{
}
static RepositoryCloneViewModel GetVM(IRepositoryHost repositoryHost, IRepositoryCloneService cloneService,
IOperatingSystem os, INotificationService notificationService, IUsageTracker usageTracker)
{
var vm = new RepositoryCloneViewModel(
repositoryHost,
cloneService,
os);
vm.Initialize(null);
return(vm);
}
public GitHubConnectSection1(IGitHubServiceProvider serviceProvider,
ISimpleApiClientFactory apiFactory,
ITeamExplorerServiceHolder holder,
IConnectionManager manager,
IPackageSettings settings,
IVSServices vsServices,
IRepositoryCloneService cloneService,
IDialogService dialogService)
: base(serviceProvider, apiFactory, holder, manager, settings, vsServices, cloneService, dialogService, 1)
{
}
public RepositorySelectViewModel(IRepositoryCloneService service)
{
Guard.ArgumentNotNull(service, nameof(service));
this.service = service;
repository = this.WhenAnyValue(x => x.SelectedItem)
.Select(CreateRepository)
.ToProperty(this, x => x.Repository);
this.WhenAnyValue(x => x.Filter).Subscribe(_ => ItemsView?.Refresh());
}
public RepositoryCloneViewModel(
IOperatingSystem os,
IConnectionManager connectionManager,
IRepositoryCloneService service,
IGitService gitService,
IUsageTracker usageTracker,
IDialogService dialogService,
IRepositorySelectViewModel gitHubTab,
IRepositorySelectViewModel enterpriseTab)
{
this.os = os;
this.connectionManager = connectionManager;
this.service = service;
this.gitService = gitService;
this.usageTracker = usageTracker;
this.dialogService = dialogService;
GitHubTab = gitHubTab;
EnterpriseTab = enterpriseTab;
tabs = new IRepositoryCloneTabViewModel[] { GitHubTab, EnterpriseTab };
var repository = this.WhenAnyValue(x => x.SelectedTabIndex)
.SelectMany(x => tabs[x].WhenAnyValue(tab => tab.Repository));
Path = service.DefaultClonePath;
repository.Subscribe(x => UpdatePath(x));
pathWarning = Observable.CombineLatest(
repository,
this.WhenAnyValue(x => x.Path),
ValidatePathWarning)
.ToProperty(this, x => x.PathWarning);
var canClone = Observable.CombineLatest(
repository, this.WhenAnyValue(x => x.Path),
(repo, path) => repo != null && !service.DestinationFileExists(path) &&
(!service.DestinationDirectoryExists(path) || service.DestinationDirectoryEmpty(path)));
var canOpen = Observable.CombineLatest(
repository, this.WhenAnyValue(x => x.Path),
(repo, path) => repo != null && !service.DestinationFileExists(path) && service.DestinationDirectoryExists(path) &&
!service.DestinationDirectoryEmpty(path));
Browse = ReactiveCommand.Create(() => BrowseForDirectory());
Clone = ReactiveCommand.CreateFromObservable(
() => repository.Select(x => new CloneDialogResult(Path, x?.CloneUrl)),
canClone);
Open = ReactiveCommand.CreateFromObservable(
() => repository.Select(x => new CloneDialogResult(Path, x?.CloneUrl)),
canOpen);
LoginAsDifferentUser = ReactiveCommand.CreateFromTask(LoginAsDifferentUserAsync);
}
static RepositoryCloneViewModel GetVM(IRepositoryHost repositoryHost, IRepositoryCloneService cloneService,
IOperatingSystem os, INotificationService notificationService, IUsageTracker usageTracker)
{
var vm = new RepositoryCloneViewModel(
repositoryHost,
cloneService,
os,
notificationService,
usageTracker);
vm.Initialize(null);
return vm;
}
public RepositoryCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
IVSServices vsServices)
{
this.repositoryHost = repositoryHost;
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.vsServices = vsServices;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
Repositories = new ReactiveList <IRepositoryModel>();
loadRepositoriesCommand = ReactiveCommand.CreateAsyncObservable(OnLoadRepositories);
isLoading = this.WhenAny(x => x.LoadingFailed, x => x.Value)
.CombineLatest(loadRepositoriesCommand.IsExecuting, (failed, loading) => !failed && loading)
.ToProperty(this, x => x.IsLoading);
loadRepositoriesCommand.Subscribe(Repositories.AddRange);
filterTextIsEnabled = this.WhenAny(x => x.Repositories.Count, x => x.Value > 0)
.ToProperty(this, x => x.FilterTextIsEnabled);
noRepositoriesFound = this.WhenAny(x => x.FilterTextIsEnabled, x => x.IsLoading, x => x.LoadingFailed
, (any, loading, failed) => !any.Value && !loading.Value && !failed.Value)
.ToProperty(this, x => x.NoRepositoriesFound);
var filterResetSignal = this.WhenAny(x => x.FilterText, x => x.Value)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler);
FilteredRepositories = Repositories.CreateDerivedCollection(
x => x,
filter: FilterRepository,
signalReset: filterResetSignal
);
BaseRepositoryPathValidator = this.CreateBaseRepositoryPathValidator();
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
public RepositoryCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService)
{
this.repositoryHost = repositoryHost;
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.notificationService = notificationService;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
Repositories = new ReactiveList<IRepositoryModel>();
loadRepositoriesCommand = ReactiveCommand.CreateAsyncObservable(OnLoadRepositories);
isLoading = this.WhenAny(x => x.LoadingFailed, x => x.Value)
.CombineLatest(loadRepositoriesCommand.IsExecuting, (failed, loading) => !failed && loading)
.ToProperty(this, x => x.IsLoading);
loadRepositoriesCommand.Subscribe(Repositories.AddRange);
filterTextIsEnabled = this.WhenAny(x => x.Repositories.Count, x => x.Value > 0)
.ToProperty(this, x => x.FilterTextIsEnabled);
noRepositoriesFound = this.WhenAny(x => x.FilterTextIsEnabled, x => x.IsLoading, x => x.LoadingFailed
, (any, loading, failed) => !any.Value && !loading.Value && !failed.Value)
.ToProperty(this, x => x.NoRepositoriesFound);
var filterResetSignal = this.WhenAny(x => x.FilterText, x => x.Value)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler);
FilteredRepositories = Repositories.CreateDerivedCollection(
x => x,
filter: FilterRepository,
signalReset: filterResetSignal
);
BaseRepositoryPathValidator = this.CreateBaseRepositoryPathValidator();
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
static GitHubContainerProvider CreateGitHubContainerProvider(IDialogService dialogService = null,
IRepositoryCloneService cloneService = null, IUsageTracker usageTracker = null)
{
dialogService = dialogService ?? Substitute.For <IDialogService>();
cloneService = cloneService ?? Substitute.For <IRepositoryCloneService>();
usageTracker = usageTracker ?? Substitute.For <IUsageTracker>();
var sp = Substitute.For <IGitHubServiceProvider>();
sp.GetService <IDialogService>().Returns(dialogService);
sp.GetService <IRepositoryCloneService>().Returns(cloneService);
sp.GetService <IUsageTracker>().Returns(usageTracker);
var gitHubServiceProvider = new Lazy <IGitHubServiceProvider>(() => sp);
return(new GitHubContainerProvider(gitHubServiceProvider));
}
static OpenFromUrlCommand CreateOpenFromUrlCommand(
IDialogService dialogService = null,
IRepositoryCloneService repositoryCloneService = null,
ITeamExplorerContext teamExplorerContext = null,
IGitHubContextService gitHubContextService = null)
{
dialogService = dialogService ?? Substitute.For <IDialogService>();
repositoryCloneService = repositoryCloneService ?? Substitute.For <IRepositoryCloneService>();
teamExplorerContext = teamExplorerContext ?? Substitute.For <ITeamExplorerContext>();
gitHubContextService = gitHubContextService ?? Substitute.For <IGitHubContextService>();
return(new OpenFromUrlCommand(
new Lazy <IDialogService>(() => dialogService),
new Lazy <IRepositoryCloneService>(() => repositoryCloneService),
new Lazy <ITeamExplorerContext>(() => teamExplorerContext),
new Lazy <IGitHubContextService>(() => gitHubContextService)));
}
static RepositoryCloneViewModel GetVM(IModelService modelService, IRepositoryCloneService cloneService, IOperatingSystem os)
{
var connection = Substitute.For <IConnection>();
connection.HostAddress.Returns(HostAddress.GitHubDotComHostAddress);
var modelServiceFactory = Substitute.For <IModelServiceFactory>();
modelServiceFactory.CreateAsync(connection).Returns(modelService);
var vm = new RepositoryCloneViewModel(
modelServiceFactory,
cloneService,
os);
vm.InitializeAsync(connection).Wait();
return(vm);
}
/// <summary>
/// This returns a service provider with everything mocked except for
/// RepositoryCloneService and RepositoryCreationService, which are real
/// instances.
/// </summary>
/// <param name="cloneService"></param>
/// <param name="creationService"></param>
/// <returns></returns>
public static IGitHubServiceProvider GetServiceProvider(
IRepositoryCloneService cloneService = null,
IRepositoryCreationService creationService = null,
IAvatarProvider avatarProvider = null)
{
var ret = Substitute.For <IGitHubServiceProvider, IServiceProvider>();
var gitservice = IGitService;
var cm = Substitute.For <SComponentModel, IComponentModel>();
var cc = new CompositionContainer(CompositionOptions.IsThreadSafe | CompositionOptions.DisableSilentRejection);
cc.ComposeExportedValue(gitservice);
((IComponentModel)cm).DefaultExportProvider.Returns(cc);
ret.GetService(typeof(SComponentModel)).Returns(cm);
Services.UnitTestServiceProvider = ret;
var os = OperatingSystem;
var vsgit = IVSGitServices;
var clone = cloneService ?? new RepositoryCloneService(os, vsgit, Substitute.For <ITeamExplorerServices>(),
Substitute.For <IGraphQLClientFactory>(), Substitute.For <IGitHubContextService>(),
Substitute.For <IUsageTracker>(), ret);
var create = creationService ?? new RepositoryCreationService(clone);
avatarProvider = avatarProvider ?? Substitute.For <IAvatarProvider>();
ret.GetService(typeof(IGitService)).Returns(gitservice);
ret.GetService(typeof(IVSServices)).Returns(Substitute.For <IVSServices>());
ret.GetService(typeof(ITeamExplorerServices)).Returns(Substitute.For <ITeamExplorerServices>());
ret.GetService(typeof(IGraphQLClientFactory)).Returns(Substitute.For <IGraphQLClientFactory>());
ret.GetService(typeof(IGitHubContextService)).Returns(Substitute.For <IGitHubContextService>());
ret.GetService(typeof(IVSGitExt)).Returns(Substitute.For <IVSGitExt>());
ret.GetService(typeof(IUsageTracker)).Returns(Substitute.For <IUsageTracker>());
ret.GetService(typeof(IVSGitServices)).Returns(vsgit);
ret.GetService(typeof(IOperatingSystem)).Returns(os);
ret.GetService(typeof(IRepositoryCloneService)).Returns(clone);
ret.GetService(typeof(IRepositoryCreationService)).Returns(create);
ret.GetService(typeof(IViewViewModelFactory)).Returns(ViewViewModelFactory);
ret.GetService(typeof(IConnection)).Returns(Connection);
ret.GetService(typeof(IConnectionManager)).Returns(ConnectionManager);
ret.GetService(typeof(IAvatarProvider)).Returns(avatarProvider);
ret.GetService(typeof(IDelegatingTwoFactorChallengeHandler)).Returns(TwoFactorChallengeHandler);
ret.GetService(typeof(IGistPublishService)).Returns(GistPublishService);
ret.GetService(typeof(IPullRequestService)).Returns(PullRequestService);
return(ret);
}
public RepositoryCloneViewModel(
IOperatingSystem os,
IConnectionManager connectionManager,
IRepositoryCloneService service,
IUsageService usageService,
IUsageTracker usageTracker,
IRepositorySelectViewModel gitHubTab,
IRepositorySelectViewModel enterpriseTab,
IRepositoryUrlViewModel urlTab)
{
this.os = os;
this.connectionManager = connectionManager;
this.service = service;
this.usageService = usageService;
this.usageTracker = usageTracker;
GitHubTab = gitHubTab;
EnterpriseTab = enterpriseTab;
UrlTab = urlTab;
tabs = new IRepositoryCloneTabViewModel[] { GitHubTab, EnterpriseTab, UrlTab };
var repository = this.WhenAnyValue(x => x.SelectedTabIndex)
.SelectMany(x => tabs[x].WhenAnyValue(tab => tab.Repository));
Path = service.DefaultClonePath;
repository.Subscribe(x => UpdatePath(x));
pathError = Observable.CombineLatest(
repository,
this.WhenAnyValue(x => x.Path),
ValidatePath)
.ToProperty(this, x => x.PathError);
var canClone = Observable.CombineLatest(
repository,
this.WhenAnyValue(x => x.PathError),
(repo, error) => (repo, error))
.Select(x => x.repo != null && x.error == null);
Browse = ReactiveCommand.Create().OnExecuteCompleted(_ => BrowseForDirectory());
Clone = ReactiveCommand.CreateAsyncObservable(
canClone,
_ => repository.Select(x => new CloneDialogResult(Path, x)));
}
public RepositorySelectViewModel(IRepositoryCloneService service, IGitHubContextService gitHubContextService)
{
Guard.ArgumentNotNull(service, nameof(service));
Guard.ArgumentNotNull(service, nameof(gitHubContextService));
this.service = service;
this.gitHubContextService = gitHubContextService;
var selectedRepository = this.WhenAnyValue(x => x.SelectedItem)
.Select(CreateRepository);
var filterRepository = this.WhenAnyValue(x => x.Filter)
.Select(f => gitHubContextService.FindContextFromUrl(f))
.Select(CreateRepository);
repository = selectedRepository
.Merge(filterRepository)
.ToProperty(this, x => x.Repository);
this.WhenAnyValue(x => x.Filter).Subscribe(_ => ItemsView?.Refresh());
}
public GitHubConnectSection(IGitHubServiceProvider serviceProvider,
ISimpleApiClientFactory apiFactory,
ITeamExplorerServiceHolder holder,
IConnectionManager manager,
IPackageSettings packageSettings,
IVSServices vsServices,
IRepositoryCloneService cloneService,
IDialogService dialogService,
ILocalRepositories localRepositories,
int index)
: base(serviceProvider, apiFactory, holder, manager)
{
Guard.ArgumentNotNull(apiFactory, nameof(apiFactory));
Guard.ArgumentNotNull(holder, nameof(holder));
Guard.ArgumentNotNull(manager, nameof(manager));
Guard.ArgumentNotNull(packageSettings, nameof(packageSettings));
Guard.ArgumentNotNull(vsServices, nameof(vsServices));
Guard.ArgumentNotNull(cloneService, nameof(cloneService));
Guard.ArgumentNotNull(dialogService, nameof(dialogService));
Guard.ArgumentNotNull(localRepositories, nameof(localRepositories));
Title = "GitHub";
IsEnabled = true;
IsVisible = false;
LoggedIn = false;
sectionIndex = index;
this.packageSettings = packageSettings;
this.vsServices = vsServices;
this.cloneService = cloneService;
this.dialogService = dialogService;
this.localRepositories = localRepositories;
Clone = CreateAsyncCommandHack(DoClone);
connectionManager.Connections.CollectionChanged += RefreshConnections;
PropertyChanged += OnPropertyChange;
UpdateConnection();
}
public StartPageCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService,
IUsageTracker usageTracker)
{
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.notificationService = notificationService;
this.usageTracker = usageTracker;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
}
static RepositoryCloneViewModel CreateTarget(
IOperatingSystem os = null,
IConnectionManager connectionManager = null,
IRepositoryCloneService service = null,
IRepositorySelectViewModel gitHubTab = null,
IRepositorySelectViewModel enterpriseTab = null,
IRepositoryUrlViewModel urlTab = null)
{
os = os ?? Substitute.For <IOperatingSystem>();
connectionManager = connectionManager ?? CreateConnectionManager("https://github.com");
service = service ?? CreateRepositoryCloneService();
gitHubTab = gitHubTab ?? CreateSelectViewModel();
enterpriseTab = enterpriseTab ?? CreateSelectViewModel();
urlTab = urlTab ?? Substitute.For <IRepositoryUrlViewModel>();
return(new RepositoryCloneViewModel(
os,
connectionManager,
service,
gitHubTab,
enterpriseTab,
urlTab));
}
public RepositoryCloneViewModel(
IConnection connection,
IModelServiceFactory modelServiceFactory,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem)
{
Guard.ArgumentNotNull(connection, nameof(connection));
Guard.ArgumentNotNull(modelServiceFactory, nameof(modelServiceFactory));
Guard.ArgumentNotNull(cloneService, nameof(cloneService));
Guard.ArgumentNotNull(operatingSystem, nameof(operatingSystem));
this.connection = connection;
this.modelServiceFactory = modelServiceFactory;
this.operatingSystem = operatingSystem;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, connection.HostAddress.Title);
Repositories = new TrackingCollection <IRemoteRepositoryModel>();
repositories.ProcessingDelay = TimeSpan.Zero;
repositories.Comparer = OrderedComparer <IRemoteRepositoryModel> .OrderBy(x => x.Owner).ThenBy(x => x.Name).Compare;
repositories.Filter = FilterRepository;
repositories.NewerComparer = OrderedComparer <IRemoteRepositoryModel> .OrderByDescending(x => x.UpdatedAt).Compare;
filterTextIsEnabled = this.WhenAny(x => x.IsBusy,
loading => loading.Value || repositories.UnfilteredCount > 0 && !LoadingFailed)
.ToProperty(this, x => x.FilterTextIsEnabled);
this.WhenAny(
x => x.repositories.UnfilteredCount,
x => x.IsBusy,
x => x.LoadingFailed,
(unfilteredCount, loading, failed) =>
{
if (loading.Value)
{
return(false);
}
if (failed.Value)
{
return(false);
}
return(unfilteredCount.Value == 0);
})
.Subscribe(x =>
{
NoRepositoriesFound = x;
});
this.WhenAny(x => x.FilterText, x => x.Value)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler)
.Subscribe(_ => repositories.Filter = FilterRepository);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.Create(canCloneObservable);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
NoRepositoriesFound = true;
}
public RepositoryCreationService(IRepositoryCloneService cloneService)
{
this.cloneService = cloneService;
}
public RepositoryCreationService(IRepositoryCloneService cloneService)
{
this.cloneService = cloneService;
}
public RepositoryCloneViewModel(
IRepositoryHost repositoryHost,
IRepositoryCloneService cloneService,
IOperatingSystem operatingSystem,
INotificationService notificationService,
IUsageTracker usageTracker)
{
this.repositoryHost = repositoryHost;
this.cloneService = cloneService;
this.operatingSystem = operatingSystem;
this.notificationService = notificationService;
this.usageTracker = usageTracker;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CloneTitle, repositoryHost.Title);
Repositories = new TrackingCollection <IRepositoryModel>();
repositories.ProcessingDelay = TimeSpan.Zero;
repositories.Comparer = OrderedComparer <IRepositoryModel> .OrderBy(x => x.Owner).ThenBy(x => x.Name).Compare;
repositories.Filter = FilterRepository;
repositories.NewerComparer = OrderedComparer <IRepositoryModel> .OrderByDescending(x => x.UpdatedAt).Compare;
filterTextIsEnabled = this.WhenAny(x => x.IsLoading, x => x.Value)
.Select(x => !x && repositories.UnfilteredCount > 0)
.ToProperty(this, x => x.FilterTextIsEnabled);
this.WhenAny(x => x.FilterTextIsEnabled, x => x.IsLoading, x => x.LoadingFailed
, (any, loading, failed) => !any.Value && !loading.Value && !failed.Value)
.Subscribe(x => NoRepositoriesFound = x);
this.WhenAny(x => x.FilterText, x => x.Value)
.DistinctUntilChanged(StringComparer.OrdinalIgnoreCase)
.Throttle(TimeSpan.FromMilliseconds(100), RxApp.MainThreadScheduler)
.Subscribe(_ => repositories.Filter = FilterRepository);
var baseRepositoryPath = this.WhenAny(
x => x.BaseRepositoryPath,
x => x.SelectedRepository,
(x, y) => x.Value);
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(baseRepositoryPath)
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
var canCloneObservable = this.WhenAny(
x => x.SelectedRepository,
x => x.BaseRepositoryPathValidator.ValidationResult.IsValid,
(x, y) => x.Value != null && y.Value);
canClone = canCloneObservable.ToProperty(this, x => x.CanClone);
CloneCommand = ReactiveCommand.CreateAsyncObservable(canCloneObservable, OnCloneRepository);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
BaseRepositoryPath = cloneService.DefaultClonePath;
NoRepositoriesFound = true;
}
