public GitPatcherState(
IDriverRepositoryPreparationFollower driverRepositoryPreparation,
IRunnerRepositoryPreparation runnerRepositoryState,
IRunnableStateProvider runnableStateProvider,
IPatcherRunnabilityCliState runnabilityCliState,
IInstalledSdkFollower dotNetInstalled,
IEnvironmentErrorsVm envErrors,
IMissingMods missingMods,
ILogger logger)
{
State = Observable.CombineLatest(
driverRepositoryPreparation.DriverInfo
.Select(x => x.ToUnit()),
runnerRepositoryState.State,
runnableStateProvider.WhenAnyValue(x => x.State)
.Select(x => x.ToUnit()),
runnabilityCliState.Runnable,
dotNetInstalled.DotNetSdkInstalled
.Select(x => (x, true))
.StartWith((new DotNetVersion(string.Empty, false), false)),
envErrors.WhenAnyFallback(x => x.ActiveError !.ErrorString),
missingMods.Missing
.QueryWhenChanged()
.Throttle(TimeSpan.FromMilliseconds(200), RxApp.MainThreadScheduler)
.StartWith(ListExt.Empty <ModKey>()),
(driver, runner, checkout, runnability, dotnet, envError, reqModsMissing) =>
{
if (driver.IsHaltingError)
{
return(driver);
}
if (runner.IsHaltingError)
{
return(runner);
}
if (!dotnet.Item2)
{
return(new ConfigurationState(ErrorResponse.Fail("Determining DotNet SDK installed"))
{
IsHaltingError = false
});
}
if (!dotnet.Item1.Acceptable)
{
return(new ConfigurationState(ErrorResponse.Fail("No DotNet SDK installed")));
}
if (envError != null)
{
return(new ConfigurationState(ErrorResponse.Fail(envError)));
}
if (reqModsMissing.Count > 0)
{
return(new ConfigurationState(ErrorResponse.Fail(
$"Required mods missing from load order:{Environment.NewLine}{string.Join(Environment.NewLine, reqModsMissing)}")));
}
if (runnability.RunnableState.Failed)
{
return(runnability.BubbleError());
}
if (checkout.RunnableState.Failed)
{
return(checkout.BubbleError());
}
logger.Information("State returned success!");
return(ConfigurationState.Success);
})
.Replay(1)
.RefCount();
}
public ProfileVm(
ILifetimeScope scope,
IPatcherInitializationVm initVm,
IProfileDataFolderVm dataFolder,
IProfileIdentifier ident,
IProfileNameVm nameProvider,
IProfileLoadOrder loadOrder,
IProfileDirectories dirs,
IProfileVersioning versioning,
IProfileDisplayControllerVm profileDisplay,
ILockToCurrentVersioning lockSetting,
ISelectedProfileControllerVm selProfile,
IProfileExporter exporter,
IProfileGroupsList groupsList,
IEnvironmentErrorsVm environmentErrors,
OverallErrorVm overallErrorVm,
StartRun startRun,
ILogger logger)
{
Scope = scope;
Init = initVm;
OverallErrorVm = overallErrorVm;
NameVm = nameProvider;
Groups = groupsList.Groups;
DataFolderOverride = dataFolder;
Versioning = versioning;
LockSetting = lockSetting;
Exporter = exporter;
DisplayController = profileDisplay;
_startRun = startRun;
_logger = logger;
ID = ident.ID;
Release = ident.Release;
GroupsDisplay = new SourceListUiFunnel <GroupVm>(Groups, this);
ProfileDirectory = dirs.ProfileDirectory;
WorkingDirectory = dirs.WorkingDirectory;
EnvironmentErrors = environmentErrors;
_dataFolder = dataFolder.WhenAnyValue(x => x.Path)
.ToGuiProperty <DirectoryPath>(this, nameof(DataFolder), string.Empty, deferSubscription: true);
LoadOrder = loadOrder.LoadOrder;
var enabledGroups = Groups.Connect()
.ObserveOnGui()
.FilterOnObservable(p => p.WhenAnyValue(x => x.IsOn), scheduler: RxApp.MainThreadScheduler)
.RefCount();
var enabledGroupModKeys = enabledGroups
.Transform(x => x.ModKey)
.QueryWhenChanged(q => q.ToHashSet())
.Replay(1).RefCount();
_blockingError = Observable.CombineLatest(
dataFolder.WhenAnyValue(x => x.DataFolderResult),
loadOrder.WhenAnyValue(x => x.State),
enabledGroups
.QueryWhenChanged(q => q)
.StartWith(Noggog.ListExt.Empty <GroupVm>()),
enabledGroups
.FilterOnObservable(g => g.WhenAnyValue(x => x.State).Select(x => x.IsHaltingError))
.QueryWhenChanged(q => q)
.StartWith(Noggog.ListExt.Empty <GroupVm>()),
LoadOrder.Connect()
.FilterOnObservable(
x =>
{
return(Observable.CombineLatest(
x.WhenAnyValue(y => y.Exists)
.DistinctUntilChanged(),
enabledGroupModKeys
.Select(groupModKeys => groupModKeys.Contains(x.ModKey)),
(exists, isEnabledGroupKey) => !exists && !isEnabledGroupKey));
},
scheduler: RxApp.MainThreadScheduler)
.QueryWhenChanged(q => q)
.StartWith(Noggog.ListExt.Empty <ReadOnlyModListingVM>())
.Throttle(TimeSpan.FromMilliseconds(200), RxApp.MainThreadScheduler),
this.WhenAnyValue(x => x.IgnoreMissingMods),
(dataFolder, loadOrder, enabledGroups, erroredEnabledGroups, missingMods, ignoreMissingMods) =>
{
if (enabledGroups.Count == 0)
{
return(GetResponse <ViewModel> .Fail("There are no enabled groups to run."));
}
if (!dataFolder.Succeeded)
{
return(dataFolder.BubbleFailure <ViewModel>());
}
if (!loadOrder.Succeeded)
{
return(loadOrder.BubbleFailure <ViewModel>());
}
if (!ignoreMissingMods && missingMods.Count > 0)
{
return(GetResponse <ViewModel> .Fail($"Load order had mods that were missing:{Environment.NewLine}{string.Join(Environment.NewLine, missingMods.Select(x => x.ModKey))}"));
}
if (erroredEnabledGroups.Count > 0)
{
var errGroup = erroredEnabledGroups.First();
return(GetResponse <ViewModel> .Fail(errGroup, $"\"{errGroup.Name}\" has a blocking error: {errGroup.State}"));
}
return(GetResponse <ViewModel> .Succeed(null !));
})
