static IRepositoryCreationViewModel GetMeAViewModel(
IServiceProvider provider = null,
IRepositoryCreationService creationService = null,
IModelService modelService = null)
{
if (provider == null)
{
provider = Substitutes.ServiceProvider;
}
var os = provider.GetOperatingSystem();
creationService = creationService ?? provider.GetRepositoryCreationService();
var avatarProvider = provider.GetAvatarProvider();
var connection = provider.GetConnection();
connection.HostAddress.Returns(HostAddress.GitHubDotComHostAddress);
var usageTracker = Substitute.For <IUsageTracker>();
modelService = modelService ?? Substitute.For <IModelService>();
var factory = GetMeAFactory(modelService);
var vm = new RepositoryCreationViewModel(factory, os, creationService, usageTracker);
vm.InitializeAsync(connection).Wait();
return(vm);
}
RepositoryCreationViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IAvatarProvider avatarProvider)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, operatingSystem, repositoryCreationService, avatarProvider)
{}
/// <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 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(IGitService);
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;
}
/// <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);
}
/// <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;
}
RepositoryCreationViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, operatingSystem, repositoryCreationService)
{
}
/// <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);
}
RepositoryCreationViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, operatingSystem, repositoryCreationService, usageTracker)
{}
public RepositoryCreationViewModel(
IModelServiceFactory modelServiceFactory,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
{
Guard.ArgumentNotNull(modelServiceFactory, nameof(modelServiceFactory));
Guard.ArgumentNotNull(operatingSystem, nameof(operatingSystem));
Guard.ArgumentNotNull(repositoryCreationService, nameof(repositoryCreationService));
Guard.ArgumentNotNull(usageTracker, nameof(usageTracker));
this.modelServiceFactory = modelServiceFactory;
this.operatingSystem = operatingSystem;
this.repositoryCreationService = repositoryCreationService;
this.usageTracker = usageTracker;
SelectedGitIgnoreTemplate = GitIgnoreItem.None;
SelectedLicense = LicenseItem.None;
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(this.WhenAny(x => x.BaseRepositoryPath, x => x.Value))
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid);
var nonNullRepositoryName = this.WhenAny(
x => x.RepositoryName,
x => x.BaseRepositoryPath,
(x, y) => x.Value)
.WhereNotNull();
RepositoryNameValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.IfNullOrEmpty(Resources.RepositoryNameValidatorEmpty)
.IfTrue(x => x.Length > 100, Resources.RepositoryNameValidatorTooLong)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
SafeRepositoryNameWarningValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.Add(repoName =>
{
var parsedReference = GetSafeRepositoryName(repoName);
return(parsedReference != repoName ? String.Format(CultureInfo.CurrentCulture, Resources.SafeRepositoryNameWarning, parsedReference) : null);
});
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
CreateRepository = InitializeCreateRepositoryCommand();
canKeepPrivate = CanKeepPrivateObservable.CombineLatest(CreateRepository.IsExecuting,
(canKeep, publishing) => canKeep && !publishing)
.ToProperty(this, x => x.CanKeepPrivate);
isCreating = CreateRepository.IsExecuting
.ToProperty(this, x => x.IsCreating);
BaseRepositoryPath = repositoryCreationService.DefaultClonePath;
}
RepositoryCreationViewModel(
IConnectionRepositoryHostMap connectionRepositoryHostMap,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IAvatarProvider avatarProvider)
: this(connectionRepositoryHostMap.CurrentRepositoryHost, operatingSystem, repositoryCreationService, avatarProvider)
{
}
public RepositoryCreationViewModel(
IGlobalConnection connection,
IModelServiceFactory modelServiceFactory,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
: this(connection.Get(), modelServiceFactory, operatingSystem, repositoryCreationService, usageTracker)
{
}
static IRepositoryCreationViewModel GetMeAViewModel(
IServiceProvider provider = null,
IRepositoryCreationService creationService = null)
{
if (provider == null)
provider = Substitutes.ServiceProvider;
var repositoryHost = provider.GetRepositoryHosts().GitHubHost;
var os = provider.GetOperatingSystem();
creationService = creationService ?? provider.GetRepositoryCreationService();
var avatarProvider = provider.GetAvatarProvider();
var connection = provider.GetConnection();
return new RepositoryCreationViewModel(repositoryHost, os, creationService, avatarProvider);
}
static IRepositoryCreationViewModel GetMeAViewModel(
IServiceProvider provider = null,
IRepositoryCreationService creationService = null)
{
if (provider == null)
{
provider = Substitutes.ServiceProvider;
}
var repositoryHost = provider.GetRepositoryHosts().GitHubHost;
var os = provider.GetOperatingSystem();
creationService = creationService ?? provider.GetRepositoryCreationService();
var avatarProvider = provider.GetAvatarProvider();
var connection = provider.GetConnection();
return(new RepositoryCreationViewModel(repositoryHost, os, creationService, avatarProvider));
}
/// <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 RepositoryCreationViewModel(
IConnection connection,
IModelServiceFactory modelServiceFactory,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
{
Guard.ArgumentNotNull(connection, nameof(connection));
Guard.ArgumentNotNull(modelServiceFactory, nameof(modelServiceFactory));
Guard.ArgumentNotNull(operatingSystem, nameof(operatingSystem));
Guard.ArgumentNotNull(repositoryCreationService, nameof(repositoryCreationService));
Guard.ArgumentNotNull(usageTracker, nameof(usageTracker));
this.operatingSystem = operatingSystem;
this.repositoryCreationService = repositoryCreationService;
this.usageTracker = usageTracker;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CreateTitle, connection.HostAddress.Title);
SelectedGitIgnoreTemplate = GitIgnoreItem.None;
SelectedLicense = LicenseItem.None;
modelService = modelServiceFactory.CreateBlocking(connection);
accounts = modelService.GetAccounts()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, vm => vm.Accounts, initialValue: new ReadOnlyCollection <IAccount>(new IAccount[] {}));
this.WhenAny(x => x.Accounts, x => x.Value)
.Select(accts => accts?.FirstOrDefault())
.WhereNotNull()
.Subscribe(a => SelectedAccount = a);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(this.WhenAny(x => x.BaseRepositoryPath, x => x.Value))
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid);
var nonNullRepositoryName = this.WhenAny(
x => x.RepositoryName,
x => x.BaseRepositoryPath,
(x, y) => x.Value)
.WhereNotNull();
RepositoryNameValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.IfNullOrEmpty(Resources.RepositoryNameValidatorEmpty)
.IfTrue(x => x.Length > 100, Resources.RepositoryNameValidatorTooLong)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
SafeRepositoryNameWarningValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.Add(repoName =>
{
var parsedReference = GetSafeRepositoryName(repoName);
return(parsedReference != repoName ? String.Format(CultureInfo.CurrentCulture, Resources.SafeRepositoryNameWarning, parsedReference) : null);
});
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
CreateRepository = InitializeCreateRepositoryCommand();
canKeepPrivate = CanKeepPrivateObservable.CombineLatest(CreateRepository.IsExecuting,
(canKeep, publishing) => canKeep && !publishing)
.ToProperty(this, x => x.CanKeepPrivate);
isCreating = CreateRepository.IsExecuting
.ToProperty(this, x => x.IsCreating);
GitIgnoreTemplates = TrackingCollection.CreateListenerCollectionAndRun(
modelService.GetGitIgnoreTemplates(),
new[] { GitIgnoreItem.None },
OrderedComparer <GitIgnoreItem> .OrderByDescending(item => GitIgnoreItem.IsRecommended(item.Name)).Compare,
x =>
{
if (x.Name.Equals("VisualStudio", StringComparison.OrdinalIgnoreCase))
{
SelectedGitIgnoreTemplate = x;
}
});
Licenses = TrackingCollection.CreateListenerCollectionAndRun(
modelService.GetLicenses(),
new[] { LicenseItem.None },
OrderedComparer <LicenseItem> .OrderByDescending(item => LicenseItem.IsRecommended(item.Name)).Compare);
BaseRepositoryPath = repositoryCreationService.DefaultClonePath;
}
public RepositoryCreationViewModel(
IRepositoryHost repositoryHost,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IAvatarProvider avatarProvider)
{
this.repositoryHost = repositoryHost;
this.operatingSystem = operatingSystem;
this.repositoryCreationService = repositoryCreationService;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CreateTitle, repositoryHost.Title);
SelectedGitIgnoreTemplate = GitIgnoreItem.None;
SelectedLicense = LicenseItem.None;
accounts = repositoryHost.ModelService.GetAccounts()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, vm => vm.Accounts, initialValue: new ReadOnlyCollection <IAccount>(new IAccount[] {}));
this.WhenAny(x => x.Accounts, x => x.Value)
.WhereNotNull()
.Where(accts => accts.Any())
.Subscribe(accts => {
var selectedAccount = accts.FirstOrDefault();
if (selectedAccount != null)
{
SelectedAccount = accts.FirstOrDefault();
}
});
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
BaseRepositoryPathValidator = this.CreateBaseRepositoryPathValidator();
var nonNullRepositoryName = this.WhenAny(
x => x.RepositoryName,
x => x.BaseRepositoryPath,
(x, y) => x.Value)
.WhereNotNull();
RepositoryNameValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.IfNullOrEmpty(Resources.RepositoryNameValidatorEmpty)
.IfTrue(x => x.Length > 100, Resources.RepositoryNameValidatorTooLong)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
SafeRepositoryNameWarningValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.Add(repoName =>
{
var parsedReference = GetSafeRepositoryName(repoName);
return(parsedReference != repoName ? String.Format(CultureInfo.CurrentCulture, Resources.SafeRepositoryNameWarning, parsedReference) : null);
});
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
CreateRepository = InitializeCreateRepositoryCommand();
canKeepPrivate = CanKeepPrivateObservable.CombineLatest(CreateRepository.IsExecuting,
(canKeep, publishing) => canKeep && !publishing)
.ToProperty(this, x => x.CanKeepPrivate);
isCreating = CreateRepository.IsExecuting
.ToProperty(this, x => x.IsCreating);
gitIgnoreTemplates = repositoryHost.ModelService.GetGitIgnoreTemplates()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, x => x.GitIgnoreTemplates, initialValue: new GitIgnoreItem[] { });
this.WhenAny(x => x.GitIgnoreTemplates, x => x.Value)
.WhereNotNull()
.Where(ignores => ignores.Any())
.Subscribe(ignores =>
{
SelectedGitIgnoreTemplate = ignores.FirstOrDefault(
template => template.Name.Equals("VisualStudio", StringComparison.OrdinalIgnoreCase));
});
licenses = repositoryHost.ModelService.GetLicenses()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, x => x.Licenses, initialValue: new LicenseItem[] { });
BaseRepositoryPath = repositoryCreationService.DefaultClonePath;
}
public RepositoryCreationViewModel(
IRepositoryHost repositoryHost,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IUsageTracker usageTracker)
{
this.repositoryHost = repositoryHost;
this.operatingSystem = operatingSystem;
this.repositoryCreationService = repositoryCreationService;
this.usageTracker = usageTracker;
Title = string.Format(CultureInfo.CurrentCulture, Resources.CreateTitle, repositoryHost.Title);
SelectedGitIgnoreTemplate = GitIgnoreItem.None;
SelectedLicense = LicenseItem.None;
accounts = repositoryHost.ModelService.GetAccounts()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, vm => vm.Accounts, initialValue: new ReadOnlyCollection<IAccount>(new IAccount[] {}));
this.WhenAny(x => x.Accounts, x => x.Value)
.Select(accts => accts?.FirstOrDefault())
.WhereNotNull()
.Subscribe(a => SelectedAccount = a);
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
BaseRepositoryPathValidator = ReactivePropertyValidator.ForObservable(this.WhenAny(x => x.BaseRepositoryPath, x => x.Value))
.IfNullOrEmpty(Resources.RepositoryCreationClonePathEmpty)
.IfTrue(x => x.Length > 200, Resources.RepositoryCreationClonePathTooLong)
.IfContainsInvalidPathChars(Resources.RepositoryCreationClonePathInvalidCharacters)
.IfPathNotRooted(Resources.RepositoryCreationClonePathInvalid);
var nonNullRepositoryName = this.WhenAny(
x => x.RepositoryName,
x => x.BaseRepositoryPath,
(x, y) => x.Value)
.WhereNotNull();
RepositoryNameValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.IfNullOrEmpty(Resources.RepositoryNameValidatorEmpty)
.IfTrue(x => x.Length > 100, Resources.RepositoryNameValidatorTooLong)
.IfTrue(IsAlreadyRepoAtPath, Resources.RepositoryNameValidatorAlreadyExists);
SafeRepositoryNameWarningValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.Add(repoName =>
{
var parsedReference = GetSafeRepositoryName(repoName);
return parsedReference != repoName ? String.Format(CultureInfo.CurrentCulture, Resources.SafeRepositoryNameWarning, parsedReference) : null;
});
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
CreateRepository = InitializeCreateRepositoryCommand();
canKeepPrivate = CanKeepPrivateObservable.CombineLatest(CreateRepository.IsExecuting,
(canKeep, publishing) => canKeep && !publishing)
.ToProperty(this, x => x.CanKeepPrivate);
isCreating = CreateRepository.IsExecuting
.ToProperty(this, x => x.IsCreating);
GitIgnoreTemplates = TrackingCollection.CreateListenerCollectionAndRun(
repositoryHost.ModelService.GetGitIgnoreTemplates(),
new[] { GitIgnoreItem.None },
OrderedComparer<GitIgnoreItem>.OrderByDescending(item => GitIgnoreItem.IsRecommended(item.Name)).Compare,
x =>
{
if (x.Name.Equals("VisualStudio", StringComparison.OrdinalIgnoreCase))
SelectedGitIgnoreTemplate = x;
});
Licenses = TrackingCollection.CreateListenerCollectionAndRun(
repositoryHost.ModelService.GetLicenses(),
new[] { LicenseItem.None },
OrderedComparer<LicenseItem>.OrderByDescending(item => LicenseItem.IsRecommended(item.Name)).Compare);
BaseRepositoryPath = repositoryCreationService.DefaultClonePath;
}
public RepositoryCreationViewModel(
IRepositoryHost repositoryHost,
IOperatingSystem operatingSystem,
IRepositoryCreationService repositoryCreationService,
IAvatarProvider avatarProvider)
{
this.repositoryHost = repositoryHost;
this.operatingSystem = operatingSystem;
this.repositoryCreationService = repositoryCreationService;
Title = string.Format(CultureInfo.CurrentCulture, "Create a {0} Repository", repositoryHost.Title);
SelectedGitIgnoreTemplate = GitIgnoreItem.None;
SelectedLicense = LicenseItem.None;
accounts = repositoryHost.ModelService.GetAccounts()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, vm => vm.Accounts, initialValue: new ReadOnlyCollection<IAccount>(new IAccount[] {}));
this.WhenAny(x => x.Accounts, x => x.Value)
.WhereNotNull()
.Where(accts => accts.Any())
.Subscribe(accts => {
var selectedAccount = accts.FirstOrDefault();
if (selectedAccount != null)
{
SelectedAccount = accts.FirstOrDefault();
}
});
browseForDirectoryCommand.Subscribe(_ => ShowBrowseForDirectoryDialog());
BaseRepositoryPathValidator = this.CreateBaseRepositoryPathValidator();
var nonNullRepositoryName = this.WhenAny(
x => x.RepositoryName,
x => x.BaseRepositoryPath,
(x, y) => x.Value)
.WhereNotNull();
RepositoryNameValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.IfNullOrEmpty("Please enter a repository name")
.IfTrue(x => x.Length > 100, "Repository name must be fewer than 100 characters")
.IfTrue(IsAlreadyRepoAtPath, "Repository with same name already exists at this location");
SafeRepositoryNameWarningValidator = ReactivePropertyValidator.ForObservable(nonNullRepositoryName)
.Add(repoName =>
{
var parsedReference = GetSafeRepositoryName(repoName);
return parsedReference != repoName ? "Will be created as " + parsedReference : null;
});
this.WhenAny(x => x.BaseRepositoryPathValidator.ValidationResult, x => x.Value)
.Subscribe();
CreateRepository = InitializeCreateRepositoryCommand();
canKeepPrivate = CanKeepPrivateObservable.CombineLatest(CreateRepository.IsExecuting,
(canKeep, publishing) => canKeep && !publishing)
.ToProperty(this, x => x.CanKeepPrivate);
isCreating = CreateRepository.IsExecuting
.ToProperty(this, x => x.IsCreating);
gitIgnoreTemplates = repositoryHost.ModelService.GetGitIgnoreTemplates()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, x => x.GitIgnoreTemplates, initialValue: new GitIgnoreItem[] { });
this.WhenAny(x => x.GitIgnoreTemplates, x => x.Value)
.WhereNotNull()
.Where(ignores => ignores.Any())
.Subscribe(ignores =>
{
SelectedGitIgnoreTemplate = ignores.FirstOrDefault(
template => template.Name.Equals("VisualStudio", StringComparison.OrdinalIgnoreCase));
});
licenses = repositoryHost.ModelService.GetLicenses()
.ObserveOn(RxApp.MainThreadScheduler)
.ToProperty(this, x => x.Licenses, initialValue: new LicenseItem[] { });
BaseRepositoryPath = repositoryCreationService.DefaultClonePath;
}
