/// <summary> /// import mods as an asynchronous operation. /// </summary> /// <param name="importType">Type of the import.</param> /// <param name="file">The file.</param> /// <returns>IModCollection.</returns> protected virtual async Task <IModCollection> ImportModsAsync(ImportType importType, string file = Shared.Constants.EmptyParam) { async Task <IModCollection> performImport(IGame game) { var instance = Create(); var parameters = new ModCollectionExporterParams() { ModDirectory = Path.Combine(game.UserDirectory, Shared.Constants.ModDirectory), File = file, Mod = instance }; ICollectionImportResult result = null; switch (importType) { case ImportType.Paradox: result = await modCollectionExporter.ImportParadoxAsync(parameters); break; case ImportType.ParadoxLauncher: result = await modCollectionExporter.ImportParadoxLauncherAsync(parameters); break; case ImportType.Paradoxos: result = await modCollectionExporter.ImportParadoxosAsync(parameters); break; case ImportType.ParadoxLauncherBeta: result = await modCollectionExporter.ImportParadoxLauncherBetaAsync(parameters); break; case ImportType.ParadoxLauncherJson: result = await modCollectionExporter.ImportParadoxLauncherJsonAsync(parameters); break; default: break; } if (result != null) { // Order of operations is very important here MapImportResult(instance, result); return(instance); } return(null); } var game = GameService.GetSelected(); if (game == null) { return(null); } return(await performImport(game)); }
/// <summary> /// import as an asynchronous operation. /// </summary> /// <param name="file">The file.</param> /// <returns>Task<IModCollection>.</returns> public async Task <IModCollection> ImportAsync(string file) { var game = GameService.GetSelected(); if (game == null) { return(null); } var instance = await GetImportedCollectionDetailsAsync(file); if (instance != null) { // Incase selected game != imported collection game if (!game.Type.Equals(instance.Game)) { game = GameService.Get().FirstOrDefault(p => p.Type.Equals(instance.Game)); } var path = GetPatchModDirectory(game, instance); var exportPath = GetPatchModDirectory(game, !string.IsNullOrWhiteSpace(instance.MergedFolderName) ? instance.MergedFolderName : instance.Name); var result = await modCollectionExporter.ImportModDirectoryAsync(new ModCollectionExporterParams() { File = file, ModDirectory = path, Mod = instance, ExportModDirectory = exportPath }); if (result) { return(instance); } } return(null); }
/// <summary> /// export hash report as an asynchronous operation. /// </summary> /// <param name="mods">The mods.</param> /// <param name="path">The path.</param> /// <returns>Task<System.Boolean>.</returns> public virtual async Task <bool> ExportHashReportAsync(IEnumerable <IMod> mods, string path) { if (!string.IsNullOrWhiteSpace(path) && mods?.Count() > 0) { var modExport = mods.ToList(); var collection = GetAllModCollectionsInternal().FirstOrDefault(p => p.IsSelected); var patchModName = GenerateCollectionPatchName(collection.Name); var allMods = GetInstalledModsInternal(GameService.GetSelected(), false); var patchMod = allMods.FirstOrDefault(p => p.Name.Equals(patchModName)); if (patchMod == null) { var game = GameService.GetSelected(); if (await ModWriter.ModDirectoryExistsAsync(new ModWriterParameters() { RootDirectory = GetPatchModDirectory(game, patchModName) })) { patchMod = GeneratePatchModDescriptor(allMods, game, patchModName); } } if (patchMod != null && collection.PatchModEnabled) { if (patchMod.Files == null || !patchMod.Files.Any()) { await PopulateModFilesInternalAsync(new List <IMod>() { patchMod }); } modExport.Add(patchMod); } var reports = await ParseReportAsync(modExport); return(await exportService.ExportAsync(reports, path)); } return(false); }
/// <summary> /// Purges the mod directory asynchronous. /// </summary> /// <param name="folder">The folder.</param> /// <returns>Task<System.Boolean>.</returns> public virtual async Task <bool> PurgeModDirectoryAsync(string folder) { var game = GameService.GetSelected(); if (game == null) { return(false); } var fullPath = Path.Combine(game.UserDirectory, Shared.Constants.ModDirectory, folder); var result = await ModWriter.PurgeModDirectoryAsync(new ModWriterParameters() { RootDirectory = game.UserDirectory, Path = Path.Combine(Shared.Constants.ModDirectory, folder) }, true); var mods = GetInstalledModsInternal(game, false); if (mods.Any(p => !string.IsNullOrWhiteSpace(p.FullPath) && p.FullPath.Contains(fullPath))) { var mod = mods.Where(p => p.FullPath.Contains(fullPath)); if (mod.Any()) { await DeleteDescriptorsInternalAsync(mod); } } return(result); }
/// <summary> /// delete descriptors internal as an asynchronous operation. /// </summary> /// <param name="mods">The mods.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> protected virtual async Task <bool> DeleteDescriptorsInternalAsync(IEnumerable <IMod> mods) { var game = GameService.GetSelected(); if (game != null && mods?.Count() > 0) { var tasks = new List <Task>(); foreach (var item in mods) { var task = ModWriter.DeleteDescriptorAsync(new ModWriterParameters() { Mod = item, RootDirectory = game.UserDirectory }); tasks.Add(task); } await Task.WhenAll(tasks); Cache.Invalidate(new CacheInvalidateParameters() { Region = ModsCacheRegion, Prefix = game.Type, Keys = new List <string> { GetModsCacheKey(true), GetModsCacheKey(false) } }); return(true); } return(false); }
/// <summary> /// lock descriptors as an asynchronous operation. /// </summary> /// <param name="mods">The mods.</param> /// <param name="isLocked">if set to <c>true</c> [is locked].</param> /// <returns>Task<System.Boolean>.</returns> public virtual async Task <bool> LockDescriptorsAsync(IEnumerable <IMod> mods, bool isLocked) { var game = GameService.GetSelected(); if (game != null && mods?.Count() > 0) { var tasks = new List <Task>(); foreach (var item in mods) { // Cannot lock\unlock mandatory local zipped mods if (!CheckIfModShouldBeLocked(game, item)) { var task = ModWriter.SetDescriptorLockAsync(new ModWriterParameters() { Mod = item, RootDirectory = game.UserDirectory }, isLocked); item.IsLocked = isLocked; tasks.Add(task); } } await Task.WhenAll(tasks); return(true); } return(false); }
/// <summary> /// Saves the specified collection. /// </summary> /// <param name="collection">The collection.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">collection</exception> public virtual bool Save(IModCollection collection) { if (collection == null || string.IsNullOrWhiteSpace(collection.Game)) { throw new ArgumentNullException(nameof(collection)); } var game = GameService.GetSelected(); if (game == null) { return(false); } lock (serviceLock) { var collections = StorageProvider.GetModCollections().ToList(); if (collections.Count > 0) { var existing = collections.FirstOrDefault(p => p.Name.Equals(collection.Name, StringComparison.OrdinalIgnoreCase) && p.Game.Equals(collection.Game)); if (existing != null) { collections.Remove(existing); } if (collection.IsSelected) { foreach (var item in collections.Where(p => p.Game.Equals(collection.Game) && p.IsSelected)) { item.IsSelected = false; } } } collections.Add(collection); return(StorageProvider.SetModCollections(collections)); } }
/// <summary> /// Gets the collection mods. /// </summary> /// <param name="mods">The mods.</param> /// <param name="collectionName">Name of the collection.</param> /// <returns>IEnumerable<IMod>.</returns> protected virtual IEnumerable <IMod> GetCollectionMods(IEnumerable <IMod> mods = null, string collectionName = Shared.Constants.EmptyParam) { if (mods == null) { mods = GetInstalledModsInternal(GameService.GetSelected(), false); } var collectionMods = new List <IMod>(); var collections = GetAllModCollectionsInternal(); if (collections?.Count() > 0) { IModCollection collection; if (!string.IsNullOrWhiteSpace(collectionName)) { collection = collections.FirstOrDefault(p => p.Name.Equals(collectionName, StringComparison.OrdinalIgnoreCase)); } else { collection = collections.FirstOrDefault(p => p.IsSelected); } if (collection != null) { foreach (var item in collection.Mods) { var mod = mods.FirstOrDefault(p => p.DescriptorFile.Equals(item, StringComparison.OrdinalIgnoreCase)); if (mod != null) { collectionMods.Add(mod); } } } } return(collectionMods); }
/// <summary> /// import as an asynchronous operation. /// </summary> /// <param name="file">The file.</param> /// <returns>Task<IModCollection>.</returns> public async Task <IModCollection> ImportAsync(string file) { var game = GameService.GetSelected(); if (game == null) { return(null); } var instance = await GetImportedCollectionDetailsAsync(file); if (instance != null) { var path = GetModDirectory(game, instance); if (await modCollectionExporter.ImportModDirectoryAsync(new ModCollectionExporterParams() { File = file, ModDirectory = path, Mod = instance })) { return(instance); } } return(null); }
/// <summary> /// import as an asynchronous operation. /// </summary> /// <param name="file">The file.</param> /// <returns>Task<IModCollection>.</returns> public async Task <IModCollection> ImportAsync(string file) { var game = GameService.GetSelected(); if (game == null) { return(null); } var instance = await GetImportedCollectionDetailsAsync(file); if (instance != null) { var path = GetPatchModDirectory(game, instance); var exportPath = GetPatchModDirectory(game, !string.IsNullOrWhiteSpace(instance.MergedFolderName) ? instance.MergedFolderName : instance.Name); if (await modCollectionExporter.ImportModDirectoryAsync(new ModCollectionExporterParams() { File = file, ModDirectory = path, Mod = instance, ExportModDirectory = exportPath })) { return(instance); } } return(null); }
/// <summary> /// Exports the asynchronous. /// </summary> /// <param name="file">The file.</param> /// <param name="modCollection">The mod collection.</param> /// <param name="exportOrderOnly">if set to <c>true</c> [export order only].</param> /// <param name="exportMods">if set to <c>true</c> [export mods].</param> /// <returns>Task<System.Boolean>.</returns> public virtual Task <bool> ExportAsync(string file, IModCollection modCollection, bool exportOrderOnly = false, bool exportMods = false) { var game = GameService.GetSelected(); if (game == null || modCollection == null) { return(Task.FromResult(false)); } var collection = Mapper.Map <IModCollection>(modCollection); if (string.IsNullOrWhiteSpace(collection.MergedFolderName) && exportMods) { collection.MergedFolderName = collection.Name.GenerateValidFileName(); } var path = GetPatchModDirectory(game, modCollection); var parameters = new ModCollectionExporterParams() { File = file, Mod = collection, ModDirectory = path, ExportModOrderOnly = exportOrderOnly }; if (exportMods) { parameters.ExportMods = GetCollectionMods(collectionName: modCollection.Name); } return(modCollectionExporter.ExportAsync(parameters)); }
/// <summary> /// install mods as an asynchronous operation. /// </summary> /// <returns>Task<System.Boolean>.</returns> public virtual async Task <bool> InstallModsAsync() { var game = GameService.GetSelected(); if (game == null) { return(false); } var mods = GetInstalledModsInternal(game, false); var descriptors = new List <IMod>(); var userDirectoryMods = GetAllModDescriptors(Path.Combine(game.UserDirectory, Shared.Constants.ModDirectory), ModSource.Local); if (userDirectoryMods?.Count() > 0) { descriptors.AddRange(userDirectoryMods); } var workshopDirectoryMods = GetAllModDescriptors(game.WorkshopDirectory, ModSource.Steam); if (workshopDirectoryMods?.Count() > 0) { descriptors.AddRange(workshopDirectoryMods); } var diffs = descriptors.Where(p => !mods.Any(m => m.DescriptorFile.Equals(p.DescriptorFile, StringComparison.OrdinalIgnoreCase))).ToList(); if (diffs.Count > 0) { await ModWriter.CreateModDirectoryAsync(new ModWriterParameters() { RootDirectory = game.UserDirectory, Path = Shared.Constants.ModDirectory }); var tasks = new List <Task>(); foreach (var diff in diffs) { if (IsPatchModInternal(diff)) { continue; } tasks.Add(ModWriter.WriteDescriptorAsync(new ModWriterParameters() { Mod = diff, RootDirectory = game.UserDirectory, Path = diff.DescriptorFile }, IsPatchModInternal(diff))); } if (tasks.Count > 0) { await Task.WhenAll(tasks); Cache.Invalidate(ModsCachePrefix, ConstructModsCacheKey(game, true), ConstructModsCacheKey(game, false)); } return(true); } return(false); }
/// <summary> /// Exports the mods asynchronous. /// </summary> /// <param name="enabledMods">The mods.</param> /// <param name="regularMods">The regular mods.</param> /// <param name="modCollection">The mod collection.</param> /// <returns>Task<System.Boolean>.</returns> public virtual async Task <bool> ExportModsAsync(IReadOnlyCollection <IMod> enabledMods, IReadOnlyCollection <IMod> regularMods, IModCollection modCollection) { var game = GameService.GetSelected(); if (game == null || enabledMods == null || regularMods == null || modCollection == null) { return(false); } var allMods = GetInstalledModsInternal(game, false); var mod = GeneratePatchModDescriptor(allMods, game, GenerateCollectionPatchName(modCollection.Name)); var applyModParams = new ModWriterParameters() { OtherMods = regularMods.Where(p => !enabledMods.Any(m => m.DescriptorFile.Equals(p.DescriptorFile))).ToList(), EnabledMods = enabledMods, RootDirectory = game.UserDirectory }; if (await ModWriter.ModDirectoryExistsAsync(new ModWriterParameters() { RootDirectory = mod.FullPath })) { if (modCollection.PatchModEnabled && enabledMods.Any()) { if (await ModWriter.WriteDescriptorAsync(new ModWriterParameters() { Mod = mod, RootDirectory = game.UserDirectory, Path = mod.DescriptorFile, LockDescriptor = CheckIfModShouldBeLocked(game, mod) }, IsPatchModInternal(mod))) { applyModParams.TopPriorityMods = new List <IMod>() { mod }; Cache.Invalidate(new CacheInvalidateParameters() { Region = ModsCacheRegion, Prefix = game.Type, Keys = new List <string> { GetModsCacheKey(true), GetModsCacheKey(false) } }); } } } else { // Remove left over descriptor if (allMods.Any(p => p.Name.Equals(mod.Name))) { await DeleteDescriptorsInternalAsync(new List <IMod>() { mod }); } } return(await ModWriter.ApplyModsAsync(applyModParams)); }
/// <summary> /// Gets the image stream asynchronous. /// </summary> /// <param name="modName">Name of the mod.</param> /// <param name="path">The path.</param> /// <returns>Task<MemoryStream>.</returns> public virtual Task <MemoryStream> GetImageStreamAsync(string modName, string path) { var game = GameService.GetSelected(); if (game == null || string.IsNullOrWhiteSpace(modName)) { return(Task.FromResult((MemoryStream)null)); } var mods = GetInstalledModsInternal(game, false); return(GetImageStreamAsync(mods.FirstOrDefault(p => p.Name.Equals(modName)), path)); }
/// <summary> /// Creates this instance. /// </summary> /// <returns>IModCollection.</returns> public virtual IModCollection Create() { var game = GameService.GetSelected(); if (game == null) { return(null); } var instance = GetModelInstance <IModCollection>(); instance.Game = game.Type; return(instance); }
/// <summary> /// Mods the directory exists asynchronous. /// </summary> /// <param name="folder">The folder.</param> /// <returns>Task<System.Boolean>.</returns> public virtual Task <bool> ModDirectoryExistsAsync(string folder) { var game = GameService.GetSelected(); if (game == null) { return(Task.FromResult(false)); } return(ModWriter.ModDirectoryExistsAsync(new ModWriterParameters() { RootDirectory = game.UserDirectory, Path = Path.Combine(Shared.Constants.ModDirectory, folder) })); }
/// <summary> /// Evals the achievement compatibility. /// </summary> /// <param name="mods">The mods.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> public virtual bool EvalAchievementCompatibility(IEnumerable <IMod> mods) { var game = GameService.GetSelected(); if (game != null && mods?.Count() > 0) { foreach (var item in mods.Where(p => p.IsValid)) { var isAchievementCompatible = !item.Files.Any(p => game.ChecksumFolders.Any(s => p.StartsWith(s, StringComparison.OrdinalIgnoreCase))); item.AchievementStatus = isAchievementCompatible ? AchievementStatus.Compatible : AchievementStatus.NotCompatible; } return(true); } return(false); }
/// <summary> /// Gets the image stream asynchronous. /// </summary> /// <param name="mod">The mod.</param> /// <param name="path">The path.</param> /// <param name="isFromGame">if set to <c>true</c> [is from game].</param> /// <returns>Task<MemoryStream>.</returns> public virtual Task <MemoryStream> GetImageStreamAsync(IMod mod, string path, bool isFromGame = false) { if (!isFromGame) { if (mod != null && !string.IsNullOrWhiteSpace(path)) { return(Reader.GetImageStreamAsync(mod.FullPath, path)); } } else { return(Reader.GetImageStreamAsync(Path.GetDirectoryName(GameService.GetSelected().ExecutableLocation), path)); } return(Task.FromResult((MemoryStream)null)); }
/// <summary> /// Gets all mod collections internal. /// </summary> /// <returns>IEnumerable<IModCollection>.</returns> protected virtual IEnumerable <IModCollection> GetAllModCollectionsInternal() { var game = GameService.GetSelected(); if (game == null) { return(new List <IModCollection>()); } var collections = StorageProvider.GetModCollections().Where(s => s.Game.Equals(game.Type)); if (collections.Count() > 0) { return(collections.OrderBy(p => p.Name)); } return(new List <IModCollection>()); }
/// <summary> /// Gets the specified name. /// </summary> /// <param name="name">The name.</param> /// <returns>IModCollection.</returns> public virtual IModCollection Get(string name) { var game = GameService.GetSelected(); if (game == null) { return(null); } var collections = StorageProvider.GetModCollections(); if (collections?.Count() > 0) { var collection = collections.FirstOrDefault(c => c.Name.Equals(name, StringComparison.OrdinalIgnoreCase) && c.Game.Equals(game.Type)); return(collection); } return(null); }
/// <summary> /// Exports the asynchronous. /// </summary> /// <param name="file">The file.</param> /// <param name="modCollection">The mod collection.</param> /// <param name="exportOrderOnly">if set to <c>true</c> [export order only].</param> /// <returns>Task<System.Boolean>.</returns> public virtual Task <bool> ExportAsync(string file, IModCollection modCollection, bool exportOrderOnly = false) { var game = GameService.GetSelected(); if (game == null || modCollection == null) { return(Task.FromResult(false)); } var path = GetModDirectory(game, modCollection); return(modCollectionExporter.ExportAsync(new ModCollectionExporterParams() { File = file, Mod = modCollection, ModDirectory = path, ExportModOrderOnly = exportOrderOnly })); }
/// <summary> /// Populates the mod path. /// </summary> /// <param name="definitions">The definitions.</param> /// <param name="collectionMods">The collection mods.</param> /// <returns>IEnumerable<IDefinition>.</returns> protected virtual IEnumerable <IDefinition> PopulateModPath(IEnumerable <IDefinition> definitions, IEnumerable <IMod> collectionMods) { if (definitions?.Count() > 0) { foreach (var item in definitions) { if (IsPatchModInternal(item.ModName)) { item.ModPath = GetModDirectory(GameService.GetSelected(), item.ModName); } else { item.ModPath = collectionMods.FirstOrDefault(p => p.Name.Equals(item.ModName)).FullPath; } } } return(definitions); }
/// <summary> /// Exports the paradox launcher json asynchronous. /// </summary> /// <param name="file">The file.</param> /// <param name="modCollection">The mod collection.</param> /// <returns>Task<System.Boolean>.</returns> public virtual Task <bool> ExportParadoxLauncherJsonAsync(string file, IModCollection modCollection) { var game = GameService.GetSelected(); if (game == null || modCollection == null) { return(Task.FromResult(false)); } var collection = Mapper.Map <IModCollection>(modCollection); var parameters = new ModCollectionExporterParams() { File = file, Mod = collection, ExportMods = GetCollectionMods(collectionName: modCollection.Name), Game = game }; return(modCollectionExporter.ExportParadoxLauncherJsonAsync(parameters)); }
/// <summary> /// get imported collection details as an asynchronous operation. /// </summary> /// <param name="file">The file.</param> /// <returns>Task<IModCollection>.</returns> public virtual async Task <IModCollection> GetImportedCollectionDetailsAsync(string file) { var game = GameService.GetSelected(); if (game == null) { return(null); } var instance = GetModelInstance <IModCollection>(); var result = await modCollectionExporter.ImportAsync(new ModCollectionExporterParams() { File = file, Mod = instance }); if (result) { return(instance); } return(null); }
/// <summary> /// Imports the hash report asynchronous. /// </summary> /// <param name="mods">The mods.</param> /// <param name="path">The path.</param> /// <returns>Task<IEnumerable<IModHashReport>>.</returns> public virtual async Task <IEnumerable <IModHashReport> > ImportHashReportAsync(IEnumerable <IMod> mods, string path) { var modExport = mods.ToList(); var collection = GetAllModCollectionsInternal().FirstOrDefault(p => p.IsSelected); var patchModName = GenerateCollectionPatchName(collection.Name); var allMods = GetInstalledModsInternal(GameService.GetSelected(), false); var patchMod = allMods.FirstOrDefault(p => p.Name.Equals(patchModName)); if (patchMod != null) { if (patchMod.Files == null || !patchMod.Files.Any()) { await PopulateModFilesInternalAsync(new List <IMod>() { patchMod }); } modExport.Add(patchMod); } var currentReports = await ParseReportAsync(modExport); var importedReports = await modReportExporter.ImportAsync(path); if (importedReports != null) {
/// <summary> /// Exports the mods asynchronous. /// </summary> /// <param name="enabledMods">The mods.</param> /// <param name="regularMods">The regular mods.</param> /// <param name="collectionName">Name of the collection.</param> /// <returns>Task<System.Boolean>.</returns> public virtual async Task <bool> ExportModsAsync(IReadOnlyCollection <IMod> enabledMods, IReadOnlyCollection <IMod> regularMods, string collectionName) { var game = GameService.GetSelected(); if (game == null || enabledMods == null || regularMods == null) { return(false); } var allMods = GetInstalledModsInternal(game, false); var mod = GeneratePatchModDescriptor(allMods, game, GenerateCollectionPatchName(collectionName)); var applyModParams = new ModWriterParameters() { OtherMods = regularMods.Where(p => !enabledMods.Any(m => m.DescriptorFile.Equals(p.DescriptorFile))).ToList(), EnabledMods = enabledMods, RootDirectory = game.UserDirectory }; if (await ModWriter.ModDirectoryExistsAsync(new ModWriterParameters() { RootDirectory = game.UserDirectory, Path = mod.FileName })) { if (await ModWriter.WriteDescriptorAsync(new ModWriterParameters() { Mod = mod, RootDirectory = game.UserDirectory, Path = mod.DescriptorFile }, IsPatchModInternal(mod))) { applyModParams.TopPriorityMods = new List <IMod>() { mod }; Cache.Invalidate(ModsCachePrefix, ConstructModsCacheKey(game, true), ConstructModsCacheKey(game, false)); } } return(await ModWriter.ApplyModsAsync(applyModParams)); }
/// <summary> /// lock descriptors as an asynchronous operation. /// </summary> /// <param name="mods">The mods.</param> /// <param name="isLocked">if set to <c>true</c> [is locked].</param> /// <returns>Task<System.Boolean>.</returns> public virtual async Task <bool> LockDescriptorsAsync(IEnumerable <IMod> mods, bool isLocked) { var game = GameService.GetSelected(); if (game != null && mods?.Count() > 0) { var tasks = new List <Task>(); foreach (var item in mods) { var task = ModWriter.SetDescriptorLockAsync(new ModWriterParameters() { Mod = item, RootDirectory = game.UserDirectory }, isLocked); tasks.Add(task); } await Task.WhenAll(tasks); return(true); } return(false); }
/// <summary> /// Deletes the specified name. /// </summary> /// <param name="name">The name.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> public virtual bool Delete(string name) { var game = GameService.GetSelected(); if (game == null) { return(false); } lock (serviceLock) { var collections = StorageProvider.GetModCollections().ToList(); if (collections.Count > 0) { var existing = collections.FirstOrDefault(p => p.Game.Equals(game.Type) && p.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); if (existing != null) { collections.Remove(existing); return(StorageProvider.SetModCollections(collections)); } } } return(false); }
/// <summary> /// export hash report as an asynchronous operation. /// </summary> /// <param name="mods">The mods.</param> /// <param name="path">The path.</param> /// <returns>Task<System.Boolean>.</returns> public virtual async Task <bool> ExportHashReportAsync(IEnumerable <IMod> mods, string path) { if (!string.IsNullOrWhiteSpace(path) && mods?.Count() > 0) { var modExport = mods.ToList(); var collection = GetAllModCollectionsInternal().FirstOrDefault(p => p.IsSelected); var patchModName = GenerateCollectionPatchName(collection.Name); var allMods = GetInstalledModsInternal(GameService.GetSelected(), false); var patchMod = allMods.FirstOrDefault(p => p.Name.Equals(patchModName)); if (patchMod != null) { if (patchMod.Files == null || patchMod.Files.Count() == 0) { await PopulateModFilesInternalAsync(new List <IMod>() { patchMod }); } modExport.Add(patchMod); } var reports = await ParseReportAsync(modExport); return(await modReportExporter.ExportAsync(reports, path)); } return(false); }
/// <summary> /// parse report as an asynchronous operation. /// </summary> /// <param name="mods">The mods.</param> /// <returns>IEnumerable<IModHashReport>.</returns> protected virtual async Task <IEnumerable <IHashReport> > ParseReportAsync(IEnumerable <IMod> mods) { var game = GameService.GetSelected(); var reports = new List <IHashReport>(); var total = mods.SelectMany(p => p.Files).Count(p => game.GameFolders.Any(a => p.StartsWith(a))); var progress = 0; double lastPercentage = 0; foreach (var mod in mods) { var report = GetModelInstance <IHashReport>(); report.Name = mod.Name; report.ReportType = HashReportType.Collection; var hashReports = new List <IHashFileReport>(); foreach (var item in mod.Files.Where(p => game.GameFolders.Any(a => p.StartsWith(a)))) { var info = Reader.GetFileInfo(mod.FullPath, item); if (info != null) { var fileReport = GetModelInstance <IHashFileReport>(); fileReport.File = item; fileReport.Hash = info.ContentSHA; hashReports.Add(fileReport); } progress++; var percentage = GetProgressPercentage(total, progress); if (percentage != lastPercentage) { await messageBus.PublishAsync(new ModReportExportEvent(1, percentage)); } lastPercentage = percentage; } report.Reports = hashReports; reports.Add(report); } return(reports); }