private async Task AddFactorioInstallation(FactorioFolder folder)
{
await PreserveContentsAsync(folder.Directory);
var factorioDir = App.Instance.Settings.GetFactorioDirectory();
if (!factorioDir.Exists)
{
factorioDir.Create();
}
var newFolder = await folder.CopyToAsync(factorioDir);
newFolder.RenameToUnique();
var factorioVersion = new FactorioVersion(newFolder);
FactorioVersions.Add(factorioVersion);
factorioVersion.BeginEdit();
}
public void UnmaintainRelease_ShouldDeleteAndIsStored_DiscardRelease()
{
// Arrange
var modName = "TestMod";
var version = new FactorioVersion(1, 2, 3);
var shouldDelete = true;
var isStored = true;
var modsStorageService = new Mock <IModsStorageService>();
modsStorageService.Setup(mss => mss.ReleaseIsStored(modName, version)).Returns(isStored);
var mainService = new MainService(null, null, null, null, null, modsStorageService.Object);
// Act
mainService.UnmaintainRelease(modName, version, shouldDelete);
// Assert
modsStorageService.Verify(mss => mss.DiscardRelease(modName, version), Times.Once);
}
private static bool TryGetFactorioVersion(string name, bool isVersion, out FactorioVersion factorioVersion)
{
factorioVersion = null;
var factorioVersions = FactorioCollection.Load();
if (isVersion)
{
if (!Version.TryParse(name, out var version))
{
return(false);
}
bool exact = name.IndexOf('.') != name.LastIndexOf('.');
factorioVersion = factorioVersions.Find(version, exact);
}
else
{
factorioVersion = factorioVersions.Find(name);
}
return(factorioVersion != null);
}
private static async Task ApplyUpdatePackageAsync(FactorioVersion versionToUpdate, FileInfo packageFile, IProgress <double> progress)
{
using (var archive = ZipFile.OpenRead(packageFile.FullName))
{
UpdatePackageInfo packageInfo = await GetUpdatePackageInfoAsync(archive);
if (!string.Equals(packageInfo.Type, "update", StringComparison.InvariantCultureIgnoreCase))
{
throw new CriticalUpdaterException(UpdaterErrorType.PackageInvalid);
}
int fileCount = packageInfo.UpdatedFiles.Length;
int counter = 0;
foreach (var fileUpdate in packageInfo.UpdatedFiles)
{
progress.Report((double)counter / fileCount);
switch (fileUpdate.Action)
{
case FileUpdateAction.Added:
await AddFileAsync(fileUpdate, versionToUpdate, archive, packageInfo.PackageDirectory);
break;
case FileUpdateAction.Removed:
await DeleteFileAsync(fileUpdate, versionToUpdate);
break;
case FileUpdateAction.Differs:
await UpdateFileAsync(fileUpdate, versionToUpdate, archive, packageInfo.PackageDirectory);
break;
}
counter++;
}
progress.Report(1);
}
}
private static async Task AddFileAsync(FileUpdateInfo fileUpdate, FactorioVersion versionToUpdate, ZipArchive archive, string packageDirectory)
{
await Task.Run(() =>
{
var file = new FileInfo(versionToUpdate.ExpandPathVariables(fileUpdate.Path));
string entryPath = fileUpdate.Path;
if (!string.IsNullOrEmpty(packageDirectory))
{
entryPath = string.Join("/", packageDirectory, entryPath);
}
entryPath = ResolveArchivePath(entryPath);
var entry = archive.GetEntry(entryPath);
var dir = file.Directory;
if (!dir.Exists)
{
dir.Create();
}
entry.ExtractToFile(file.FullName, true);
});
}
private bool ShowVersionList(CookieContainer container, out FactorioOnlineVersion selectedVersion)
{
selectedVersion = null;
List <FactorioOnlineVersion> versions;
try
{
if (!FactorioWebsite.GetVersions(container, out versions))
{
MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("RetrievingVersions", MessageType.Error),
App.Instance.GetLocalizedMessageTitle("RetrievingVersions", MessageType.Error),
MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
}
catch (WebException)
{
MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("RetrievingVersions", MessageType.Error),
App.Instance.GetLocalizedMessageTitle("RetrievingVersions", MessageType.Error),
MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
versions.ForEach(item => item.Downloadable = GetVersionDownloadable(item));
var versionListWindow = new VersionListWindow {
Owner = Window
};
var versionListViewModel = (VersionListViewModel)versionListWindow.ViewModel;
versions.ForEach(item => versionListViewModel.FactorioVersions.Add(item));
bool?versionResult = versionListWindow.ShowDialog();
selectedVersion = versionListViewModel.SelectedVersion;
return(versionResult.HasValue && versionResult.Value);
}
public bool Compatible(FactorioVersion gameVersion, CfanModule module)
{
return(module.IsCompatibleKSP(gameVersion));
}
public static FactorioVersion GenerateValidRandomizedFactorioVersion()
{
return(FactorioVersion.For(GenerateValidRandomizedFactorioVersionString()));
}
public bool IsCompatibleKSP(FactorioVersion kspVersion)
{
ModDependency baseGame = BaseGameDependency;
return(baseGame == null || baseGame.isSatisfiedBy("base", kspVersion));
}
/// <summary>
/// Creates a new resolver that will find a way to install all the modules specified.
/// </summary>
public RelationshipResolver(ICollection <CfanModule> modules, RelationshipResolverOptions options, IRegistryQuerier registry,
FactorioVersion kspversion) : this(options, registry, kspversion)
{
AddModulesToInstall(modules.ToArray());
}
public void ToString_WhenGivenFactorioVersion_ReturnsCorrectString(FactorioVersion version, String expected)
{
Assert.Equal(expected, version.ToString());
}
/// <summary>
/// This function returns a changeset based on the selections of the user.
/// Currently returns null if a conflict is detected.
/// </summary>
/// <param name="registry"></param>
/// <param name="changeSet"></param>
/// <param name="installer">A module installer for the current KSP install</param>
/// <param name="version">The version of the current KSP install</param>
public async Task <IEnumerable <ModChange> > ComputeChangeSetFromModList(
IRegistryQuerier registry, HashSet <ModChange> changeSet, ModuleInstaller installer,
FactorioVersion version)
{
var modules_to_install = new HashSet <CfanModule>();
var modules_to_remove = new HashSet <CfanModule>();
var options = new RelationshipResolverOptions
{
without_toomanyprovides_kraken = false,
with_recommends = false
};
foreach (var change in changeSet)
{
switch (change.ChangeType)
{
case GUIModChangeType.None:
break;
case GUIModChangeType.Update:
case GUIModChangeType.Install:
//TODO: Fix
//This will give us a mod with a wrong version!
modules_to_install.Add(change.Mod.ToCkanModule());
break;
case GUIModChangeType.Remove:
modules_to_remove.Add(change.Mod);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var installed_modules =
registry.InstalledModules.Select(imod => imod.Module).ToDictionary(mod => mod.identifier, mod => mod);
bool handled_all_to_many_provides = false;
while (!handled_all_to_many_provides)
{
//Can't await in catch clause - doesn't seem to work in mono. Hence this flag
TooManyModsProvideKraken kraken;
try
{
new RelationshipResolver(modules_to_install.ToList(), options, registry, version);
handled_all_to_many_provides = true;
continue;
}
catch (TooManyModsProvideKraken k)
{
kraken = k;
}
catch (ModuleNotFoundKraken k)
{
//We shouldn't need this. However the relationship provider will throw TMPs with incompatible mods.
user.RaiseError("Module {0} has not been found. This may be because it is not compatible " +
"with the currently installed version of KSP", k.module);
return(null);
}
//Shouldn't get here unless there is a kraken.
var mod = await too_many_provides(kraken);
if (mod != null)
{
modules_to_install.Add(mod);
}
else
{
//TODO Is could be a new type of Kraken.
throw kraken;
}
}
foreach (var dependency in registry.FindReverseDependencies(modules_to_remove.Select(mod => mod.identifier)))
{
//TODO This would be a good place to have a event that alters the row's graphics to show it will be removed
CfanModule module_by_version = registry.GetModuleByVersion(installed_modules[dependency].identifier,
installed_modules[dependency].modVersion) ?? registry.InstalledModule(dependency).Module;
changeSet.Add(new ModChange(new GUIMod(module_by_version, registry, version), GUIModChangeType.Remove, null));
}
//May throw InconsistentKraken
var resolver = new RelationshipResolver(options, registry, version);
resolver.RemoveModsFromInstalledList(
changeSet.Where(change => change.ChangeType.Equals(GUIModChangeType.Remove)).Select(m => m.Mod.ToModule()));
resolver.AddModulesToInstall(modules_to_install.ToList());
changeSet.UnionWith(
resolver.ModList()
.Select(m => new ModChange(new GUIMod(m, registry, version), GUIModChangeType.Install, resolver.ReasonFor(m))));
return(changeSet);
}
/// <summary>
/// Return the most recent release of a module with a optional ksp version to target and a RelationshipDescriptor to satisfy.
/// </summary>
/// <param name="ksp_version">If not null only consider mods which match this ksp version.</param>
/// <param name="relationship">If not null only consider mods which satisfy the RelationshipDescriptor.</param>
/// <returns></returns>
public CfanModule Latest(FactorioVersion ksp_version = null, ModDependency relationship = null, bool hasFactorioAuth = false)
{
IDictionary <ModVersion, CfanJson> module_version = this.module_version;
if (!hasFactorioAuth)
{
module_version = module_version.Where(p => !CfanJson.requiresFactorioComAuthorization(p.Value)).ToDictionary(p => p.Key, p => p.Value);
}
var available_versions = new List <ModVersion>(module_version.Keys);
CfanJson module;
log.DebugFormat("Our dictionary has {0} keys", module_version.Keys.Count);
log.DebugFormat("Choosing between {0} available versions", available_versions.Count);
// Uh oh, nothing available. Maybe this existed once, but not any longer.
if (available_versions.Count == 0)
{
return(null);
}
// No restrictions? Great, we can just pick the first one!
if (ksp_version == null && relationship == null)
{
module = module_version[available_versions.First()];
log.DebugFormat("No KSP version restriction, {0} is most recent", module.modInfo.version);
return(new CfanModule(module));
}
// If there's no relationship to satisfy, we can just pick the first that is
// compatible with our version of KSP.
if (relationship == null)
{
// Time to check if there's anything that we can satisfy.
var version =
available_versions.FirstOrDefault(v => new CfanModule(module_version[v]).IsCompatibleKSP(ksp_version));
if (version != null)
{
return(new CfanModule(module_version[version]));
}
log.DebugFormat("No version of {0} is compatible with KSP {1}",
module_version[available_versions[0]].modInfo.name, ksp_version);
return(null);
}
// If we're here, then we have a relationship to satisfy, so things get more complex.
if (ksp_version == null)
{
var version = available_versions.FirstOrDefault(p => relationship.isSatisfiedBy(identifier, p));
return(version == null ? null : new CfanModule(module_version[version]));
}
else
{
var version = available_versions.FirstOrDefault(v =>
relationship.isSatisfiedBy(identifier, v) &&
new CfanModule(module_version[v]).IsCompatibleKSP(ksp_version));
return(version == null ? null : new CfanModule(module_version[version]));
}
}
private async Task AddLocalVersion()
{
var dialog = new VistaFolderBrowserDialog();
bool?result = dialog.ShowDialog(Window);
if (result.HasValue && result.Value)
{
var installationDirectory = new DirectoryInfo(dialog.SelectedPath);
Version version;
bool is64Bit;
if (!FactorioVersion.LocalInstallationValid(installationDirectory, out version, out is64Bit))
{
MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("InvalidFactorioFolder", MessageType.Error),
App.Instance.GetLocalizedMessageTitle("InvalidFactorioFolder", MessageType.Error),
MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (is64Bit != Environment.Is64BitOperatingSystem)
{
MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("IncompatiblePlatform", MessageType.Error),
App.Instance.GetLocalizedMessageTitle("IncompatiblePlatform", MessageType.Error),
MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (FactorioVersions.Any(factorioVersion => factorioVersion.Version == version))
{
MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("FactorioVersionInstalled", MessageType.Error),
App.Instance.GetLocalizedMessageTitle("FactorioVersionInstalled", MessageType.Error),
MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var copyOrMoveWindow = new CopyOrMoveMessageWindow()
{
Owner = Window
};
((CopyOrMoveViewModel)copyOrMoveWindow.ViewModel).CopyOrMoveType = CopyOrMoveType.Factorio;
result = copyOrMoveWindow.ShowDialog();
if (result.HasValue && result.Value)
{
bool move = copyOrMoveWindow.Move;
DirectoryInfo factorioDirectory = App.Instance.Settings.GetFactorioDirectory();
if (!factorioDirectory.Exists)
{
factorioDirectory.Create();
}
DirectoryInfo destinationDirectory = new DirectoryInfo(Path.Combine(factorioDirectory.FullName, version.ToString(3)));
var progressWindow = new ProgressWindow()
{
Owner = Window
};
var progressViewModel = (ProgressViewModel)progressWindow.ViewModel;
progressViewModel.ActionName = App.Instance.GetLocalizedResourceString("AddingLocalInstallationAction");
progressViewModel.ProgressDescription = move ? App.Instance.GetLocalizedResourceString("MovingFilesDescription") : App.Instance.GetLocalizedResourceString("CopyingFilesDescription");
progressViewModel.IsIndeterminate = true;
Task addTask = move
? MoveFactorioInstallationAsync(installationDirectory, destinationDirectory)
: CopyFactorioInstallationAsync(installationDirectory, destinationDirectory);
Task closeWindowTask = addTask.ContinueWith(t => progressWindow.Dispatcher.Invoke(progressWindow.Close));
progressWindow.ShowDialog();
await addTask;
await closeWindowTask;
FactorioVersions.Add(new FactorioVersion(destinationDirectory, version));
}
}
}
/// <summary>
/// Is the mod installed and does it have a newer version compatible with version
/// We can't update AD mods
/// </summary>
public static bool HasUpdate(this IRegistryQuerier querier, string identifier, FactorioVersion version)
{
CfanModule newest_version;
try
{
newest_version = querier.LatestAvailable(identifier, version);
}
catch (ModuleNotFoundKraken)
{
return(false);
}
if (newest_version == null)
{
return(false);
}
return(!new List <string>(querier.InstalledPreexistingModules).Contains(identifier) && querier.IsInstalled(identifier, false) &&
newest_version.modVersion.IsGreaterThan(querier.InstalledVersion(identifier)));
}
public static CfanModule GetModuleByIdentifierAndOptionalVersion(this IRegistryQuerier querier, CfanModuleIdAndVersion moduleIdAndVersion, FactorioVersion factorioVersion)
{
if (moduleIdAndVersion.version != null)
{
return(GetModuleByVersion(querier, moduleIdAndVersion.identifier, moduleIdAndVersion.version.ToString()));
}
else
{
return(querier.LatestAvailable(moduleIdAndVersion.identifier, factorioVersion));
}
}
public void For_WhenGivenStringWithValidMinorVersion_ReturnsCorrectMinorVersion(String factorioVersionString, Int32 minor)
{
var factorioVersion = FactorioVersion.For(factorioVersionString);
Assert.Equal(minor, factorioVersion.Minor);
}
public void For_WhenGivenStringWithNegativeMinorVersion_ThrowsArgumentOutOfRangeException(String factorioVersionString)
{
var exception = Assert.Throws <ArgumentOutOfRangeException>(() => FactorioVersion.For(factorioVersionString));
Assert.Equal($"Unable to parse \"{factorioVersionString}\" into a FactorioVersion - version parts must be positive. (Parameter 'factorioVersionString')", exception.Message);
}
public void For_WhenGivenEmptyStringOrWhitespace_ThrowsArgumentException(String factorioVersionString)
{
var exception = Assert.Throws <ArgumentException>(() => FactorioVersion.For(factorioVersionString));
Assert.Equal($"factorioVersionString may not be empty. (Parameter 'factorioVersionString')", exception.Message);
}
public void For_WhenGivenNull_ThrowsArgumentNullException()
{
var exception = Assert.Throws <ArgumentNullException>(() => FactorioVersion.For(null));
Assert.Equal("factorioVersionString is required. (Parameter 'factorioVersionString')", exception.Message);
}
private async Task AddZippedVersion()
{
var dialog = new VistaOpenFileDialog();
dialog.Filter = App.Instance.GetLocalizedResourceString("ZipDescription") + @" (*.zip)|*.zip";
bool?result = dialog.ShowDialog(Window);
if (result.HasValue && result.Value)
{
var archiveFile = new FileInfo(dialog.FileName);
Version version = null;
DirectoryInfo versionDirectory = null;
var progressWindow = new ProgressWindow()
{
Owner = Window
};
var progressViewModel = (ProgressViewModel)progressWindow.ViewModel;
progressViewModel.ActionName = App.Instance.GetLocalizedResourceString("AddingFromZipAction");
progressViewModel.ProgressDescription = App.Instance.GetLocalizedResourceString("CheckingValidityDescription");
progressViewModel.IsIndeterminate = true;
bool invalidArchiveFile = false;
bool invalidPlatform = false;
bool versionInstalled = false;
IProgress <int> progress = new Progress <int>(stage =>
{
switch (stage)
{
case 1:
progressViewModel.ProgressDescription = App.Instance.GetLocalizedResourceString("ExtractingDescription");
break;
case -1:
invalidArchiveFile = true;
break;
case -2:
invalidPlatform = true;
break;
case -3:
versionInstalled = true;
break;
}
});
Task extractTask = Task.Run(() =>
{
bool is64Bit;
if (FactorioVersion.ArchiveFileValid(archiveFile, out version, out is64Bit))
{
if (is64Bit == Environment.Is64BitOperatingSystem)
{
if (FactorioVersions.All(factorioVersion => factorioVersion.Version != version))
{
progress.Report(1);
DirectoryInfo factorioDirectory = App.Instance.Settings.GetFactorioDirectory();
ZipFile.ExtractToDirectory(archiveFile.FullName, factorioDirectory.FullName);
string versionString = version.ToString(3);
versionDirectory = factorioDirectory.EnumerateDirectories($"Factorio_{versionString}*").First();
versionDirectory.MoveTo(Path.Combine(factorioDirectory.FullName, versionString));
}
else
{
progress.Report(-3);
}
}
else
{
progress.Report(-2);
}
}
else
{
progress.Report(-1);
}
});
Task closeWindowTask =
extractTask.ContinueWith(t => progressWindow.Dispatcher.Invoke(progressWindow.Close));
progressWindow.ShowDialog();
await extractTask;
await closeWindowTask;
if (invalidArchiveFile)
{
MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("InvalidFactorioArchive", MessageType.Error),
App.Instance.GetLocalizedMessageTitle("InvalidFactorioArchive", MessageType.Error),
MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (invalidPlatform)
{
MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("IncompatiblePlatform", MessageType.Error),
App.Instance.GetLocalizedMessageTitle("IncompatiblePlatform", MessageType.Error),
MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (versionInstalled)
{
MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("FactorioVersionInstalled", MessageType.Error),
App.Instance.GetLocalizedMessageTitle("FactorioVersionInstalled", MessageType.Error),
MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
FactorioVersions.Add(new FactorioVersion(versionDirectory, version));
if (MessageBox.Show(Window,
App.Instance.GetLocalizedMessage("DeleteFactorioArchive", MessageType.Question),
App.Instance.GetLocalizedMessageTitle("DeleteFactorioArchive", MessageType.Question),
MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
{
archiveFile.Delete();
}
}
}
}
public bool ReleaseIsStored(string modName, FactorioVersion version)
{
return(File.Exists(Path.Combine(modsPath, ReleaseData.GetFileName(modName, version))));
}
/// <summary>
/// Starts Factorio if the command line specifies to do so.
/// </summary>
/// <param name="commandLine">The programs command line.</param>
/// <param name="createApp">Specifies whether an app should be created.</param>
/// <returns>Returns true if the game was started, otherwise false.</returns>
private static bool StartGameIfSpecified(CommandLine commandLine, bool createApp)
{
string versionString;
if (commandLine.TryGetArgument('f', "factorio-version", out versionString))
{
// Variable not used but sets 'Application.Current'.
App app = null;
if (createApp)
{
app = CreateApp(commandLine);
}
var versions = FactorioVersion.GetInstalledVersions();
FactorioVersion steamVersion;
if (FactorioSteamVersion.TryLoad(out steamVersion))
{
versions.Add(steamVersion);
}
FactorioVersion factorioVersion = null;
if (string.Equals(versionString, FactorioVersion.LatestKey, StringComparison.InvariantCultureIgnoreCase))
{
factorioVersion = versions.MaxBy(item => item.Version, new VersionComparer());
}
else
{
factorioVersion = versions.Find(item => string.Equals(item.VersionString, versionString, StringComparison.InvariantCultureIgnoreCase));
}
if (factorioVersion != null)
{
var mods = new List <Mod>();
var modpacks = new List <Modpack>();
ModManager.BeginUpdateTemplates();
Mod.LoadMods(mods, modpacks);
ModpackTemplateList.Instance.PopulateModpackList(mods, modpacks, null);
mods.ForEach(mod => mod.Active = false);
string modpackName;
if (commandLine.TryGetArgument('p', "modpack", out modpackName))
{
Modpack modpack = modpacks.FirstOrDefault(item => item.Name == modpackName);
if (modpack != null)
{
modpack.Active = true;
}
else
{
MessageBox.Show(
$"No modpack named '{modpackName}' found.\nThe game will be launched without any mods enabled.",
"Error loading modpack!", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
ModManager.EndUpdateTemplates(true);
ModManager.SaveTemplates();
Process.Start(factorioVersion.ExecutablePath);
}
else
{
MessageBox.Show(
$"Factorio version {versionString} is not available.\nCheck your installed Factorio versions.",
"Error starting game!", MessageBoxButton.OK, MessageBoxImage.Error);
}
return(true);
}
return(false);
}
public void DiscardRelease(string modName, FactorioVersion version)
{
File.Delete(Path.Combine(modsPath, ReleaseData.GetFileName(modName, version)));
RemoveFromAllStoredReleases(modName, version);
}
private void _UpdateModsList(bool repo_updated)
{
log.Debug("Updating the mod list");
FactorioVersion version = CurrentInstance.Version();
IRegistryQuerier registry = RegistryManager.Instance(CurrentInstance).registry;
var gui_mods = new HashSet <GUIMod>(registry.Available(version)
.Select(m => new GUIMod(m, registry, version)));
gui_mods.UnionWith(registry.Incompatible(version)
.Select(m => new GUIMod(m, registry, version)));
var installed = registry.InstalledModules
.Select(m => new GUIMod(m.Module, registry, version));
//Hashset does not define if add/unionwith replaces existing elements.
//In this case that could cause a CkanModule to be replaced by a Module.
//Hence the explicit checking
foreach (var mod in installed.Where(mod => !gui_mods.Contains(mod)))
{
gui_mods.Add(mod);
}
var old_modules = new HashSet <GUIMod>(mainModList.Modules);
if (repo_updated)
{
foreach (var gui_mod in gui_mods.Where(m => !old_modules.Contains(m)))
{
gui_mod.IsNew = true;
}
}
else
{
//Copy the new mod flag from the old list.
var old_new_mods = new HashSet <GUIMod>(old_modules.Where(m => m.IsNew));
foreach (var gui_mod in gui_mods.Where(m => old_new_mods.Contains(m)))
{
gui_mod.IsNew = true;
}
}
// Update our mod listing. If we're doing a repo update, then we don't refresh
// all (in case the user has selected changes they wish to apply).
mainModList.ConstructModList(gui_mods.ToList(), refreshAll: !repo_updated);
mainModList.Modules = new ReadOnlyCollection <GUIMod>(
mainModList.full_list_of_mod_rows.Values.Select(row => row.Tag as GUIMod).ToList());
//TODO Consider using smart enum patten so stuff like this is easier
FilterToolButton.DropDownItems[0].Text = String.Format("Compatible ({0})",
mainModList.CountModsByFilter(GUIModFilter.Compatible));
FilterToolButton.DropDownItems[1].Text = String.Format("Installed ({0})",
mainModList.CountModsByFilter(GUIModFilter.Installed));
FilterToolButton.DropDownItems[2].Text = String.Format("Upgradeable ({0})",
mainModList.CountModsByFilter(GUIModFilter.InstalledUpdateAvailable));
FilterToolButton.DropDownItems[3].Text = String.Format("Cached ({0})",
mainModList.CountModsByFilter(GUIModFilter.Cached));
FilterToolButton.DropDownItems[4].Text = String.Format("New in repository ({0})",
mainModList.CountModsByFilter(GUIModFilter.NewInRepository));
FilterToolButton.DropDownItems[5].Text = String.Format("Not installed ({0})",
mainModList.CountModsByFilter(GUIModFilter.NotInstalled));
FilterToolButton.DropDownItems[6].Text = String.Format("Incompatible ({0})",
mainModList.CountModsByFilter(GUIModFilter.Incompatible));
FilterToolButton.DropDownItems[7].Text = String.Format("All ({0})",
mainModList.CountModsByFilter(GUIModFilter.All));
var has_any_updates = gui_mods.Any(mod => mod.HasUpdate);
UpdateAllToolButton.Enabled = has_any_updates;
UpdateFilters(this);
}
/// <summary>
/// Creates a new Relationship resolver.
/// </summary>
/// <param name="options"><see cref="RelationshipResolverOptions"/></param>
/// <param name="registry">The registry to use</param>
/// <param name="kspversion">The version of the install that the registry corresponds to</param>
public RelationshipResolver(RelationshipResolverOptions options, IRegistryQuerier registry, FactorioVersion kspversion)
{
this.registry = registry;
this.kspversion = kspversion;
this.options = options;
installed_modules = new HashSet <CfanModule>(registry.InstalledModules.Select(i_module => i_module.Module));
var installed_relationship = new SelectionReason.Installed();
foreach (var module in installed_modules)
{
reasons.Add(module, installed_relationship);
}
}
public static Dictionary <GUIMod, string> ComputeConflictsFromModList(IRegistryQuerier registry,
IEnumerable <ModChange> change_set, FactorioVersion ksp_version)
{
var modules_to_install = new HashSet <string>();
var modules_to_remove = new HashSet <string>();
var options = new RelationshipResolverOptions
{
without_toomanyprovides_kraken = true,
procede_with_inconsistencies = true,
without_enforce_consistency = true,
with_recommends = false
};
foreach (var change in change_set)
{
switch (change.ChangeType)
{
case GUIModChangeType.None:
break;
case GUIModChangeType.Install:
modules_to_install.Add(change.Mod.Identifier);
break;
case GUIModChangeType.Remove:
modules_to_remove.Add(change.Mod.Identifier);
break;
case GUIModChangeType.Update:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
var installed =
registry.Installed()
.Where(pair => pair.Value.CompareTo(new ProvidedVersion("", "0.0.0")) != 0)
.Select(pair => pair.Key);
//We wish to only check mods that would exist after the changes are made.
var mods_to_check =
installed.Union(modules_to_install).Except(modules_to_remove).Select(p => new CfanModuleIdAndVersion(p));
var resolver = new RelationshipResolver(mods_to_check.ToList(), options, registry, ksp_version);
return(resolver.ConflictList.ToDictionary(item => new GUIMod(item.Key, registry, ksp_version),
item => item.Value));
}
private static List <CfanModule> getModulesFromRegistry(
IEnumerable <CfanModuleIdAndVersion> module_names, IRegistryQuerier registry, FactorioVersion kspversion)
{
return(module_names.Select(
p =>
{
var mod = p.version != null
? registry.GetModuleByVersion(p.identifier, p.version)
: registry.LatestAvailable(p.identifier, kspversion);
if (mod == null)
{
throw new ModuleNotFoundKraken(p.identifier, p.version?.ToString(), "Module not found.");
}
return mod;
}).ToList());
}
/// <summary>
/// Attempts to convert the module_names to ckan modules via CkanModule.FromIDandVersion and then calls RelationshipResolver.ctor(IEnumerable{CkanModule}, Registry, KSPVersion)"/>
/// </summary>
/// <param name="module_names"></param>
/// <param name="options"></param>
/// <param name="registry"></param>
/// <param name="kspversion"></param>
public RelationshipResolver(IEnumerable <CfanModuleIdAndVersion> module_names, RelationshipResolverOptions options, IRegistryQuerier registry, FactorioVersion kspversion) :
this(getModulesFromRegistry(module_names, registry, kspversion),
options,
registry,
kspversion)
{
// Does nothing, just calls the other overloaded constructor
}
public void CompareTo_WhenProvidedSmallerVersion_ReturnsOne(String left, String right)
{
Assert.Equal(1, FactorioVersion.For(left).CompareTo(FactorioVersion.For(right)));
}
