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 !));
})
public GitNugetTargetingVm(
ILogger logger,
INewestProfileLibraryVersionsVm newest,
IProfileVersioning versioning)
{
UpdateMutagenManualToLatestCommand = NoggogCommand.CreateFromObject(
objectSource: newest.WhenAnyValue(x => x.NewestMutagenVersion),
canExecute: v =>
{
return(Observable.CombineLatest(
this.WhenAnyValue(x => x.ManualMutagenVersion),
v,
(manual, latest) => latest != null && latest != manual));
},
execute: v => ManualMutagenVersion = v ?? string.Empty,
extraCanExecute: this.WhenAnyValue(x => x.MutagenVersioning)
.Select(vers => vers == PatcherNugetVersioningEnum.Manual),
disposable: this);
UpdateSynthesisManualToLatestCommand = NoggogCommand.CreateFromObject(
objectSource: newest.WhenAnyValue(x => x.NewestSynthesisVersion),
canExecute: v =>
{
return(Observable.CombineLatest(
this.WhenAnyValue(x => x.ManualSynthesisVersion),
v,
(manual, latest) => latest != null && latest != manual));
},
execute: v => ManualSynthesisVersion = v ?? string.Empty,
extraCanExecute: this.WhenAnyValue(x => x.SynthesisVersioning)
.Select(vers => vers == PatcherNugetVersioningEnum.Manual),
disposable: this);
ActiveNugetVersion = Observable.CombineLatest(
versioning.WhenAnyValue(x => x.ActiveVersioning)
.Switch(),
this.WhenAnyValue(x => x.MutagenVersioning),
this.WhenAnyValue(x => x.ManualMutagenVersion),
newest.WhenAnyValue(x => x.NewestMutagenVersion),
this.WhenAnyValue(x => x.SynthesisVersioning),
this.WhenAnyValue(x => x.ManualSynthesisVersion),
newest.WhenAnyValue(x => x.NewestSynthesisVersion),
(profile, mutaVersioning, mutaManual, newestMuta, synthVersioning, synthManual, newestSynth) =>
{
var sb = new StringBuilder("Switching nuget targets");
NugetsToUse mutagen, synthesis;
if (mutaVersioning == PatcherNugetVersioningEnum.Profile)
{
sb.Append($" Mutagen following profile: {profile.Mutagen}");
mutagen = profile.Mutagen;
}
else
{
mutagen = new NugetsToUse("Mutagen", mutaVersioning.ToNugetVersioningEnum(), mutaManual,
newestMuta);
sb.Append($" {mutagen}");
}
if (synthVersioning == PatcherNugetVersioningEnum.Profile)
{
sb.Append($" Synthesis following profile: {profile.Synthesis}");
synthesis = profile.Synthesis;
}
else
{
synthesis = new NugetsToUse("Synthesis", synthVersioning.ToNugetVersioningEnum(),
synthManual, newestSynth);
sb.Append($" {synthesis}");
}
logger.Information(sb.ToString());
return(new ActiveNugetVersioning(
Mutagen: mutagen,
Synthesis: synthesis));
})
.Select(nuget => nuget.TryGetTarget())
.Replay(1)
.RefCount();
}
