/// <summary>
/// Maps the import result.
/// </summary>
/// <param name="modCollection">The mod collection.</param>
/// <param name="importResult">The import result.</param>
protected virtual void MapImportResult(IModCollection modCollection, ICollectionImportResult importResult)
{
if (!string.IsNullOrWhiteSpace(importResult.Game))
{
var collectionGame = GameService.Get().FirstOrDefault(p => p.Type.Equals(importResult.Game));
if (collectionGame == null)
{
collectionGame = GameService.Get().FirstOrDefault(p => p.ParadoxGameId.Equals(importResult.Game));
}
if (collectionGame != null)
{
modCollection.Game = collectionGame.Type;
}
}
modCollection.IsSelected = importResult.IsSelected;
modCollection.MergedFolderName = importResult.MergedFolderName;
modCollection.ModNames = importResult.ModNames;
modCollection.Mods = importResult.Descriptors;
modCollection.Name = importResult.Name;
modCollection.PatchModEnabled = importResult.PatchModEnabled;
if (importResult.ModIds != null && importResult.ModIds.Any())
{
var mods = GetInstalledModsInternal(modCollection.Game, false);
if (mods.Any())
{
var collectionMods = mods.Where(p => importResult.ModIds.Contains(p.RemoteId.ToString()));
modCollection.Mods = collectionMods.Select(p => p.DescriptorFile).ToList();
modCollection.ModNames = collectionMods.Select(p => p.Name).ToList();
}
}
}
/// <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>
/// 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);
}
