Merge remote-tracking branch 'upstream/develop'

Author: Squall-Leonhart

xivModdingFramework/Mods/DataContainers/BackupModPackData.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+
+namespace xivModdingFramework.Mods.DataContainers
+{
+    public class BackupModPackData
+    {
+        /// <summary>
+        /// The name of the mod pack
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The mod pack author
+        /// </summary>
+        public string Author = "TexTools";
+
+        /// <summary>
+        /// The mod pack version
+        /// </summary>
+        public Version Version = new Version("1.0.0");
+
+        /// <summary>
+        /// The modpack Url
+        /// </summary>
+        public string Url = "";
+
+        /// <summary>
+        /// The description for the mod pack
+        /// </summary>
+        public string Description = "";
+
+        /// <summary>
+        /// The list of mods to back up
+        /// </summary>
+        public List<BackupModData> ModsToBackup { get; set; }
+    }
+
+    public class BackupModData
+    {
+        /// <summary>
+        /// Simple mod data
+        /// </summary>
+        public SimpleModData SimpleModData { get; set; }
+
+        /// <summary>
+        /// Mod pack that the mod is a part of
+        /// </summary>
+        public  ModPack ModPack { get; set; }
+    }
+}

xivModdingFramework/Mods/DataContainers/ModList.cs

@@ -20,6 +20,7 @@
 using System.Diagnostics.Contracts;
 using System.Security.Cryptography;
 using System.Text;
+using xivModdingFramework.General.Enums;
 using xivModdingFramework.Helpers;
 
 namespace xivModdingFramework.Mods.DataContainers
@@ -114,6 +115,27 @@ public bool IsCustomFile()
         {
             return data.modOffset == data.originalOffset;
         }
+
+        /// <summary>
+        /// Creates a Mod instance using the provided JSON
+        /// </summary>
+        /// <param name="modsJson"></param>
+        /// <param name="sourceApplication"></param>
+        /// <returns></returns>
+        public static Mod MakeModFromJson(ModsJson modsJson, string sourceApplication)
+        {
+            return new Mod
+            {
+                source = sourceApplication,
+                name = modsJson.Name,
+                category = modsJson.Category,
+                fullPath = modsJson.FullPath,
+                datFile = IOUtil.GetDataFileFromPath(modsJson.FullPath).GetDataFileName(),
+                enabled = true,
+                modPack = modsJson.ModPackEntry,
+                data = new Data()
+            };
+        }
     }
 
     public class Data

xivModdingFramework/Mods/FileTypes/TTMP.cs

@@ -50,6 +50,7 @@ public class TTMP
 
         private readonly string _currentWizardTTMPVersion = "1.3w";
         private readonly string _currentSimpleTTMPVersion = "1.3s";
+        private readonly string _currentBackupTTMPVersion = "1.0b";
         private const string _minimumAssembly = "1.3.0.0";
 
         private string _tempMPD, _tempMPL, _source;
@@ -335,6 +336,122 @@ public async Task<int> CreateSimpleModPack(SimpleModPackData modPackData, Direct
             return processCount;
         }
 
