290 lines
12 KiB
C#
290 lines
12 KiB
C#
using LANCommander.SDK;
|
|
using Playnite.SDK;
|
|
using Playnite.SDK.Models;
|
|
using SharpCompress.Archives;
|
|
using SharpCompress.Archives.Zip;
|
|
using SharpCompress.Common;
|
|
using SharpCompress.Readers;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using YamlDotNet.Serialization;
|
|
using YamlDotNet.Serialization.NamingConventions;
|
|
|
|
namespace LANCommander.PlaynitePlugin.Services
|
|
{
|
|
internal class GameSaveService
|
|
{
|
|
private readonly LANCommanderClient LANCommander;
|
|
private readonly IPlayniteAPI PlayniteApi;
|
|
private readonly PowerShellRuntime PowerShellRuntime;
|
|
|
|
internal GameSaveService(LANCommanderClient lanCommander, IPlayniteAPI playniteApi, PowerShellRuntime powerShellRuntime)
|
|
{
|
|
LANCommander = lanCommander;
|
|
PlayniteApi = playniteApi;
|
|
PowerShellRuntime = powerShellRuntime;
|
|
}
|
|
|
|
internal void DownloadSave(Game game)
|
|
{
|
|
string tempFile = String.Empty;
|
|
|
|
if (game != null)
|
|
{
|
|
PlayniteApi.Dialogs.ActivateGlobalProgress(progress =>
|
|
{
|
|
progress.ProgressMaxValue = 100;
|
|
progress.CurrentProgressValue = 0;
|
|
|
|
var destination = LANCommander.DownloadLatestSave(Guid.Parse(game.GameId), (changed) =>
|
|
{
|
|
progress.CurrentProgressValue = changed.ProgressPercentage;
|
|
}, (complete) =>
|
|
{
|
|
progress.CurrentProgressValue = 100;
|
|
});
|
|
|
|
// Lock the thread until download is done
|
|
while (progress.CurrentProgressValue != 100)
|
|
{
|
|
|
|
}
|
|
|
|
tempFile = destination;
|
|
},
|
|
new GlobalProgressOptions("Downloading latest save...")
|
|
{
|
|
IsIndeterminate = false,
|
|
Cancelable = false
|
|
});
|
|
|
|
// Go into the archive and extract the files to the correct locations
|
|
try
|
|
{
|
|
var tempLocation = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
|
|
|
|
Directory.CreateDirectory(tempLocation);
|
|
|
|
ExtractFilesFromZip(tempFile, tempLocation);
|
|
|
|
var deserializer = new DeserializerBuilder()
|
|
.WithNamingConvention(new PascalCaseNamingConvention())
|
|
.Build();
|
|
|
|
var manifestContents = File.ReadAllText(Path.Combine(tempLocation, "_manifest.yml"));
|
|
|
|
var manifest = deserializer.Deserialize<GameManifest>(manifestContents);
|
|
|
|
#region Move files
|
|
foreach (var savePath in manifest.SavePaths.Where(sp => sp.Type == "File"))
|
|
{
|
|
bool inInstallDir = savePath.Path.StartsWith("{InstallDir}");
|
|
string tempSavePath = Path.Combine(tempLocation, savePath.Id.ToString());
|
|
|
|
var tempSavePathFile = Path.Combine(tempSavePath, savePath.Path.Replace('/', '\\').Replace("{InstallDir}\\", ""));
|
|
|
|
var destination = Environment.ExpandEnvironmentVariables(savePath.Path.Replace('/', '\\').Replace("{InstallDir}", game.InstallDirectory));
|
|
|
|
if (File.Exists(tempSavePathFile))
|
|
{
|
|
// Is file, move file
|
|
if (File.Exists(destination))
|
|
File.Delete(destination);
|
|
|
|
File.Move(tempSavePathFile, destination);
|
|
}
|
|
else if (Directory.Exists(tempSavePath))
|
|
{
|
|
var files = Directory.GetFiles(tempSavePath, "*", SearchOption.AllDirectories);
|
|
|
|
if (inInstallDir)
|
|
{
|
|
foreach (var file in files)
|
|
{
|
|
if (inInstallDir)
|
|
{
|
|
// Files are in the game's install directory. Move them there from the save path.
|
|
destination = file.Replace(tempSavePath, savePath.Path.Replace('/', '\\').TrimEnd('\\').Replace("{InstallDir}", game.InstallDirectory));
|
|
|
|
if (File.Exists(destination))
|
|
File.Delete(destination);
|
|
|
|
File.Move(file, destination);
|
|
}
|
|
else
|
|
{
|
|
// Specified path is probably an absolute path, maybe with environment variables.
|
|
destination = Environment.ExpandEnvironmentVariables(file.Replace(tempSavePathFile, savePath.Path.Replace('/', '\\')));
|
|
|
|
if (File.Exists(destination))
|
|
File.Delete(destination);
|
|
|
|
File.Move(file, destination);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Handle registry importing
|
|
var registryImportFilePath = Path.Combine(tempLocation, "_registry.reg");
|
|
|
|
if (File.Exists(registryImportFilePath))
|
|
{
|
|
var registryImportFileContents = File.ReadAllText(registryImportFilePath);
|
|
|
|
PowerShellRuntime.RunCommand($"regedit.exe /s \"{registryImportFilePath}\"", registryImportFileContents.Contains("HKEY_LOCAL_MACHINE"));
|
|
}
|
|
#endregion
|
|
|
|
// Clean up temp files
|
|
Directory.Delete(tempLocation, true);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void UploadSave(Game game)
|
|
{
|
|
var manifestPath = Path.Combine(game.InstallDirectory, "_manifest.yml");
|
|
|
|
if (File.Exists(manifestPath))
|
|
{
|
|
var deserializer = new DeserializerBuilder()
|
|
.WithNamingConvention(new PascalCaseNamingConvention())
|
|
.Build();
|
|
|
|
var manifest = deserializer.Deserialize<GameManifest>(File.ReadAllText(manifestPath));
|
|
var temp = Path.GetTempFileName();
|
|
|
|
if (manifest.SavePaths != null && manifest.SavePaths.Count() > 0)
|
|
{
|
|
using (var archive = ZipArchive.Create())
|
|
{
|
|
archive.DeflateCompressionLevel = SharpCompress.Compressors.Deflate.CompressionLevel.BestCompression;
|
|
|
|
#region Add files from defined paths
|
|
foreach (var savePath in manifest.SavePaths.Where(sp => sp.Type == "File"))
|
|
{
|
|
var localPath = Environment.ExpandEnvironmentVariables(savePath.Path.Replace('/', '\\').Replace("{InstallDir}", game.InstallDirectory));
|
|
|
|
if (Directory.Exists(localPath))
|
|
{
|
|
AddDirectoryToZip(archive, localPath, localPath, savePath.Id);
|
|
}
|
|
else if (File.Exists(localPath))
|
|
{
|
|
archive.AddEntry(Path.Combine(savePath.Id.ToString(), savePath.Path.Replace("{InstallDir}/", "")), localPath);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Add files from defined paths
|
|
foreach (var savePath in manifest.SavePaths.Where(sp => sp.Type == "File"))
|
|
{
|
|
var localPath = Environment.ExpandEnvironmentVariables(savePath.Path.Replace('/', '\\').Replace("{InstallDir}", game.InstallDirectory));
|
|
|
|
if (Directory.Exists(localPath))
|
|
{
|
|
AddDirectoryToZip(archive, localPath, localPath, savePath.Id);
|
|
}
|
|
else if (File.Exists(localPath))
|
|
{
|
|
archive.AddEntry(Path.Combine(savePath.Id.ToString(), savePath.Path.Replace("{InstallDir}/", "")), localPath);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Export registry keys
|
|
if (manifest.SavePaths.Any(sp => sp.Type == "Registry"))
|
|
{
|
|
List<string> tempRegFiles = new List<string>();
|
|
|
|
var exportCommand = new StringBuilder();
|
|
|
|
foreach (var savePath in manifest.SavePaths.Where(sp => sp.Type == "Registry"))
|
|
{
|
|
var tempRegFile = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".reg");
|
|
|
|
exportCommand.AppendLine($"reg.exe export \"{savePath.Path.Replace(":\\", "\\")}\" \"{tempRegFile}\"");
|
|
tempRegFiles.Add(tempRegFile);
|
|
}
|
|
|
|
PowerShellRuntime.RunCommand(exportCommand.ToString());
|
|
|
|
var exportFile = new StringBuilder();
|
|
|
|
foreach (var tempRegFile in tempRegFiles)
|
|
{
|
|
exportFile.AppendLine(File.ReadAllText(tempRegFile));
|
|
File.Delete(tempRegFile);
|
|
}
|
|
|
|
archive.AddEntry("_registry.reg", new MemoryStream(Encoding.UTF8.GetBytes(exportFile.ToString())), true);
|
|
}
|
|
#endregion
|
|
|
|
archive.AddEntry("_manifest.yml", manifestPath);
|
|
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
archive.SaveTo(ms);
|
|
|
|
ms.Seek(0, SeekOrigin.Begin);
|
|
|
|
var save = LANCommander.UploadSave(game.GameId, ms.ToArray());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddDirectoryToZip(ZipArchive zipArchive, string path, string workingDirectory, Guid pathId)
|
|
{
|
|
foreach (var file in Directory.GetFiles(path))
|
|
{
|
|
// Oh man is this a hack. We should be removing only the working directory from the start,
|
|
// but we're making the assumption that the working dir put in actually prefixes the path.
|
|
// Also wtf, that Path.Combine is stripping the pathId out?
|
|
zipArchive.AddEntry(Path.Combine(pathId.ToString(), path.Substring(workingDirectory.Length), Path.GetFileName(file)), file);
|
|
}
|
|
|
|
foreach (var child in Directory.GetDirectories(path))
|
|
{
|
|
// See above
|
|
//ZipEntry entry = new ZipEntry(Path.Combine(pathId.ToString(), path.Substring(workingDirectory.Length), Path.GetFileName(path)));
|
|
|
|
//zipStream.PutNextEntry(entry);
|
|
//zipStream.CloseEntry();
|
|
|
|
AddDirectoryToZip(zipArchive, child, workingDirectory, pathId);
|
|
}
|
|
}
|
|
|
|
private void ExtractFilesFromZip(string zipPath, string destination)
|
|
{
|
|
using (var fs = File.OpenRead(zipPath))
|
|
using (var ts = new TrackableStream(fs))
|
|
using (var reader = ReaderFactory.Open(ts))
|
|
{
|
|
reader.WriteAllToDirectory(destination, new ExtractionOptions()
|
|
{
|
|
ExtractFullPath = true,
|
|
Overwrite = true
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|