/// <summary>
/// import as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public async Task <bool> ImportAsync(ModCollectionExporterParams parameters)
{
var path = Path.Combine(Path.GetDirectoryName(parameters.ModDirectory), Constants.DLC_load_path);
if (File.Exists(path))
{
var content = await File.ReadAllTextAsync(path);
if (!string.IsNullOrWhiteSpace(content))
{
try
{
var model = JsonConvert.DeserializeObject <DLCLoad>(content);
if (model.EnabledMods?.Count > 0)
{
parameters.Mod.Name = CollectionName;
parameters.Mod.Mods = model.EnabledMods;
return(true);
}
}
catch (Exception ex)
{
logger.Error(ex);
}
}
}
return(false);
}
/// <summary>
/// Database importv3 as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>A Task<ICollectionImportResult> representing the asynchronous operation.</returns>
protected virtual async Task <ICollectionImportResult> DatabaseImportv3Async(ModCollectionExporterParams parameters)
{
try
{
using var con = GetConnection(parameters);
var activeCollection = (await con.QueryAsync <Models.Paradox.v4.Playsets>(p => p.IsActive == true, trace: trace)).FirstOrDefault();
if (activeCollection != null)
{
var collectionMods = await con.QueryAsync <Models.Paradox.v4.PlaysetsMods>(p => p.PlaysetId == activeCollection.Id.ToString(), trace : trace);
if (collectionMods?.Count() > 0)
{
var mods = await con.QueryAllAsync <Models.Paradox.v4.Mods>(trace : trace);
var ordered = collectionMods.Where(p => p.Enabled).OrderBy(p => p.Position).ToList();
var validMods = mods.Where(p => ordered.Any(m => m.ModId.Equals(p.Id))).OrderBy(p => ordered.FindIndex(o => o.ModId == p.Id));
if (validMods.Any())
{
var result = DIResolver.Get <ICollectionImportResult>();
result.Name = activeCollection.Name;
result.Descriptors = validMods.Select(p => p.GameRegistryId).ToList();
result.ModNames = validMods.Select(p => p.DisplayName).ToList();
return(result);
}
}
}
}
catch (Exception ex)
{
logger.Error(ex);
}
return(null);
}
/// <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>
/// 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>
/// import as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public async Task <bool> ImportAsync(ModCollectionExporterParams parameters)
{
try
{
using var con = GetConnection(parameters);
var activeCollection = (await con.QueryAsync <Playsets>(p => p.IsActive == true, trace: trace)).FirstOrDefault();
if (activeCollection != null)
{
var collectionMods = await con.QueryAsync <PlaysetsMods>(p => p.PlaysetId == activeCollection.Id.ToString(), trace : trace);
if (collectionMods?.Count() > 0)
{
var mods = await con.QueryAllAsync <Models.Paradox.v2.Mods>(trace : trace);
var ordered = collectionMods.Where(p => p.Enabled).OrderBy(p => p.Position).ToList();
var validMods = mods.Where(p => ordered.Any(m => m.ModId.Equals(p.Id))).OrderBy(p => ordered.FindIndex(o => o.ModId == p.Id));
if (validMods.Count() > 0)
{
parameters.Mod.Name = activeCollection.Name;
parameters.Mod.Mods = validMods.Select(p => p.GameRegistryId).ToList();
return(true);
}
}
}
}
catch (Exception ex)
{
logger.Error(ex);
}
return(false);
}
/// <summary>
/// Imports the asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <ICollectionImportResult> ImportAsync(ModCollectionExporterParams parameters)
{
var importResult = ImportInternal(parameters, true, out var result);
if (importResult)
{
return(Task.FromResult(result));
}
return(Task.FromResult((ICollectionImportResult)null));
}
/// <summary>
/// database import as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public async Task <ICollectionImportResult> DatabaseImportAsync(ModCollectionExporterParams parameters)
{
// Caching sucks in this ORM
DbFieldCache.Flush();
FieldCache.Flush();
IdentityCache.Flush();
PrimaryCache.Flush();
if (await IsV4Async(parameters))
{
return(await DatabaseImportv3Async(parameters));
}
return(await DatabaseImportv2Async(parameters));
}
/// <summary>
/// Is v4 as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>A Task<System.Boolean> representing the asynchronous operation.</returns>
private async Task <bool> IsV4Async(ModCollectionExporterParams parameters)
{
try
{
using var con = GetConnection(parameters);
var changes = await con.QueryAllAsync <Models.Paradox.v2.KnoxMigrations>();
return(changes != null && changes.Any(c => c.Name.Equals(Constants.SqlV4Id.Name, StringComparison.OrdinalIgnoreCase) && c.Id.Equals(Constants.SqlV4Id.Id)));
}
catch
{
return(false);
}
}
/// <summary>
/// Exports the asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <bool> ExportAsync(ModCollectionExporterParams parameters)
{
var content = JsonConvert.SerializeObject(parameters.Mod, Formatting.None);
using var zip = ArchiveFactory.Create(ArchiveType.Zip);
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(content));
zip.AddEntry(Common.Constants.ExportedModContentId, stream, false);
if (Directory.Exists(parameters.ModDirectory) && !parameters.ExportModOrderOnly)
{
zip.AddAllFromDirectory(parameters.ModDirectory);
}
zip.SaveTo(parameters.File, new SharpCompress.Writers.WriterOptions(CompressionType.Deflate));
zip.Dispose();
return(Task.FromResult(true));
}
/// <summary>
/// Exports the asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public async Task <bool> ExportAsync(ModCollectionExporterParams parameters)
{
var content = JsonConvert.SerializeObject(parameters.Mod, Formatting.None);
using var zip = ArchiveFactory.Create(ArchiveType.Zip);
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(content));
zip.AddEntry(Common.Constants.ExportedModContentId, stream, false);
var streams = new List <MemoryStream>();
if (Directory.Exists(parameters.ModDirectory) && !parameters.ExportModOrderOnly)
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
zip.AddAllFromDirectory(parameters.ModDirectory);
}
else
{
// Yeah, osx sucks (ulimit bypass)
var files = Directory.GetFiles(parameters.ModDirectory, "*.*", SearchOption.AllDirectories);
foreach (var item in files)
{
var fs = new FileStream(item, FileMode.Open, FileAccess.Read, FileShare.Read);
var ms = new MemoryStream();
await fs.CopyToAsync(ms);
var file = item.Replace(parameters.ModDirectory, string.Empty).Trim('\\').Trim('/');
zip.AddEntry(file, ms, false, modified: new System.IO.FileInfo(item).LastWriteTime);
fs.Close();
await fs.DisposeAsync();
streams.Add(ms);
}
}
}
zip.SaveTo(parameters.File, new SharpCompress.Writers.WriterOptions(CompressionType.Deflate));
zip.Dispose();
if (streams.Any())
{
var task = streams.Select(async p =>
{
p.Close();
await p.DisposeAsync();
});
await Task.WhenAll(task);
}
return(true);
}
/// <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>
/// Export as an asynchronous operation.
/// </summary>
/// <param name="params">The parameters.</param>
/// <returns>A Task<System.Boolean> representing the asynchronous operation.</returns>
public async Task <bool> ExportAsync(ModCollectionExporterParams @params)
{
// Paradox launcher only exports pdx or steam mods, local mods are not exported
var validMods = @params.ExportMods.Where(p => p.Source != ModSource.Local).ToList();
var modInfo = new ModInfo()
{
Game = @params.Game.ParadoxGameId,
Name = @params.Mod.Name,
Mods = validMods.Select(p => new Models.Paradox.Json.v3.Mods()
{
DisplayName = p.Name,
Enabled = true,
Position = validMods.IndexOf(p),
SteamId = p.Source == ModSource.Steam ? p.RemoteId.ToString() : null,
PdxId = p.Source == ModSource.Paradox ? p.RemoteId.ToString() : null
}).ToList()
};
var json = JsonDISerializer.Serialize(modInfo);
await File.WriteAllTextAsync(@params.File, json);
return(true);
}
/// <summary>
/// Imports the mod directory asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <bool> ImportModDirectoryAsync(ModCollectionExporterParams parameters)
{
var result = ImportInternal(parameters, false, out _);
return(Task.FromResult(result));
}
/// <summary>
/// Imports the internal.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <param name="importInstance">if set to <c>true</c> [import instance].</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private bool ImportInternal(ModCollectionExporterParams parameters, bool importInstance)
{
if (!importInstance)
{
if (Directory.Exists(parameters.ModDirectory))
{
Directory.Delete(parameters.ModDirectory, true);
}
}
var result = false;
void parseUsingReaderFactory()
{
using var fileStream = File.OpenRead(parameters.File);
using var reader = ReaderFactory.Open(fileStream);
while (reader.MoveToNextEntry())
{
if (!reader.Entry.IsDirectory)
{
var relativePath = reader.Entry.Key.StandardizeDirectorySeparator().Trim(Path.DirectorySeparatorChar);
if (reader.Entry.Key.Equals(Common.Constants.ExportedModContentId, StringComparison.OrdinalIgnoreCase))
{
if (importInstance)
{
using var entryStream = reader.OpenEntryStream();
using var memoryStream = new MemoryStream();
entryStream.CopyTo(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
using var streamReader = new StreamReader(memoryStream, true);
var text = streamReader.ReadToEnd();
streamReader.Close();
JsonConvert.PopulateObject(text, parameters.Mod);
result = true;
break;
}
}
else
{
reader.WriteEntryToDirectory(parameters.ModDirectory, ZipExtractionOpts.GetExtractionOptions());
}
}
}
}
void parseUsingArchiveFactory()
{
using var fileStream = File.OpenRead(parameters.File);
using var reader = ArchiveFactory.Open(fileStream);
foreach (var entry in reader.Entries.Where(entry => !entry.IsDirectory))
{
var relativePath = entry.Key.StandardizeDirectorySeparator().Trim(Path.DirectorySeparatorChar);
if (entry.Key.Equals(Common.Constants.ExportedModContentId, StringComparison.OrdinalIgnoreCase))
{
if (importInstance)
{
using var entryStream = entry.OpenEntryStream();
using var memoryStream = new MemoryStream();
entryStream.CopyTo(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
using var streamReader = new StreamReader(memoryStream, true);
var text = streamReader.ReadToEnd();
streamReader.Close();
JsonConvert.PopulateObject(text, parameters.Mod);
result = true;
break;
}
}
else
{
entry.WriteToDirectory(parameters.ModDirectory, ZipExtractionOpts.GetExtractionOptions());
}
}
}
try
{
parseUsingReaderFactory();
}
catch (Exception ex)
{
logger.Error(ex);
result = false;
parseUsingArchiveFactory();
}
return(!importInstance || result);
}
/// <summary>
/// json import as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
/// <exception cref="System.NotSupportedException"></exception>
public override Task <ICollectionImportResult> JsonImportAsync(ModCollectionExporterParams parameters)
{
throw new NotSupportedException();
}
/// <summary>
/// import as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public async Task <bool> ImportAsync(ModCollectionExporterParams parameters)
{
if (File.Exists(parameters.File))
{
void map(ParadoxosExportedList model)
{
parameters.Mod.Name = model.ExportedList.Name;
IOrderedEnumerable <ParadoxosMod> ordered;
// It got confusing a bit...
if (model.ExportedList.CustomOrder)
{
ordered = model.ExportedList.Mod.OrderByDescending(p => p.Order);
}
else
{
ordered = model.ExportedList.Mod.OrderByDescending(p => p.ModName, StringComparer.OrdinalIgnoreCase);
}
parameters.Mod.Mods = ordered.Select(p =>
{
if (!p.FileName.StartsWith("mod/", StringComparison.OrdinalIgnoreCase))
{
return(string.Format(ModDirectory, p.FileName));
}
return(p.FileName);
}).ToList();
}
bool parseXML(string content)
{
try
{
var model = ParseParadoxosAsXML(content);
map(model);
return(true);
}
catch (Exception ex)
{
logger.Error(ex);
}
return(false);
}
bool parseJson(string content)
{
try
{
var model = ParseParadoxosAsJSON(content);
map(model);
return(true);
}
catch (Exception ex)
{
logger.Error(ex);
}
return(false);
}
var content = await File.ReadAllTextAsync(parameters.File);
if (!string.IsNullOrWhiteSpace(content))
{
if (parameters.File.EndsWith(Shared.Constants.XMLExtension, StringComparison.OrdinalIgnoreCase))
{
return(parseXML(content));
}
else if (parameters.File.EndsWith(Shared.Constants.JsonExtension, StringComparison.OrdinalIgnoreCase))
{
return(parseJson(content));
}
else
{
// Try to guess and parse as both
return(parseXML(content) || parseJson(content));
}
}
}
return(false);
}
/// <summary>
/// Imports the internal.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <param name="importInstance">if set to <c>true</c> [import instance].</param>
/// <param name="collectionImportResult">The collection import result.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
private bool ImportInternal(ModCollectionExporterParams parameters, bool importInstance, out ICollectionImportResult collectionImportResult)
{
ICollectionImportResult importResult = null;
if (importInstance)
{
importResult = DIResolver.Get <ICollectionImportResult>();
}
if (!importInstance)
{
if (Directory.Exists(parameters.ModDirectory))
{
DiskOperations.DeleteDirectory(parameters.ModDirectory, true);
}
}
var result = false;
int getTotalFileCount()
{
var count = 0;
using var fileStream = File.OpenRead(parameters.File);
using var reader = ReaderFactory.Open(fileStream);
while (reader.MoveToNextEntry())
{
if (!reader.Entry.IsDirectory)
{
count++;
}
}
fileStream.Close();
fileStream.Dispose();
return(count);
}
void parseUsingReaderFactory()
{
double total = getTotalFileCount();
using var fileStream = File.OpenRead(parameters.File);
using var reader = ReaderFactory.Open(fileStream);
double processed = 0;
double previousProgress = 0;
while (reader.MoveToNextEntry())
{
if (!reader.Entry.IsDirectory)
{
var relativePath = reader.Entry.Key.StandardizeDirectorySeparator().Trim(Path.DirectorySeparatorChar);
if (reader.Entry.Key.Equals(Common.Constants.ExportedModContentId, StringComparison.OrdinalIgnoreCase))
{
if (importInstance)
{
using var entryStream = reader.OpenEntryStream();
using var memoryStream = new MemoryStream();
entryStream.CopyTo(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
using var streamReader = new StreamReader(memoryStream, true);
var text = streamReader.ReadToEnd();
streamReader.Close();
streamReader.Dispose();
var model = JsonDISerializer.Deserialize <IModCollection>(text);
mapper.Map(model, importResult);
importResult.ModNames = model.ModNames;
importResult.Descriptors = model.Mods;
result = true;
break;
}
}
else
{
if (!importInstance)
{
var exportFileName = Path.Combine(relativePath.StartsWith(Common.Constants.ModExportPath + Path.DirectorySeparatorChar) ? parameters.ExportModDirectory : parameters.ModDirectory, relativePath.Replace(Common.Constants.ModExportPath + Path.DirectorySeparatorChar, string.Empty));
if (!Directory.Exists(Path.GetDirectoryName(exportFileName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(exportFileName));
}
reader.WriteEntryToFile(exportFileName, ZipExtractionOpts.GetExtractionOptions());
}
}
processed++;
var perc = GetProgressPercentage(total, processed, 100);
if (perc != previousProgress)
{
messageBus.Publish(new ModExportProgressEvent(perc));
previousProgress = perc;
}
}
}
}
void parseUsingArchiveFactory()
{
using var fileStream = File.OpenRead(parameters.File);
using var reader = ArchiveFactory.Open(fileStream);
var entries = reader.Entries.Where(entry => !entry.IsDirectory);
double total = !importInstance?entries.Count() : 1;
double processed = 0;
double previousProgress = 0;
foreach (var entry in entries)
{
var relativePath = entry.Key.StandardizeDirectorySeparator().Trim(Path.DirectorySeparatorChar);
if (entry.Key.Equals(Common.Constants.ExportedModContentId, StringComparison.OrdinalIgnoreCase))
{
if (importInstance)
{
using var entryStream = entry.OpenEntryStream();
using var memoryStream = new MemoryStream();
entryStream.CopyTo(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
using var streamReader = new StreamReader(memoryStream, true);
var text = streamReader.ReadToEnd();
streamReader.Close();
streamReader.Dispose();
var model = JsonDISerializer.Deserialize <IModCollection>(text);
mapper.Map(model, importResult);
importResult.ModNames = model.ModNames;
importResult.Descriptors = model.Mods;
result = true;
break;
}
}
else
{
if (!importInstance)
{
var exportFileName = Path.Combine(relativePath.StartsWith(Common.Constants.ModExportPath + Path.DirectorySeparatorChar) ? parameters.ExportModDirectory : parameters.ModDirectory, relativePath.Replace(Common.Constants.ModExportPath + Path.DirectorySeparatorChar, string.Empty));
if (!Directory.Exists(Path.GetDirectoryName(exportFileName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(exportFileName));
}
entry.WriteToFile(exportFileName, ZipExtractionOpts.GetExtractionOptions());
}
}
processed++;
var perc = GetProgressPercentage(total, processed, 100);
if (perc != previousProgress)
{
messageBus.Publish(new ModExportProgressEvent(perc));
previousProgress = perc;
}
}
}
try
{
parseUsingArchiveFactory();
}
catch (Exception ex)
{
logger.Error(ex);
result = false;
parseUsingReaderFactory();
}
collectionImportResult = importResult;
return(!importInstance || result);
}
/// <summary>
/// import paradoxos as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <ICollectionImportResult> ImportParadoxosAsync(ModCollectionExporterParams parameters)
{
return(paradoxosImporter.ImportAsync(parameters));
}
/// <summary>
/// Imports the paradox launcher asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <bool> ImportParadoxLauncherAsync(ModCollectionExporterParams parameters)
{
return(paradoxLauncherImporter.ImportAsync(parameters));
}
/// <summary>
/// Gets the database path.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>System.String.</returns>
private string GetDbPath(ModCollectionExporterParams parameters)
{
return(Path.Combine(Path.GetDirectoryName(parameters.ModDirectory), Constants.Sql_db_path));
}
/// <summary>
/// json import as an asynchronous operation.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
/// <exception cref="System.AggregateException"></exception>
public virtual async Task <ICollectionImportResult> JsonImportAsync(ModCollectionExporterParams parameters)
{
async Task <(Exception, ICollectionImportResult)> parseV2()
{
var content = await File.ReadAllTextAsync(parameters.File);
if (!string.IsNullOrWhiteSpace(content))
{
Models.Paradox.Json.v2.ModInfo model = null;
try
{
model = JsonDISerializer.Deserialize <Models.Paradox.Json.v2.ModInfo>(content);
}
catch (Exception ex)
{
return(ex, null);
}
if (!string.IsNullOrWhiteSpace(model.Game) && !string.IsNullOrWhiteSpace(model.Name))
{
// Validate whether this really is v2 (execting length larger than 4 as a dumb best guess)
if (model.Mods.Any(p => p.Position.Length >= 4))
{
var result = DIResolver.Get <ICollectionImportResult>();
result.Name = model.Name;
// Will need to lookup the game and mod ids in the mod service
result.Game = model.Game;
var mods = model.Mods.Where(p => p.Enabled).OrderBy(p => p.Position);
result.ModIds = mods.Select(p => !string.IsNullOrWhiteSpace(p.PdxId) ? p.PdxId : p.SteamId).ToList();
return(null, result);
}
}
}
return(null, null);
}
async Task <(Exception, ICollectionImportResult)> parseV3()
{
var content = await File.ReadAllTextAsync(parameters.File);
if (!string.IsNullOrWhiteSpace(content))
{
Models.Paradox.Json.v3.ModInfo model = null;
try
{
model = JsonDISerializer.Deserialize <Models.Paradox.Json.v3.ModInfo>(content);
}
catch (Exception ex)
{
return(ex, null);
}
if (!string.IsNullOrWhiteSpace(model.Game) && !string.IsNullOrWhiteSpace(model.Name))
{
var result = DIResolver.Get <ICollectionImportResult>();
result.Name = model.Name;
// Will need to lookup the game and mod ids in the mod service
result.Game = model.Game;
var mods = model.Mods.Where(p => p.Enabled).OrderBy(p => p.Position);
result.ModIds = mods.Select(p => !string.IsNullOrWhiteSpace(p.PdxId) ? p.PdxId : p.SteamId).ToList();
return(null, result);
}
}
return(null, null);
}
if (File.Exists(parameters.File))
{
var exceptions = new List <Exception>();
var result = await parseV2();
if (result.Item2 != null)
{
return(result.Item2);
}
if (result.Item1 != null)
{
exceptions.Add(result.Item1);
}
result = await parseV3();
if (result.Item2 != null)
{
return(result.Item2);
}
if (result.Item1 != null)
{
exceptions.Add(result.Item1);
}
if (exceptions.Any())
{
throw new AggregateException(exceptions);
}
}
return(null);
}
/// <summary>
/// Imports the asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <bool> ImportAsync(ModCollectionExporterParams parameters)
{
return(Task.FromResult(ImportInternal(parameters, true)));
}
/// <summary>
/// Exports the paradox launcher json asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <bool> ExportParadoxLauncherJsonAsync(ModCollectionExporterParams parameters)
{
return(paradoxLauncherExporter.ExportAsync(parameters));
}
/// <summary>
/// Exports the asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public async Task <bool> ExportAsync(ModCollectionExporterParams parameters)
{
double processed = 0;
double previousProgress = 0;
void saveProgress(object sender, SaveProgressEventArgs e)
{
switch (e.EventType)
{
case ZipProgressEventType.Saving_AfterWriteEntry:
processed++;
var perc = GetProgressPercentage(e.EntriesTotal, processed, 100);
if (perc != previousProgress)
{
messageBus.Publish(new ModExportProgressEvent(perc));
previousProgress = perc;
}
break;
default:
break;
}
}
var content = JsonConvert.SerializeObject(parameters.Mod, Formatting.None);
using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(content));
var streams = new List <Stream>()
{
dataStream
};
using var zip = new ZipFile();
zip.UseZip64WhenSaving = Zip64Option.AsNecessary;
zip.AddEntry(Common.Constants.ExportedModContentId, dataStream);
if (Directory.Exists(parameters.ModDirectory) && !parameters.ExportModOrderOnly)
{
var files = Directory.GetFiles(parameters.ModDirectory, "*.*", SearchOption.AllDirectories);
if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
foreach (var item in files)
{
var fs = new FileStream(item, FileMode.Open, FileAccess.Read, FileShare.Read);
var file = item.Replace(parameters.ModDirectory, string.Empty).Trim('\\').Trim('/');
var entry = zip.AddEntry(file, fs);
entry.AlternateEncoding = Encoding.UTF8;
entry.AlternateEncodingUsage = ZipOption.AsNecessary;
streams.Add(fs);
}
}
else
{
// Yeah, osx sucks (ulimit bypass)
foreach (var item in files)
{
var fs = new FileStream(item, FileMode.Open, FileAccess.Read, FileShare.Read);
var ms = new MemoryStream();
await fs.CopyToAsync(ms);
var file = item.Replace(parameters.ModDirectory, string.Empty).Trim('\\').Trim('/');
var entry = zip.AddEntry(file, ms);
entry.AlternateEncoding = Encoding.UTF8;
entry.AlternateEncodingUsage = ZipOption.AsNecessary;
fs.Close();
await fs.DisposeAsync();
streams.Add(ms);
}
}
}
if ((parameters.ExportMods?.Any()).GetValueOrDefault())
{
foreach (var mod in parameters.ExportMods)
{
if (Directory.Exists(mod.FullPath))
{
var files = Directory.GetFiles(mod.FullPath, "*.*", SearchOption.AllDirectories);
if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
foreach (var item in files)
{
var fs = new FileStream(item, FileMode.Open, FileAccess.Read, FileShare.Read);
var file = Path.Combine(Common.Constants.ModExportPath, parameters.Mod.Name.GenerateShortFileNameHashId(4).GenerateValidFileName() + "_" + mod.Name.GenerateValidFileName().GenerateShortFileNameHashId(8), item.Replace(mod.FullPath, string.Empty).Trim('\\').Trim('/'));
zip.AddEntry(file, fs);
streams.Add(fs);
}
}
else
{
foreach (var item in files)
{
var fs = new FileStream(item, FileMode.Open, FileAccess.Read, FileShare.Read);
var ms = new MemoryStream();
await fs.CopyToAsync(ms);
var file = Path.Combine(Common.Constants.ModExportPath, parameters.Mod.Name.GenerateShortFileNameHashId(4).GenerateValidFileName() + "_" + mod.Name.GenerateValidFileName().GenerateShortFileNameHashId(8), item.Replace(mod.FullPath, string.Empty).Trim('\\').Trim('/'));
zip.AddEntry(file, ms);
fs.Close();
await fs.DisposeAsync();
streams.Add(ms);
}
}
}
else if (File.Exists(mod.FullPath))
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
var fs = new FileStream(mod.FullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
var file = Path.Combine(Common.Constants.ModExportPath, parameters.Mod.Name.GenerateShortFileNameHashId(4).GenerateValidFileName() + "_" + Path.GetFileNameWithoutExtension(mod.FullPath).GenerateShortFileNameHashId(8) + Path.GetExtension(mod.FullPath));
zip.AddEntry(file, fs);
streams.Add(fs);
}
else
{
var fs = new FileStream(mod.FullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
var ms = new MemoryStream();
await fs.CopyToAsync(ms);
var file = Path.Combine(Common.Constants.ModExportPath, parameters.Mod.Name.GenerateShortFileNameHashId(4).GenerateValidFileName() + "_" + Path.GetFileNameWithoutExtension(mod.FullPath).GenerateShortFileNameHashId(8) + Path.GetExtension(mod.FullPath));
zip.AddEntry(file, ms);
fs.Close();
await fs.DisposeAsync();
streams.Add(ms);
}
}
}
}
zip.SaveProgress += saveProgress;
zip.Save(parameters.File);
zip.SaveProgress -= saveProgress;
zip.Dispose();
if (streams.Any())
{
var task = streams.Select(async p =>
{
p.Close();
await p.DisposeAsync();
});
await Task.WhenAll(task);
}
return(true);
}
/// <summary>
/// Gets the connection.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>IDbConnection.</returns>
private IDbConnection GetConnection(ModCollectionExporterParams parameters)
{
return(new SqliteConnection($"Data Source=\"{GetDbPath(parameters)}\"").EnsureOpen());
}
/// <summary>
/// Imports the paradox launcher beta asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<ICollectionImportResult>.</returns>
public Task <ICollectionImportResult> ImportParadoxLauncherBetaAsync(ModCollectionExporterParams parameters)
{
return(paradoxLauncherImporterBeta.DatabaseImportAsync(parameters));
}
/// <summary>
/// Imports the paradox launcher json asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <ICollectionImportResult> ImportParadoxLauncherJsonAsync(ModCollectionExporterParams parameters)
{
return(paradoxLauncherImporter.JsonImportAsync(parameters));
}
/// <summary>
/// Imports the mod directory asynchronous.
/// </summary>
/// <param name="parameters">The parameters.</param>
/// <returns>Task<System.Boolean>.</returns>
public Task <bool> ImportModDirectoryAsync(ModCollectionExporterParams parameters)
{
return(Task.FromResult(ImportInternal(parameters, false)));
}