+        /// <summary>
+        /// Creates a backup modpack which retains the original modpacks on import
+        /// </summary>
+        /// <param name="backupModpackData">The data that will go into the mod pack</param>
+        /// <param name="gameDirectory">The game directory</param>
+        /// <param name="progress">The progress of the mod pack creation</param>
+        /// <param name="overwriteModpack">Whether or not to overwrite an existing modpack with the same name</param>
+        /// <returns>The number of mods processed for the mod pack</returns>
+        public async Task<int> CreateBackupModpack(BackupModPackData backupModpackData, DirectoryInfo gameDirectory, IProgress<(int current, int total, string message)> progress, bool overwriteModpack)
+        {
+            var processCount = await Task.Run<int>(() =>
+            {
+                var dat = new Dat(gameDirectory);
+
+                var guid = Guid.NewGuid();
+
+                var dir = Path.Combine(Path.GetTempPath(), guid.ToString());
+                Directory.CreateDirectory(dir);
+
+
+                _tempMPD = Path.Combine(dir, "TTMPD.mpd");
+                _tempMPL = Path.Combine(dir, "TTMPL.mpl");
+
+                var modCount = 0;
+
+                var modPackJson = new ModPackJson
+                {
+                    TTMPVersion = _currentBackupTTMPVersion,
+                    Name = backupModpackData.Name,
+                    Author = backupModpackData.Author,
+                    Version = backupModpackData.Version.ToString(),
+                    MinimumFrameworkVersion = _minimumAssembly,
+                    Url = backupModpackData.Url,
+                    Description = backupModpackData.Description,
+                    SimpleModsList = new List<ModsJson>()
+                };
+
+                try
+                {
+                    using (var binaryWriter = new BinaryWriter(File.Open(_tempMPD, FileMode.Create)))
+                    {
+                        foreach (var backupModData in backupModpackData.ModsToBackup)
+                        {
+                            if (ForbiddenModTypes.Contains(Path.GetExtension(backupModData.SimpleModData.FullPath))) continue;
+
+                            var modsJson = new ModsJson
+                            {
+                                Name = backupModData.SimpleModData.Name,
+                                Category = backupModData.SimpleModData.Category.GetEnDisplayName(),
+                                FullPath = backupModData.SimpleModData.FullPath,
+                                ModSize = backupModData.SimpleModData.ModSize,
+                                DatFile = backupModData.SimpleModData.DatFile,
+                                IsDefault = backupModData.SimpleModData.IsDefault,
+                                ModOffset = binaryWriter.BaseStream.Position,
+                                ModPackEntry = backupModData.ModPack,
+                            };
+
+                            var rawData = dat.GetRawData(backupModData.SimpleModData.ModOffset,
+                                XivDataFiles.GetXivDataFile(backupModData.SimpleModData.DatFile),
+                                backupModData.SimpleModData.ModSize);
+
+                            if (rawData == null)
+                            {
+                                throw new Exception("Unable to obtain data for the following mod\n\n" +
+                                                    $"Name: {backupModData.SimpleModData.Name}\nFull Path: {backupModData.SimpleModData.FullPath}\n" +
+                                                    $"Mod Offset: {backupModData.SimpleModData.ModOffset}\nData File: {backupModData.SimpleModData.DatFile}\n\n" +
+                                                    $"Unselect the above mod and try again.");
+                            }
+
+                            binaryWriter.Write(rawData);
+
+                            modPackJson.SimpleModsList.Add(modsJson);
+
+                            progress?.Report((++modCount, backupModpackData.ModsToBackup.Count, string.Empty));
+                        }
+                    }
+
+                    progress?.Report((0, backupModpackData.ModsToBackup.Count, GeneralStrings.TTMP_Creating));
+
+                    File.WriteAllText(_tempMPL, JsonConvert.SerializeObject(modPackJson));
+
+                    var modPackPath = Path.Combine(_modPackDirectory.FullName, $"{backupModpackData.Name}.ttmp2");
+
+                    if (File.Exists(modPackPath) && !overwriteModpack)
+                    {
+                        var fileNum = 1;
+                        modPackPath = Path.Combine(_modPackDirectory.FullName, $"{backupModpackData.Name}({fileNum}).ttmp2");
+                        while (File.Exists(modPackPath))
+                        {
+                            fileNum++;
+                            modPackPath = Path.Combine(_modPackDirectory.FullName, $"{backupModpackData.Name}({fileNum}).ttmp2");
+                        }
+                    }
+                    else if (File.Exists(modPackPath) && overwriteModpack)
+                    {
+                        File.Delete(modPackPath);
+                    }
+
+                    var zf = new ZipFile();
+                    zf.UseZip64WhenSaving = Zip64Option.AsNecessary;
+                    zf.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
+                    zf.AddFile(_tempMPL, "");
+                    zf.AddFile(_tempMPD, "");
+                    zf.Save(modPackPath);
+                }
+                finally
+                {
+                    Directory.Delete(dir, true);
+                }
+
+                return modCount;
+            });
+
+            return processCount;
+        }
+
         /// <summary>
         /// Gets the data from a mod pack including images if present
         /// </summary>
