/// <summary>
/// Unpacks the update asynchronous.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>Task<System.String>.</returns>
public async Task <string> UnpackUpdateAsync(string path)
{
if (!File.Exists(path))
{
return(string.Empty);
}
var extractPath = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path));
// Cleanup path were extracting to
if (Directory.Exists(extractPath))
{
DiskOperations.DeleteDirectory(extractPath, true);
}
// Throwing exception because of this? While previously it would automatically be created
Directory.CreateDirectory(extractPath);
using var fileStream = File.OpenRead(path);
using var reader = ArchiveFactory.Open(fileStream);
var all = reader.Entries.Where(entry => !entry.IsDirectory);
double total = all.Count();
double processed = 0;
var lastPercentage = 0;
foreach (var entry in all)
{
entry.WriteToDirectory(extractPath, ZipExtractionOpts.GetExtractionOptions());
processed++;
var progress = GetProgressPercentage(total, processed);
if (progress != lastPercentage)
{
await messageBus.PublishAsync(new UpdateUnpackProgressEvent(progress));
}
lastPercentage = progress;
}
return(extractPath);
}
/// <summary>
/// Unpacks the update asynchronous.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>Task<System.String>.</returns>
public async Task <string> UnpackUpdateAsync(string path)
{
if (!File.Exists(path))
{
return(string.Empty);
}
var extractPath = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path));
using var fileStream = File.OpenRead(path);
using var reader = ArchiveFactory.Open(fileStream);
var all = reader.Entries.Where(entry => !entry.IsDirectory);
double total = all.Count();
double processed = 0;
var lastPercentage = 0;
foreach (var entry in all)
{
entry.WriteToDirectory(extractPath, ZipExtractionOpts.GetExtractionOptions());
processed++;
var progress = GetProgressPercentage(total, processed);
if (progress != lastPercentage)
{
await messageBus.PublishAsync(new UpdateUnpackProgressEvent(progress));
}
lastPercentage = progress;
}
return(extractPath);
}
/// <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>
/// 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);
}
