/// <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;
}
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 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 virtual void SetUp()
{
_inner = Substitute.For <IAvatarProvider>();
_inner.GetAvatarAsync(_email1, _name1, _size).Returns(Task.FromResult(_img1));
_inner.GetAvatarAsync(_email2, _name2, _size).Returns(Task.FromResult(_img2));
_inner.GetAvatarAsync(_email3, _name3, _size).Returns(Task.FromResult(_img3));
_inner.GetAvatarAsync(_email4, _name4, _size).Returns(Task.FromResult(_img4));
_inner.GetAvatarAsync(_emailMissing, _nameMissing, _size).Returns(Task.FromResult((Image)null));
}
public ModelServiceFactory(
IApiClientFactory apiClientFactory,
IGraphQLClientFactory graphQLClientFactory,
IHostCacheFactory hostCacheFactory,
IAvatarProvider avatarProvider)
{
this.apiClientFactory = apiClientFactory;
this.graphQLClientFactory = graphQLClientFactory;
this.hostCacheFactory = hostCacheFactory;
this.avatarProvider = avatarProvider;
}
public ModelService(
IApiClient apiClient,
Octokit.GraphQL.IConnection graphql,
IBlobCache hostCache,
IAvatarProvider avatarProvider)
{
this.ApiClient = apiClient;
this.graphql = graphql;
this.hostCache = hostCache;
this.avatarProvider = avatarProvider;
}
static ModelService CreateTarget(
IApiClient apiClient = null,
Octokit.IConnection graphql = null,
IBlobCache hostCache = null,
IAvatarProvider avatarProvider = null)
{
return(new ModelService(
apiClient ?? Substitute.For <IApiClient>(),
hostCache ?? new InMemoryBlobCache(),
Substitute.For <IAvatarProvider>()));
}
public ModelServiceFactory(
IApiClientFactory apiClientFactory,
IHostCacheFactory hostCacheFactory,
IAvatarProvider avatarProvider,
[Import(AllowDefault = true)] JoinableTaskContext joinableTaskContext)
{
this.apiClientFactory = apiClientFactory;
this.hostCacheFactory = hostCacheFactory;
this.avatarProvider = avatarProvider;
JoinableTaskContext = joinableTaskContext ?? ThreadHelper.JoinableTaskContext;
}
public MentionsAutoCompleteSource(
ITeamExplorerContext teamExplorerContext,
IGraphQLClientFactory graphqlFactory,
IAvatarProvider avatarProvider)
{
Guard.ArgumentNotNull(teamExplorerContext, nameof(teamExplorerContext));
Guard.ArgumentNotNull(graphqlFactory, nameof(graphqlFactory));
Guard.ArgumentNotNull(avatarProvider, nameof(avatarProvider));
this.teamExplorerContext = teamExplorerContext;
this.graphqlFactory = graphqlFactory;
this.avatarProvider = avatarProvider;
}
public static void StartInitialization()
{
lock (initSyncMutex)
{
InitAvatarSdkMgrIfNeeded();
if (!IsInitialized && !IsInitializationInProgress)
{
avatarProvider = AvatarSdkMgr.IoCContainer.Create <IAvatarProvider>();
initRoutine = EditorRunner.instance.Run(InitRoutine());
}
}
}
public RepositoryHostFactory(
IApiClientFactory apiClientFactory,
IHostCacheFactory hostCacheFactory,
ILoginCache loginCache,
IAvatarProvider avatarProvider,
ITwoFactorChallengeHandler twoFactorChallengeHandler)
{
this.apiClientFactory = apiClientFactory;
this.hostCacheFactory = hostCacheFactory;
this.loginCache = loginCache;
this.avatarProvider = avatarProvider;
this.twoFactorChallengeHandler = twoFactorChallengeHandler;
}
public RepositoryHostFactory(
IApiClientFactory apiClientFactory,
IHostCacheFactory hostCacheFactory,
ILoginCache loginCache,
IAvatarProvider avatarProvider,
ITwoFactorChallengeHandler twoFactorChallengeHandler)
{
this.apiClientFactory = apiClientFactory;
this.hostCacheFactory = hostCacheFactory;
this.loginCache = loginCache;
this.avatarProvider = avatarProvider;
this.twoFactorChallengeHandler = twoFactorChallengeHandler;
}
private IEnumerator Initialize()
{
// First of all, initialize the SDK. This sample shows how to provide user-defined implementations for
// the interfaces if needed. If you don't need to override the default behavior, just pass null instead.
if (!AvatarSdkMgr.IsInitialized)
{
AvatarSdkMgr.Init(
stringMgr: stringManager,
storage: persistentStorage,
sdkType: sdkType
);
}
GameObject providerContainerGameObject = GameObject.Find("AvatarProviderContainer");
if (providerContainerGameObject != null)
{
avatarProvider = providerContainerGameObject.GetComponent <AvatarProviderContainer>().avatarProvider;
}
else
{
// Initialization of the IAvatarProvider may take some time.
// We don't want to initialize it each time when the Gallery scene is loaded.
// So we store IAvatarProvider instance in the object that will not destroyed during navigation between the scenes (Gallery -> ModelViewer -> Gallery).
providerContainerGameObject = new GameObject("AvatarProviderContainer");
DontDestroyOnLoad(providerContainerGameObject);
AvatarProviderContainer providerContainer = providerContainerGameObject.AddComponent <AvatarProviderContainer>();
avatarProvider = AvatarSdkMgr.IoCContainer.Create <IAvatarProvider>();
providerContainer.avatarProvider = avatarProvider;
var initializeRequest = InitializeAvatarProviderAsync();
yield return(Await(initializeRequest, null));
if (initializeRequest.IsError)
{
Debug.LogError("Avatar provider isn't initialized!");
yield break;
}
}
yield return(UpdateAvatarList());
// disable generation buttons until avatar provider initializes
foreach (var button in galleryControls.GetComponentsInChildren <Button>(false))
{
if (button.name.Contains("Generate"))
{
button.interactable = true;
}
}
}
public RepositoryHostFactory(
IApiClientFactory apiClientFactory,
IHostCacheFactory hostCacheFactory,
ILoginManager loginManager,
ILoginCache loginCache,
IAvatarProvider avatarProvider,
IUsageTracker usage)
{
this.apiClientFactory = apiClientFactory;
this.hostCacheFactory = hostCacheFactory;
this.loginManager = loginManager;
this.loginCache = loginCache;
this.avatarProvider = avatarProvider;
this.usage = usage;
}
public static void StartInitialization()
{
lock (initSyncMutex)
{
if (!AvatarSdkMgr.IsInitialized)
{
Debug.Log("AvatarSdkMgr.Init");
AvatarSdkMgr.Init(sdkType: SdkType.Offline);
}
if (!IsInitialized && !IsInitializationInProgress)
{
avatarProvider = AvatarSdkMgr.IoCContainer.Create <IAvatarProvider>();
initRoutine = EditorRunner.instance.Run(InitRoutine());
}
}
}
void Start()
{
Screen.fullScreen = false;
Screen.orientation = ScreenOrientation.Portrait;
AppSocket.SetOnReceiveHandler(OnReceive);
if (!AvatarSdkMgr.IsInitialized)
{
AvatarSdkMgr.Init();
}
avatarProvider = AvatarSdkMgr.IoCContainer.Create <IAvatarProvider>();
QualitySettings.antiAliasing = 2;
AppSocket.SendCommand(AppSocket.SendType.UNITY_LOADED);
if (Application.platform != RuntimePlatform.Android)
{
QualitySettings.antiAliasing = 8;
String marcoBody = "mech_ferrari";
String marcoAvatar = "3907ed35-7071-4ed1-b242-169cb3abc237";
String marcoHair = "male_NewSea_J082m";
String marcoHairColor = "#3E271F";
String paolaBody = "sport_female_m";
String paolaAvatar = "7d910c92-b62c-4084-8f42-749a2cb94eb2";
String paolaHair = "female_NewSea_J096f";
String paolaHairColor = "#202020";
String aliceBody = "medic_female";
String aliceAvatar = "063f8e92-4675-4bee-8f4f-a303779b4e3c";
String aliceHair = "female_NewSea_J123f";
String aliceHairColor = "#3E271F";
if (playerObj != null)
{
CreateAvatar("b7ce00b9-3589-4dbd-9b5b-2466233e9d89", paolaAvatar, paolaHair, paolaHairColor);
}
else
{
CreateAvatar("b7ce00b9-3589-4dbd-9b5b-2466233e9d89", marcoBody, marcoAvatar, marcoHair, marcoHairColor);
}
}
}
private void OnEnable()
{
if (!AvatarMakerInitializer.IsPlatformSupported())
{
Debug.LogError("Avatar plugin supports only Windows platform and works in the Editor mode.");
return;
}
if (!AvatarMakerInitializer.IsInitialized)
{
AvatarMakerInitializer.StartInitialization();
}
avatarProvider = AvatarMakerInitializer.AvatarProvider;
UpdateAvatarList();
}
public AvatarColumnProvider(RevisionDataGridView revisionGridView, IAvatarProvider avatarProvider)
: base("Avatar")
{
_revisionGridView = revisionGridView;
_avatarProvider = avatarProvider;
_avatarProvider.CacheCleared += _revisionGridView.Invalidate;
Column = new DataGridViewTextBoxColumn
{
AutoSizeMode = DataGridViewAutoSizeColumnMode.None,
HeaderText = "Avatar",
ReadOnly = true,
SortMode = DataGridViewColumnSortMode.NotSortable,
Resizable = DataGridViewTriState.False,
Width = DpiUtil.Scale(32)
};
}
/// <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);
}
private IEnumerator InitializeScene()
{
if (initParams != null)
{
avatarProvider = initParams.avatarProvider;
sceneToReturn = initParams.sceneToReturn;
currentAvatarCode = initParams.avatarCode;
useAnimations = initParams.useAnimations;
#if !UNITY_WEBGL
IMeshConverter meshConverter = AvatarSdkMgr.IoCContainer.Create <IMeshConverter>();
if (meshConverter.IsObjConvertEnabled)
{
convertToObjButton.gameObject.SetActive(true);
}
if (meshConverter.IsFBXExportEnabled)
{
fbxExportButton.gameObject.SetActive(true);
}
#endif
#if UNITY_EDITOR
prefabButton.gameObject.SetActive(true);
#endif
settingsPanel.SetActive(initParams.showSettings);
animationsPanel.SetActive(initParams.useAnimations);
blendshapesPanel.SetActive(!initParams.useAnimations);
if (initParams.faceAvatarRequest != null)
{
isWebGLDemo = true;
headAvatarCode = currentAvatarCode;
StartCoroutine(WaitFaceAvatarCalculations(initParams.faceAvatarRequest));
}
initParams = null;
yield return(ShowAvatar(currentAvatarCode));
}
else
{
Debug.LogError("Scene parameters were no set!");
}
}
public AvatarColumnProvider(RevisionDataGridView revisionGridView, IAvatarProvider avatarProvider, IAvatarCacheCleaner avatarCacheCleaner)
: base("Avatar")
{
_revisionGridView = revisionGridView;
_avatarProvider = avatarProvider;
_avatarCacheCleaner = avatarCacheCleaner;
_avatarCacheCleaner.CacheCleared += (sender, args) => _revisionGridView.Invalidate();
Column = new DataGridViewTextBoxColumn
{
AutoSizeMode = DataGridViewAutoSizeColumnMode.None,
HeaderText = "Avatar",
ReadOnly = true,
SortMode = DataGridViewColumnSortMode.NotSortable,
Resizable = DataGridViewTriState.False,
Width = DpiUtil.Scale(32),
Visible = AppSettings.ShowAuthorAvatarColumn
};
}
/// <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.PackageServiceProvider = ret;
var os = OperatingSystem;
var vsgit = IVSGitServices;
var clone = cloneService ?? new RepositoryCloneService(os, vsgit);
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(Substitute.For <IVSServices>());
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(IRepositoryHosts)).Returns(RepositoryHosts);
ret.GetService(typeof(IExportFactoryProvider)).Returns(ExportFactoryProvider);
ret.GetService(typeof(IUIFactory)).Returns(UIFactory);
ret.GetService(typeof(IConnection)).Returns(Connection);
ret.GetService(typeof(IConnectionManager)).Returns(ConnectionManager);
ret.GetService(typeof(IAvatarProvider)).Returns(avatarProvider);
ret.GetService(typeof(ITwoFactorChallengeHandler)).Returns(TwoFactorChallengeHandler);
ret.GetService(typeof(IGistPublishService)).Returns(GistPublishService);
ret.GetService(typeof(IPullRequestService)).Returns(PullRequestService);
ret.GetService(typeof(IUIProvider)).Returns(UIProvider);
return(ret);
}
public void InitItems(string avatarCode, List <string> items, IAvatarProvider avatarProvider)
{
AvatarSdkMgr.StopCoroutine("DisplayPreviews");
this.avatarCode = avatarCode;
this.avatarProvider = avatarProvider;
InitItems(items);
List <Toggle> previewToggles = new List <Toggle>();
foreach (Toggle t in toggles)
{
Text statusText = Utils.FindSubobjectByName(t.gameObject, "StatusText").GetComponentInChildren <Text>();
string haircutId = t.GetComponentInChildren <ToggleId>().Id;
if (haircutId == BALD_HAIRCUT_NAME)
{
statusText.text = "none";
}
else
{
statusText.text = "Loading...";
previewToggles.Add(t);
}
t.onValueChanged.AddListener(isOn =>
{
if (isOn && isShown)
{
OnDoneClick();
}
});
}
AvatarSdkMgr.SpawnCoroutine(DisplayPreviews(previewToggles));
}
public ProjectController(IServiceProvider services, IAvatarProvider avatar, IPermissionProvider <Project, ProjectCreateModel> permission) : base(services)
{
_avatar = avatar;
_permission = permission;
}
public AvatarProviderTab(IAvatarProvider provider, QWidget parent)
: base(parent)
{
m_Provider = provider;
QObject.Connect(base.Page().MainFrame(), Qt.SIGNAL("javaScriptWindowObjectCleared()"), delegate {
base.Page().MainFrame().AddToJavaScriptWindowObject("AvatarSelectDialog", parent.TopLevelWidget());
});
base.SetHtml(String.Empty);
}
public AvatarController(IAvatarProvider avatarProvider)
{
this.avatarProvider = avatarProvider ?? throw new ArgumentNullException(nameof(avatarProvider));
}
public AvatarPersistentCache(IAvatarProvider inner, IAvatarGenerator avatarGenerator, IFileSystem fileSystem = null)
{
_inner = inner;
_avatarGenerator = avatarGenerator;
_fileSystem = fileSystem ?? new FileSystem();
}
/// <summary>
/// Initialize avatar provider
/// </summary>
protected virtual IEnumerator Initialize()
{
avatarProvider = AvatarSdkMgr.IoCContainer.Create <IAvatarProvider>();
yield return(Await(avatarProvider.InitializeAsync()));
}
internal CustomAvatarManager(PacketManager packetManager, FloorController floorController, PlayerAvatarManager avatarManager, IMultiplayerSessionManager sessionManager, IAvatarProvider <LoadedAvatar> avatarProvider)
{
_packetManager = packetManager;
_avatarManager = avatarManager;
_sessionManager = sessionManager;
_avatarProvider = avatarProvider;
_floorController = floorController;
}
public OrganizationController(IServiceProvider services, IAvatarProvider avatar) : base(services)
{
_avatar = avatar;
}
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 FileSystemAvatarCache(IAvatarProvider inner, IFileSystem fileSystem = null)
{
_inner = inner;
_fileSystem = fileSystem ?? new FileSystem();
}
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;
}
public ModelService(IApiClient apiClient, IBlobCache hostCache, IAvatarProvider avatarProvider)
{
this.apiClient = apiClient;
this.hostCache = hostCache;
this.avatarProvider = avatarProvider;
}
public BackupAvatarProvider(IAvatarProvider inner, Image backupImage)
{
_inner = inner;
_backupImage = backupImage;
}
public ModelService(IApiClient apiClient, IBlobCache hostCache, IAvatarProvider avatarProvider)
{
this.apiClient = apiClient;
this.hostCache = hostCache;
this.avatarProvider = avatarProvider;
}
public SafetynetAvatarProvider(IAvatarProvider avatarProvider)
{
_avatarProvider = avatarProvider ?? throw new ArgumentNullException(nameof(avatarProvider));
}