@@ -461,8 +578,9 @@ public static string GetVersion(DirectoryInfo modPackDirectory)
         /// <param name="progress">The progress of the import</param>
         /// <param name="GetRootConversionsFunction">Function called part-way through import to resolve rood conversions, if any are desired.  Function takes a List of files, the in-progress modified index and modlist files, and returns a dictionary of conversion data.  If this function throws and OperationCancelledException, the import is cancelled.</param>
         /// <returns>The number of total mods imported</returns>
-        public async Task<(int ImportCount, int ErrorCount, string Errors, float Duration)> ImportModPackAsync(DirectoryInfo modPackDirectory, List<ModsJson> modsJson,
-            DirectoryInfo gameDirectory, DirectoryInfo modListDirectory, IProgress<(int current, int total, string message)> progress, Func<HashSet<string>, Dictionary<XivDataFile, IndexFile>, ModList, Task<Dictionary<XivDependencyRoot, (XivDependencyRoot Root, int Variant)>>>  GetRootConversionsFunction = null )
+        public async Task<(int ImportCount, int ErrorCount, string Errors, float Duration)> ImportModPackAsync(
+            DirectoryInfo modPackDirectory, List<ModsJson> modsJson, DirectoryInfo gameDirectory, DirectoryInfo modListDirectory, IProgress<(int current, int total, string message)> progress, 
+            Func<HashSet<string>, Dictionary<XivDataFile, IndexFile>, ModList, Task<Dictionary<XivDependencyRoot, (XivDependencyRoot Root, int Variant)>>>  GetRootConversionsFunction = null)
         {
             if (modsJson == null || modsJson.Count == 0) return (0, 0, "", 0);
 
@@ -490,7 +608,7 @@ public static string GetVersion(DirectoryInfo modPackDirectory)
             // the *LAST* mod json entry for each file path.
             // This keeps us from having to constantly re-query the mod list file, and filters out redundant imports.
             var filePaths = new HashSet<string>();
-            var newList = new List<ModsJson>(modsJson.Count);
+            var filteredModsJson = new List<ModsJson>(modsJson.Count);
             for(int i = modsJson.Count -1; i >= 0; i--)
             {
                 var mj = modsJson[i];
@@ -504,11 +622,10 @@ public static string GetVersion(DirectoryInfo modPackDirectory)
                 if (ForbiddenModTypes.Contains(Path.GetExtension(mj.FullPath))) continue;
 
                 filePaths.Add(mj.FullPath);
-                newList.Add(mj);
+                filteredModsJson.Add(mj);
             }
-            modsJson = newList;
 
-            if(modsJson.Count == 0)
+            if(filteredModsJson.Count == 0)
             {
                 return (0, 0, "", 0);
             }
@@ -577,7 +694,7 @@ await Task.Run(async () =>
                     progress.Report((0, 0, "Writing new mod data to DAT files..."));
                     using (var binaryReader = new BinaryReader(new FileStream(_tempMPD, FileMode.Open)))
                     {
-                        foreach (var modJson in modsJson)
+                        foreach (var modJson in filteredModsJson)
                         {
                             try
                             {
@@ -598,7 +715,7 @@ await Task.Run(async () =>
                                 Mod mod = null;
                                 if (modsByFile.ContainsKey(modJson.FullPath))
                                 {
-                                    mod= modsByFile[modJson.FullPath];
+                                    mod = modsByFile[modJson.FullPath];
                                 }
 
                                 // Always write data to end of file during modpack imports in case we need
@@ -669,17 +786,25 @@ await Task.Run(async () =>
                         progress.Report((count, totalFiles, "Updating Index file references..."));
                     }
 
+                    // Add entries for new modpacks to the mod list 
+                    foreach (var modsJson in filteredModsJson)
+                    {
+                        if (modsJson.ModPackEntry == null) continue;
 
-                    var modPackExists = modList.ModPacks.Any(modpack => modpack.name == modsJson[0].ModPackEntry.name);
+                        var modPackExists = modList.ModPacks.Any(modpack => modpack.name == modsJson.ModPackEntry.name);
 
-                    if (!modPackExists)
-                    {
-                        modList.ModPacks.Add(modsJson[0].ModPackEntry);
+                        if (!modPackExists)
+                        {
+                            modList.ModPacks.Add(modsJson.ModPackEntry);
+                        }
                     }
-                    var modPack = modList.ModPacks.First(x => x.name == modsJson[0].ModPackEntry.name);
+
 
                     if (GetRootConversionsFunction != null)
                     {
+                        // Get the modpack to list the conversions under, this is the just the modpack entry of the first modsJson since they're all the same unless it's a backup
+                        // However, this code shouldn't be used when importing backup modpacks since they already had the choice to change the destination item after the initial import
+                        var modPack = modList.ModPacks.First(x => x.name == filteredModsJson[0].ModPackEntry?.name);
 
                         Dictionary<XivDependencyRoot, (XivDependencyRoot Root, int Variant)> rootConversions = null;
                         try
@@ -730,7 +855,7 @@ await Task.Run(async () =>
                                     foreach (var fileKv in convertedFiles)
                                     {
                                         // Remove the file from our json list, the conversion already handled everything we needed to do with it.
-                                        var json = modsJson.RemoveAll(x => x.FullPath == fileKv.Key);
+                                        var json = filteredModsJson.RemoveAll(x => x.FullPath == fileKv.Key);
 
                                         if (fileKv.Key != fileKv.Value)
                                         {
@@ -784,15 +909,15 @@ await Task.Run(async () =>
 
                     // Update the Mod List file.
 
-
                     foreach (var file in filePaths)
                     {
                         if (ErroneousFiles.Contains(file)) continue;
                         try
                         {
-                            var json = modsJson.FirstOrDefault(x => x.FullPath == file);
+                            var json = filteredModsJson.FirstOrDefault(x => x.FullPath == file);
                             if (json == null) continue;
 
+
                             var mod = modList.Mods.FirstOrDefault(x => x.fullPath == file);
                             var longOffset = ((long)DatOffsets[file]) * 8L;
                             var originalOffset = OriginalOffsets[file];
@@ -827,13 +952,12 @@ await Task.Run(async () =>
                                 mod.data.originalOffset = (fileAdditionMod ? longOffset : longOriginal);
                                 mod.data.dataType = fileType;
                                 mod.enabled = true;
-                                mod.modPack = modPack;
+                                mod.modPack = json.ModPackEntry;
                                 modList.Mods.Add(mod);
 
                             }
                             else
                             {
-
                                 var fileAdditionMod = originalOffset == 0 || mod.IsCustomFile();
                                 if (fileAdditionMod)
                                 {
@@ -843,7 +967,7 @@ await Task.Run(async () =>
                                 mod.data.modSize = size;
                                 mod.data.modOffset = longOffset;
                                 mod.enabled = true;
-                                mod.modPack = modPack;
+                                mod.modPack = json.ModPackEntry;
                                 mod.data.dataType = fileType;
                                 mod.name = json.Name;
                                 mod.category = json.Category;
@@ -938,7 +1062,7 @@ await Task.Run(async () =>
                     count = 0;
                     progress.Report((0, 0, "Queuing Cache Updates..."));
                     // Metadata files expanded, last thing is to queue everthing up for the Cache.
-                    var files = modsJson.Select(x => x.FullPath).ToList();
+                    var files = filteredModsJson.Select(x => x.FullPath).ToList();
                     try
                     {
                         XivCache.QueueDependencyUpdate(files);