21217561952

Committed 21 Jan 2026 04:33PM UTC coverage: 23.05% (+0.07%) from 22.977%

Build # 21217561952

Build Type

push

github

Committed by

web-flow

Commit Message

Target playset selection (#426)

* TargetPlaysetPickerView

* TargetPlaylist class

* TargetDbManager

* Button for reloading the mods

* selectedPlaysetID

* TargetPlayset was an unneed wrap

* styling

* cleanup

* Post-merge fixes

* Log selected playset change

* Write the selected playset's mods to configuration.txt

* Add margin to SELECT_PLAYSET_INFO TextBlock

* Add blank option to target playset picker

* Load selectedPlayset from configuration.txt

Run Details

144 of 774 branches covered (18.6%)

Branch coverage included in aggregate %.

28 of 147 new or added lines in 9 files covered. (19.05%)

7 existing lines in 1 file now uncovered.

728 of 3009 relevant lines covered (24.19%)

8.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/Fronter.NET/Services/ModCopier.cs

﻿using commonItems;
using Fronter.Models.Configuration;
using Fronter.Models.Database;
using log4net;
using System;
using System.Globalization;
using System.IO;
using System.Linq;
using Mod = Fronter.Models.Database.Mod;

namespace Fronter.Services;

internal sealed class ModCopier {
        private readonly Config config;
        private readonly ILog logger = LogManager.GetLogger("Mod copier");
        public ModCopier(Config config) {
                this.config = config;
        }

        public bool CopyMod() {
                logger.Notice("Mod Copying Started.");
                var converterFolder = config.ConverterFolder;
                if (!Directory.Exists(converterFolder)) {
                        logger.Error("Copy failed - where is the converter?");
                        return false;
                }

                var outputFolder = Path.Combine(converterFolder, "output");
                if (!Directory.Exists(outputFolder)) {
                        logger.Error("Copy failed - where is the converter's output folder?");
                        return false;
                }

                string? destModsFolder = config.TargetGameModsPath;
                if (destModsFolder is null) {
                        logger.Error("Copy failed - Target Folder isn't loaded!");
                        return false;
                }
                if (!Directory.Exists(destModsFolder)) {
                        logger.Error("Copy failed - Target Folder does not exist!");
                        return false;
                }
                var options = config.Options;
                string? targetName = null;
                foreach (var option in options) {
                        var value = option.GetValue();
                        if (option.Name.Equals("output_name") && !string.IsNullOrEmpty(value)) {
                                targetName = value;
                        }
                }
                var requiredFiles = config.RequiredFiles;
                if (string.IsNullOrEmpty(targetName)) {
                        var saveGame = requiredFiles.FirstOrDefault(f => string.Equals(f?.Name, "SaveGame", StringComparison.Ordinal), defaultValue: null);
                        if (saveGame is null) {
                                logger.Error("Copy failed - SaveGame is does not exist!");
                                return false;
                        }
                        var saveGamePath = saveGame.Value;
                        if (string.IsNullOrEmpty(saveGamePath)) {
                                logger.Error("Copy Failed - save game path is empty, did we even convert anything?");
                                return false;
                        }
                        if (!File.Exists(saveGamePath)) {
                                logger.Error("Copy Failed - save game does not exist, did we even convert anything?");
                                return false;
                        }
                        if (Directory.Exists(saveGamePath)) {
                                logger.Error("Copy Failed - Save game is a directory...");
                                return false;
                        }
                        saveGamePath = CommonFunctions.TrimPath(saveGamePath);
                        saveGamePath = CommonFunctions.NormalizeStringPath(saveGamePath);
                        var pos = saveGamePath.LastIndexOf('.');
                        if (pos != -1) {
                                saveGamePath = saveGamePath[..pos];
                        }
                        targetName = saveGamePath;
                }

                targetName = CommonFunctions.ReplaceCharacter(targetName, '-');
                targetName = CommonFunctions.ReplaceCharacter(targetName, ' ');
                targetName = CommonFunctions.NormalizeUTF8Path(targetName);

                var modFolderPath = Path.Combine(outputFolder, targetName);
                if (!Directory.Exists(modFolderPath)) {
                        logger.Error($"Copy Failed - Could not find mod folder: {modFolderPath}");
                        return false;
                }

                // For games using mods with .metadata folders we need to skip .mod file requirement.
                bool skipModFile = false;
                var metadataPath = Path.Combine(outputFolder, $"{targetName}/.metadata");
                if (Directory.Exists(metadataPath)) {
                        skipModFile = true;
                }

                var modFilePath = Path.Combine(outputFolder, $"{targetName}.mod");
                if (!skipModFile && !File.Exists(modFilePath)) {
                        logger.Error($"Copy Failed - Could not find mod: {modFilePath}");
                        return false;
                }

                var destModFilePath = Path.Combine(destModsFolder, $"{targetName}.mod");
                if (!skipModFile && File.Exists(destModFilePath)) {
                        logger.Info("Previous mod file found, deleting...");
                        File.Delete(destModFilePath);
                }

                var destModFolderPath = Path.Combine(destModsFolder, targetName);
                if (Directory.Exists(destModFolderPath)) {
                        logger.Info("Previous mod directory found, deleting...");
                        if (!SystemUtils.TryDeleteFolder(destModFolderPath)) {
                                logger.Error($"Could not delete directory: {destModFolderPath}");
                                return false;
                        }
                }
                try {
                        logger.Info("Copying mod to target location...");
                        if (!skipModFile) {
                                if (!SystemUtils.TryCopyFile(modFilePath, destModFilePath)) {
                                        logger.Error($"Could not copy file: {modFilePath}\nto {destModFilePath}");
                                }
                        }
                        if (!SystemUtils.TryCopyFolder(modFolderPath, destModFolderPath)) {
                                logger.Error($"Could not copy folder: {modFolderPath}\nto {destModFolderPath}");
                        }
                } catch (Exception e) {
                        logger.Error(e.ToString());
                        return false;
                }
                logger.Notice($"Mod successfully copied to: {destModFolderPath}");

                CreatePlayset(destModsFolder, targetName, destModFolderPath);

                return true;
        }

        private void CreatePlayset(string targetModsDirectory, string modName, string destModFolder) {
                var gameDocsDirectory = Directory.GetParent(targetModsDirectory)?.FullName;
                if (gameDocsDirectory is null) {
                        logger.Warn($"Couldn't get parent directory of \"{targetModsDirectory}\".");
                        return;
                }
                var latestDbFilePath = TargetDbManager.GetLastUpdatedLauncherDbPath(gameDocsDirectory);
                if (latestDbFilePath is null) {
                        logger.Debug("Launcher's database not found.");
                        return;
                }
                logger.Debug($"Launcher's database found at \"{latestDbFilePath}\".");

                logger.Info("Setting up playset...");
                string connectionString = $"Data Source={latestDbFilePath};";
                try {
                        logger.Debug("Connecting to launcher's DB...");
                        var dbContext = new LauncherDbContext(connectionString);

                        var playsetName = $"{config.Name}: {modName}";
                        var dateTimeOffset = new DateTimeOffset(DateTime.UtcNow);
                        string unixTimeMilliSeconds = dateTimeOffset.ToUnixTimeMilliseconds().ToString(CultureInfo.InvariantCulture);

                        DeactivateCurrentPlayset(dbContext);

                        // Check if a playset with the same name already exists.
                        var playset = dbContext.Playsets.FirstOrDefault(p => p.Name == playsetName);
                        if (playset is not null) {
                                logger.Debug("Removing mods from existing playset...");
                                dbContext.PlaysetsMods.RemoveRange(dbContext.PlaysetsMods.Where(pm => pm.PlaysetId == playset.Id));
                                dbContext.SaveChanges();

                                logger.Debug("Re-activating existing playset...");
                                // Set isActive to true and updatedOn to current time.
                                playset.IsActive = true;
                                playset.UpdatedOn = unixTimeMilliSeconds;
                                dbContext.SaveChanges();

                                logger.Notice("Updated existing playset.");
                        } else {
                                logger.Debug("Creating new playset...");
                                playset = new Playset {
                                        Id = Guid.NewGuid().ToString(),
                                        Name = playsetName,
                                        IsActive = true,
                                        IsRemoved = false,
                                        HasNotApprovedChanges = false,
                                        CreatedOn = unixTimeMilliSeconds
                                };
                                dbContext.Playsets.Add(playset);
                                dbContext.SaveChanges();
                        }

                        Logger.Debug("Adding mods to playset...");
                        var playsetInfo = LoadPlaysetInfo();
                        if (playsetInfo.Count == 0) {
                                var gameRegistryId = $"mod/{modName}.mod";
                                var mod = AddModToDb(dbContext, modName, gameRegistryId, destModFolder);
                                AddModToPlayset(dbContext, mod, playset);
                        }
                        foreach (var (playsetModName, playsetModPath) in playsetInfo) {
                                string playsetModPathWithBackSlashes = playsetModPath.Replace('/', '\\');

                                // Try to get an ID of existing matching mod.
                                var mod = dbContext.Mods.FirstOrDefault(m => m.Name == playsetModName ||
                                                                                                                          m.DirPath == playsetModPath ||
                                                                                                                          m.DirPath == playsetModPathWithBackSlashes);
                                if (mod is not null) {
                                        AddModToPlayset(dbContext, mod, playset);
                                } else {
                                        var gameRegistryId = playsetModPath;
                                        if (!gameRegistryId.StartsWith("mod/", StringComparison.Ordinal)) {
                                                gameRegistryId = $"mod/{gameRegistryId}";
                                        }
                                        if (!gameRegistryId.EndsWith(".mod", StringComparison.Ordinal)) {
                                                gameRegistryId = $"{gameRegistryId}.mod";
                                        }

                                        string dirPath;
                                        if (Path.IsPathRooted(playsetModPath)) {
                                                dirPath = playsetModPath;
                                        } else {
                                                dirPath = Path.Combine(gameDocsDirectory, gameRegistryId);
                                        }

                                        mod = AddModToDb(dbContext, modName, gameRegistryId, dirPath);
                                        AddModToPlayset(dbContext, mod, playset);
                                }
                        }

                        logger.Notice("Successfully set up playset.");
                } catch (Exception e) {
                        logger.Error(e);
                }
        }

        // Returns saved mod.
        private Mod AddModToDb(LauncherDbContext dbContext, string modName, string gameRegistryId, string dirPath) {
                logger.Debug($"Saving mod \"{modName}\" to DB...");

                var mod = new Mod {
                        Id = Guid.NewGuid().ToString(),
                        Status = "ready_to_play",
                        Source = "local",
                        Version = "1",
                        GameRegistryId = gameRegistryId,
                        Name = modName,
                        DirPath = dirPath,
                };
                dbContext.Mods.Add(mod);
                dbContext.SaveChanges();

                return mod;
        }

        private static void AddModToPlayset(LauncherDbContext dbContext, Mod mod, Playset playset) {
                var playsetMod = new PlaysetsMod {
                        Playset = playset,
                        Mod = mod,
                };
                dbContext.PlaysetsMods.Add(playsetMod);
                dbContext.SaveChanges();
        }

        // Loads playset info generated by converter backend.
        private Open.Collections.OrderedDictionary<string, string> LoadPlaysetInfo() {
                logger.Debug("Loading playset info from converter backend...");
                var toReturn = new Open.Collections.OrderedDictionary<string, string>();

                var filePath = Path.Combine(config.ConverterFolder, "playset_info.txt");
                if (!File.Exists(filePath)) {
                        return toReturn;
                }

                var parser = new Parser();
                parser.RegisterRegex(CommonRegexes.QuotedString, (reader, modName) => {
                        toReturn.Add(modName, reader.GetString().RemQuotes());
                });
                parser.ParseFile(filePath);
                return toReturn;
        }

        private void DeactivateCurrentPlayset(LauncherDbContext dbContext) {
                logger.Debug("Deactivating currently active playset...");
                dbContext.Playsets
                        .Where(p => p.IsActive == true)
                        .ToList()
                        .ForEach(p => p.IsActive = false);
                dbContext.SaveChanges();
        }
}

1	using commonItems;
2	using Fronter.Models.Configuration;
3	using Fronter.Models.Database;
4	using log4net;
5	using System;
6	using System.Globalization;
7	using System.IO;
8	using System.Linq;
9	using Mod = Fronter.Models.Database.Mod;
10
11	namespace Fronter.Services;
12
13	internal sealed class ModCopier {
14	private readonly Config config;
15	private readonly ILog logger = LogManager.GetLogger("Mod copier");	×
16	public ModCopier(Config config) {	×
17	this.config = config;	×
18	}	×
19
20	public bool CopyMod() {	×
21	logger.Notice("Mod Copying Started.");	×
22	var converterFolder = config.ConverterFolder;	×
23	if (!Directory.Exists(converterFolder)) {	×
24	logger.Error("Copy failed - where is the converter?");	×
25	return false;	×
26	}
27
28	var outputFolder = Path.Combine(converterFolder, "output");	×
29	if (!Directory.Exists(outputFolder)) {	×
30	logger.Error("Copy failed - where is the converter's output folder?");	×
31	return false;	×
32	}
33
NEW 34	string? destModsFolder = config.TargetGameModsPath;	×
NEW 35	if (destModsFolder is null) {	×
36	logger.Error("Copy failed - Target Folder isn't loaded!");	×
37	return false;	×
38	}
39	if (!Directory.Exists(destModsFolder)) {	×
40	logger.Error("Copy failed - Target Folder does not exist!");	×
41	return false;	×
42	}
43	var options = config.Options;	×
44	string? targetName = null;	×
45	foreach (var option in options) {	×
46	var value = option.GetValue();	×
47	if (option.Name.Equals("output_name") && !string.IsNullOrEmpty(value)) {	×
48	targetName = value;	×
49	}	×
50	}	×
51	var requiredFiles = config.RequiredFiles;	×
52	if (string.IsNullOrEmpty(targetName)) {	×
53	var saveGame = requiredFiles.FirstOrDefault(f => string.Equals(f?.Name, "SaveGame", StringComparison.Ordinal), defaultValue: null);	×
54	if (saveGame is null) {	×
55	logger.Error("Copy failed - SaveGame is does not exist!");	×
56	return false;	×
57	}
58	var saveGamePath = saveGame.Value;	×
59	if (string.IsNullOrEmpty(saveGamePath)) {	×
60	logger.Error("Copy Failed - save game path is empty, did we even convert anything?");	×
61	return false;	×
62	}
63	if (!File.Exists(saveGamePath)) {	×
64	logger.Error("Copy Failed - save game does not exist, did we even convert anything?");	×
65	return false;	×
66	}
67	if (Directory.Exists(saveGamePath)) {	×
68	logger.Error("Copy Failed - Save game is a directory...");	×
69	return false;	×
70	}
71	saveGamePath = CommonFunctions.TrimPath(saveGamePath);	×
72	saveGamePath = CommonFunctions.NormalizeStringPath(saveGamePath);	×
73	var pos = saveGamePath.LastIndexOf('.');	×
74	if (pos != -1) {	×
75	saveGamePath = saveGamePath[..pos];	×
76	}	×
77	targetName = saveGamePath;	×
78	}	×
79
80	targetName = CommonFunctions.ReplaceCharacter(targetName, '-');	×
81	targetName = CommonFunctions.ReplaceCharacter(targetName, ' ');	×
82	targetName = CommonFunctions.NormalizeUTF8Path(targetName);	×
83
84	var modFolderPath = Path.Combine(outputFolder, targetName);	×
85	if (!Directory.Exists(modFolderPath)) {	×
86	logger.Error($"Copy Failed - Could not find mod folder: {modFolderPath}");	×
87	return false;	×
88	}
89
90	// For games using mods with .metadata folders we need to skip .mod file requirement.
91	bool skipModFile = false;	×
92	var metadataPath = Path.Combine(outputFolder, $"{targetName}/.metadata");	×
93	if (Directory.Exists(metadataPath)) {	×
94	skipModFile = true;	×
95	}	×
96
97	var modFilePath = Path.Combine(outputFolder, $"{targetName}.mod");	×
98	if (!skipModFile && !File.Exists(modFilePath)) {	×
99	logger.Error($"Copy Failed - Could not find mod: {modFilePath}");	×
100	return false;	×
101	}
102
103	var destModFilePath = Path.Combine(destModsFolder, $"{targetName}.mod");	×
104	if (!skipModFile && File.Exists(destModFilePath)) {	×
105	logger.Info("Previous mod file found, deleting...");	×
106	File.Delete(destModFilePath);	×
107	}	×
108
109	var destModFolderPath = Path.Combine(destModsFolder, targetName);	×
110	if (Directory.Exists(destModFolderPath)) {	×
111	logger.Info("Previous mod directory found, deleting...");	×
112	if (!SystemUtils.TryDeleteFolder(destModFolderPath)) {	×
113	logger.Error($"Could not delete directory: {destModFolderPath}");	×
114	return false;	×
115	}
116	}	×
117	try {	×
118	logger.Info("Copying mod to target location...");	×
119	if (!skipModFile) {	×
120	if (!SystemUtils.TryCopyFile(modFilePath, destModFilePath)) {	×
121	logger.Error($"Could not copy file: {modFilePath}\nto {destModFilePath}");	×
122	}	×
123	}	×
124	if (!SystemUtils.TryCopyFolder(modFolderPath, destModFolderPath)) {	×
125	logger.Error($"Could not copy folder: {modFolderPath}\nto {destModFolderPath}");	×
126	}	×
127	} catch (Exception e) {	×
128	logger.Error(e.ToString());	×
129	return false;	×
130	}
131	logger.Notice($"Mod successfully copied to: {destModFolderPath}");	×
132
133	CreatePlayset(destModsFolder, targetName, destModFolderPath);	×
134
135	return true;	×
136	}	×
137
138	private void CreatePlayset(string targetModsDirectory, string modName, string destModFolder) {	×
139	var gameDocsDirectory = Directory.GetParent(targetModsDirectory)?.FullName;	×
140	if (gameDocsDirectory is null) {	×
141	logger.Warn($"Couldn't get parent directory of \"{targetModsDirectory}\".");	×
142	return;	×
143	}
NEW 144	var latestDbFilePath = TargetDbManager.GetLastUpdatedLauncherDbPath(gameDocsDirectory);	×
145	if (latestDbFilePath is null) {	×
146	logger.Debug("Launcher's database not found.");	×
147	return;	×
148	}
149	logger.Debug($"Launcher's database found at \"{latestDbFilePath}\".");	×
150
151	logger.Info("Setting up playset...");	×
152	string connectionString = $"Data Source={latestDbFilePath};";	×
153	try {	×
154	logger.Debug("Connecting to launcher's DB...");	×
155	var dbContext = new LauncherDbContext(connectionString);	×
156
157	var playsetName = $"{config.Name}: {modName}";	×
158	var dateTimeOffset = new DateTimeOffset(DateTime.UtcNow);	×
159	string unixTimeMilliSeconds = dateTimeOffset.ToUnixTimeMilliseconds().ToString(CultureInfo.InvariantCulture);	×
160
161	DeactivateCurrentPlayset(dbContext);	×
162
163	// Check if a playset with the same name already exists.
164	var playset = dbContext.Playsets.FirstOrDefault(p => p.Name == playsetName);	×
165	if (playset is not null) {	×
166	logger.Debug("Removing mods from existing playset...");	×
167	dbContext.PlaysetsMods.RemoveRange(dbContext.PlaysetsMods.Where(pm => pm.PlaysetId == playset.Id));	×
168	dbContext.SaveChanges();	×
169
170	logger.Debug("Re-activating existing playset...");	×
171	// Set isActive to true and updatedOn to current time.
172	playset.IsActive = true;	×
173	playset.UpdatedOn = unixTimeMilliSeconds;	×
174	dbContext.SaveChanges();	×
175
176	logger.Notice("Updated existing playset.");	×
177	} else {	×
178	logger.Debug("Creating new playset...");	×
179	playset = new Playset {	×
180	Id = Guid.NewGuid().ToString(),	×
181	Name = playsetName,	×
182	IsActive = true,	×
183	IsRemoved = false,	×
184	HasNotApprovedChanges = false,	×
185	CreatedOn = unixTimeMilliSeconds	×
186	};	×
187	dbContext.Playsets.Add(playset);	×
188	dbContext.SaveChanges();	×
189	}	×
190
191	Logger.Debug("Adding mods to playset...");	×
192	var playsetInfo = LoadPlaysetInfo();	×
193	if (playsetInfo.Count == 0) {	×
194	var gameRegistryId = $"mod/{modName}.mod";	×
195	var mod = AddModToDb(dbContext, modName, gameRegistryId, destModFolder);	×
196	AddModToPlayset(dbContext, mod, playset);	×
197	}	×
198	foreach (var (playsetModName, playsetModPath) in playsetInfo) {	×
199	string playsetModPathWithBackSlashes = playsetModPath.Replace('/', '\\');	×
200
201	// Try to get an ID of existing matching mod.
202	var mod = dbContext.Mods.FirstOrDefault(m => m.Name == playsetModName \|\|	×
203	m.DirPath == playsetModPath \|\|	×
204	m.DirPath == playsetModPathWithBackSlashes);	×
205	if (mod is not null) {	×
206	AddModToPlayset(dbContext, mod, playset);	×
207	} else {	×
208	var gameRegistryId = playsetModPath;	×
209	if (!gameRegistryId.StartsWith("mod/", StringComparison.Ordinal)) {	×
210	gameRegistryId = $"mod/{gameRegistryId}";	×
211	}	×
212	if (!gameRegistryId.EndsWith(".mod", StringComparison.Ordinal)) {	×
213	gameRegistryId = $"{gameRegistryId}.mod";	×
214	}	×
215
216	string dirPath;
217	if (Path.IsPathRooted(playsetModPath)) {	×
218	dirPath = playsetModPath;	×
219	} else {	×
220	dirPath = Path.Combine(gameDocsDirectory, gameRegistryId);	×
221	}	×
222
223	mod = AddModToDb(dbContext, modName, gameRegistryId, dirPath);	×
224	AddModToPlayset(dbContext, mod, playset);	×
225	}	×
226	}	×
227
228	logger.Notice("Successfully set up playset.");	×
229	} catch (Exception e) {	×
230	logger.Error(e);	×
231	}	×
232	}	×
233
234	// Returns saved mod.
235	private Mod AddModToDb(LauncherDbContext dbContext, string modName, string gameRegistryId, string dirPath) {	×
236	logger.Debug($"Saving mod \"{modName}\" to DB...");	×
237
238	var mod = new Mod {	×
239	Id = Guid.NewGuid().ToString(),	×
240	Status = "ready_to_play",	×
241	Source = "local",	×
242	Version = "1",	×
243	GameRegistryId = gameRegistryId,	×
244	Name = modName,	×
245	DirPath = dirPath,	×
246	};	×
247	dbContext.Mods.Add(mod);	×
248	dbContext.SaveChanges();	×
249
250	return mod;	×
251	}	×
252
253	private static void AddModToPlayset(LauncherDbContext dbContext, Mod mod, Playset playset) {	×
254	var playsetMod = new PlaysetsMod {	×
255	Playset = playset,	×
256	Mod = mod,	×
257	};	×
258	dbContext.PlaysetsMods.Add(playsetMod);	×
259	dbContext.SaveChanges();	×
260	}	×
261
262	// Loads playset info generated by converter backend.
263	private Open.Collections.OrderedDictionary<string, string> LoadPlaysetInfo() {	×
264	logger.Debug("Loading playset info from converter backend...");	×
265	var toReturn = new Open.Collections.OrderedDictionary<string, string>();	×
266
267	var filePath = Path.Combine(config.ConverterFolder, "playset_info.txt");	×
268	if (!File.Exists(filePath)) {	×
269	return toReturn;	×
270	}
271
272	var parser = new Parser();	×
273	parser.RegisterRegex(CommonRegexes.QuotedString, (reader, modName) => {	×
274	toReturn.Add(modName, reader.GetString().RemQuotes());	×
275	});	×
276	parser.ParseFile(filePath);	×
277	return toReturn;	×
278	}	×
279
280	private void DeactivateCurrentPlayset(LauncherDbContext dbContext) {	×
281	logger.Debug("Deactivating currently active playset...");	×
282	dbContext.Playsets	×
283	.Where(p => p.IsActive == true)	×
284	.ToList()	×
285	.ForEach(p => p.IsActive = false);	×
286	dbContext.SaveChanges();	×
287	}	×
288	}

ParadoxGameConverters / Fronter.NET / 21217561952

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous