/// <summary>
/// Handles the mods versions {modid} command.
/// </summary>
/// <param name="domain">Domain handler to use for lookup.</param>
/// <param name="modIdentifier">Mod to lookup versions for.</param>
public static void HandleModVersions(IDomain domain, string modIdentifier)
{
IDomainHandler handler = domain.GetDomainHandler();
ModMetadata meta = handler.GetModMetadata(Modifi.DefaultPack.MinecraftVersion, modIdentifier).Result;
IEnumerable <ModVersion> latestVersions = handler.GetRecentVersions(meta).Result;
// ModHelper.PrintModInformation(meta);
foreach (ModVersion version in latestVersions)
{
Console.Write("[");
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write(version.GetModVersion());
Console.ForegroundColor = ConsoleColor.White;
Console.Write("] ");
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(version.GetVersionName());
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" (");
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write(version.GetReleaseType());
Console.ForegroundColor = ConsoleColor.White;
Console.Write(")");
Console.ResetColor();
Console.WriteLine();
}
}
public static ModDownloadResult?HandleModDownload(IDomain domain, string modIdentifier, string modVersion = null)
{
IDomainHandler handler = domain.GetDomainHandler();
// Fetch the mod version information from the Curseforge API
try {
ModMetadata meta = handler.GetModMetadata(Modifi.DefaultPack.MinecraftVersion, modIdentifier).Result;
ModVersion mod = handler.GetModVersion(meta, modVersion).Result;
return(handler.DownloadMod(mod, Settings.ModPath).Result);
}
catch (Exception) { return(null); }
}
private static void DownloadPack()
{
using (Pack p = Modifi.DefaultPack) {
ILogger log = Modifi.DefaultLogger;
log.Information("Downloading modpack.");
log.Information(Environment.NewLine);
IDomain curseforge;
try {
curseforge = DomainHelper.LoadDomain(p, "curseforge");
}
catch (DllNotFoundException) {
log.Error("Cannot install mods; curseforge domain handler not found.");
return;
}
IDomainHandler handler = curseforge.GetDomainHandler();
using (ModStorage storage = new ModStorage(p.Installed, curseforge)) {
IEnumerable <ModMetadata> mods = storage.GetAllMods();
foreach (ModMetadata mod in mods)
{
log.Information("Installing: {0:l}", mod.GetName());
ModStatus status;
try { status = storage.GetModStatus(mod); }
catch (Exception) {
log.Error("Error: Mod marked installed but checksum did not match.");
log.Error("Please use the remove command and re-add it, or download the version manually.");
continue;
}
switch (status)
{
case ModStatus.Installed:
log.Information("Skipping, already installed.");
log.Information(Environment.NewLine);
continue;
case ModStatus.Requested:
ModVersion version = storage.GetMod(mod);
log.Information("Requested Version: {0:l} ({1})", version.GetVersionName(), version.GetModVersion());
try {
ModDownloadResult result = handler.DownloadMod(version, Settings.ModPath).Result;
storage.MarkInstalled(mod, version, result);
log.Information("Downloaded to {0}.", result.Filename);
log.Information(Environment.NewLine);
}
catch (Exception e) {
log.Error(e.Message);
log.Error(Environment.NewLine);
}
break;
}
}
}
}
}
public static void HandleModRemove(IDomain domain, string modIdentifier)
{
IDomainHandler handler = domain.GetDomainHandler();
ModStorage storage = new ModStorage(Modifi.DefaultPack.Installed, domain);
ModMetadata meta = storage.GetMetadata(modIdentifier);
if (meta == null)
{
Modifi.DefaultLogger.Error("Cannot uninstall {0}; it is not installed.", modIdentifier);
return;
}
ModVersion installed = storage.GetMod(meta);
ModStatus status = storage.GetModStatus(meta);
switch (status)
{
case ModStatus.NotInstalled:
Modifi.DefaultLogger.Error("Cannot uninstall {0}; it is not installed.", meta.GetName());
return;
case ModStatus.Requested:
Modifi.DefaultLogger.Information("Removing {0}...", meta.GetName());
storage.Delete(meta);
Modifi.DefaultLogger.Information("Done.");
return;
case ModStatus.Installed:
Modifi.DefaultLogger.Information("Removing {0} and deleting files...", meta.GetName());
storage.Delete(meta);
string filePath = Path.Combine(Settings.ModPath, installed.Filename);
bool correctChecksum = ModUtilities.ChecksumMatches(filePath, installed.Checksum);
if (correctChecksum)
{
try {
File.Delete(filePath);
}
catch (Exception e) {
Modifi.DefaultLogger.Error("Error deleting {0}, please delete it manually.", filePath);
Modifi.DefaultLogger.Error(e.Message);
}
}
else
{
Modifi.DefaultLogger.Information("File for {0} found at {1}, but the checksum did not match. Delete?", meta.GetName(), filePath);
Menu <string> delete = new Menu <string>();
delete.AddItem("Delete");
delete.AddItem("Leave");
delete.DrawMenu();
switch (delete.SelectedOption.ToLower())
{
case "delete":
File.Delete(filePath);
Modifi.DefaultLogger.Information("File deleted.");
break;
case "leave":
Modifi.DefaultLogger.Information("File left in place.");
break;
}
}
break;
}
storage.Dispose();
}
public static void HandleModAdd(IDomain domain, string modIdentifier, string modVersion = null)
{
IDomainHandler handler = domain.GetDomainHandler();
ModMetadata meta = handler.GetModMetadata(Modifi.DefaultPack.MinecraftVersion, modIdentifier).Result;
// Check mod installation status, error out if already requested/installed
using (IModStorage storage = new ModStorage(Modifi.DefaultPack.Installed, domain)) {
try {
ModStatus status = storage.GetModStatus(meta);
switch (status)
{
case ModStatus.Requested:
case ModStatus.Installed:
Modifi.DefaultLogger.Error("Mod {0} is already marked as requested, or already installed.", meta.GetName());
return;
case ModStatus.Disabled:
Modifi.DefaultLogger.Information("Mod {0} is marked at disabled. Please either delete it, or re-enable it.");
return;
}
}
catch (Exception e) {
Modifi.DefaultLogger.Error(e.Message);
return;
}
}
// If the version is already specified, don't ask, just add it
if (!String.IsNullOrEmpty(modVersion))
{
ModVersion v = handler.GetModVersion(meta, modVersion).Result;
// Connect to storage and mark the mod as requested
using (ModStorage storage = new ModStorage(Modifi.DefaultPack.MinecraftVersion, domain)) {
storage.MarkRequested(meta, v);
return;
}
}
// ============================================================
// TODO: ModHelper.PrintModInformation(meta);
Menu <ModVersion> menu = new Menu <ModVersion>();
menu.OptionFormatter = (opt) => {
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(opt.GetVersionName());
Console.ForegroundColor = ConsoleColor.DarkMagenta;
Console.Write(" [");
Console.ForegroundColor = ConsoleColor.White;
Console.Write(opt.GetModVersion());
Console.ForegroundColor = ConsoleColor.DarkMagenta;
Console.Write("]");
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write(" [{0}]", opt.GetReleaseType());
Console.WriteLine();
};
ModVersion latestRelease = handler.GetRecentVersions(meta, 1, ModReleaseType.Release).Result.First();
ModVersion latestVersion = handler.GetRecentVersions(meta, 1, ModReleaseType.Any).Result.First();
IEnumerable <ModVersion> versions = handler.GetRecentVersions(meta, 6, ModReleaseType.Any).Result.Skip(1);
menu.AddItem(latestRelease);
if (latestVersion.GetModVersion() != latestRelease.GetModVersion())
{
menu.AddItem(latestVersion);
}
menu.AddSpacer();
foreach (ModVersion v in versions.Take(5))
{
menu.AddItem(v);
}
menu.DrawMenu();
Console.ResetColor();
Console.WriteLine();
ModVersion version = menu.SelectedOption;
Console.WriteLine("Selected Version: " + version.GetModVersion());
// Create a storage handler for the domain and mark the version as requested
using (ModStorage storage = new ModStorage(Modifi.DefaultPack.Installed, domain)) {
storage.MarkRequested(meta, version);
}
}
public ApplicationService(IUnitOfWork unitOfWork)
{
this._unitOfWork = unitOfWork;
this.Notifications = DomainEvent.Container.GetInstance <IDomainHandler <DomainNotification> >();
}
