public static void OpenModsFolder(ModProjectData modProjectData)
{
Log.Here().Activity($"Attempting to open mods folder");
if (MainData != null)
{
string startPath = Path.Combine(MainData.Settings.DOS2DEDataDirectory, "Mods");
string directory = Path.Combine(Path.GetFullPath(startPath), modProjectData.FolderName);
Log.Here().Activity($"Attempting to open directory {directory}");
if (Directory.Exists(directory))
{
Process.Start(directory);
}
else
{
if (Directory.Exists(startPath))
{
Process.Start(startPath);
}
else
{
Log.Here().Error($"Mod directory for project {modProjectData.FolderName} does not exist!");
}
}
}
}
public static void OpenProjectFolder(ModProjectData modProjectData)
{
if (MainData != null)
{
string startPath = Path.Combine(MainData.Settings.DOS2DEDataDirectory, "Projects");
string directory = Path.Combine(Path.GetFullPath(startPath), modProjectData.ProjectFolder);
if (!Directory.Exists(directory))
{
directory = Path.Combine(Path.GetFullPath(startPath), modProjectData.ModuleInfo.Folder); // Imported projects
}
if (Directory.Exists(directory))
{
Process.Start(directory);
}
else
{
if (Directory.Exists(startPath))
{
Process.Start(startPath);
}
else
{
Log.Here().Error($"Projects directory for project {modProjectData.FolderName} does not exist!");
}
}
}
}
private async Task <int> OnGitGenerationAsync()
{
Log.Here().Important("Generating git repositories for selected projects.");
int total = Data.GitGenerationSettings.ExportProjects.Count;
AppController.Main.Data.ProgressValueMax = total;
//Log.Here().Activity($"[Progress] Amount per tick set to {amountPerTick}");
AppController.Main.UpdateProgressMessage("Parsing selected projects...");
var totalSuccess = 0;
var sortedProjects = Data.GitGenerationSettings.ExportProjects.OrderBy(p => p.ProjectName).ToImmutableList();
if (Data.GitGenerationSettings.ExportProjects.TryOperation(c => c.Clear()))
{
Data.GitGenerationSettings.ExportProjects.DoOperation(c => c.AddRange(sortedProjects));
}
for (var i = 0; i < total; i++)
{
AppController.Main.UpdateProgressTitle($"Generating Git Files... {(i)}/{total}");
var project = Data.GitGenerationSettings.ExportProjects[i];
AppController.Main.UpdateProgressMessage($"Generating git files for project {project.ProjectName}...");
//Log.Here().Activity($"[Progress] Target percentage for this iteration is {targetPercentage}, work should increase it by {totalPercentageAmount}");
ModProjectData modProjectData = (ModProjectData)project;
var success = await GenerateGitFilesAsync(modProjectData, Data.GitGenerationSettings).ConfigureAwait(false);
if (success)
{
totalSuccess += 1;
AppController.Main.UpdateProgressLog($"Successfuly generated git repo for project {project.DisplayName}.");
Log.Here().Important("Git repository successfully generated for {0}.", project.DisplayName);
}
else
{
AppController.Main.UpdateProgressLog($"Error generating git repo for project {project.DisplayName}.");
Log.Here().Error("Error generating git repository for {0}.", project.DisplayName);
}
AppController.Main.UpdateProgress(1);
AppController.Main.UpdateProgressTitle($"Generating Git Files... {(i + 1)}/{total}");
}
AppController.Main.UpdateProgressTitle($"Generating Git Files... {total}/{total}");
AppController.Main.UpdateProgressMessage("Finishing up...");
AppController.Main.UpdateProgressLog("Git generation complete. We did it!");
AppController.Main.FinishProgress();
return(totalSuccess);
}
public static async Task <Unit> OpenLocalizationEditorForProject(ModProjectData modData)
{
Log.Here().Activity($"Opening locale editor for project {modData.DisplayName}");
LocaleViewModel localizationData = new LocaleViewModel();
LocaleEditorCommands.LoadSettings(_instance.ViewModel, localizationData);
await LocaleEditorCommands.LoadLocalizationDataAsync(localizationData, _instance.ViewModel, modData);
RxApp.MainThreadScheduler.Schedule(_ =>
{
_instance.OpenLocalizationEditorWithData(localizationData);
});
return(Unit.Default);
}
public static void OpenBackupFolder(ModProjectData modProjectData)
{
if (MainData != null)
{
string directory = Path.Combine(Path.GetFullPath(MainData.Settings.BackupRootDirectory), modProjectData.ProjectName);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
Process.Start(directory);
}
else
{
Log.Here().Error($"MainData is null!");
}
}
public static void OpenGitFolder(ModProjectData modProjectData)
{
if (MainData != null)
{
string directory = modProjectData.GitData?.RepositoryPath;
if (!String.IsNullOrEmpty(directory) && Directory.Exists(directory))
{
Process.Start(directory);
}
else
{
Process.Start(Path.GetFullPath(MainData.Settings.GitRootDirectory));
}
}
else
{
Log.Here().Error($"MainData is null!");
}
}
public void TestView()
{
/*
* Data.UserKeywords.RemoveEmpty();
*
* for (int i = 0; i < 50; i++)
* {
* string testStr = "test_" + i;
*
* var tdata = new TemplateEditorData()
* {
* ID = testStr,
* Name = testStr
* };
* tdata.Init(Data);
* Data.Templates.Add(tdata);
*
* var kdata = new KeywordData()
* {
* KeywordName = testStr,
* KeywordValue = ""
* };
* Data.UserKeywords.Keywords.Add(kdata);
* }
*/
Data.NewProjects.Add(new AvailableProjectViewData()
{
Name = "SJjjsjdiasjdiasidiahdisahdihaisdhddddddddddddddddddddddddddddddddddddddddiasdias"
});
for (var i = 0; i < 15; i++)
{
Data.NewProjects.Add(new AvailableProjectViewData()
{
Name = "Project_" + i
});
}
Data.ManagedProjects.Add(ModProjectData.Test("Test Project"));
Data.ManagedProjects.Add(ModProjectData.Test("Test Project 2"));
}
public bool GenerateBackupFolder(ModProjectData modProject = null)
{
string projectBackupDirectory = Data.Settings.BackupRootDirectory;
if (modProject != null)
{
projectBackupDirectory = Path.Combine(Data.Settings.BackupRootDirectory, modProject.ProjectName);
}
try
{
Directory.CreateDirectory(projectBackupDirectory);
return(true);
}
catch (Exception ex)
{
MainWindow.FooterError("Error creating backup directory at {0}: {1}", projectBackupDirectory, ex.Message);
}
return(false);
}
private List <JunctionData> PrepareDirectories(ModProjectData project, List <string> DirectoryLayouts)
{
var sourceFolders = new List <JunctionData>();
foreach (var directoryBaseName in DirectoryLayouts)
{
var projectSubdirectoryName = directoryBaseName.Replace("ProjectName", project.ProjectName).Replace("ProjectGUID", project.ModuleInfo.UUID);
var junctionSourceDirectory = Path.Combine(Data.Settings.DOS2DataDirectory, projectSubdirectoryName);
if (!Directory.Exists(junctionSourceDirectory))
{
Log.Here().Important($"Directory {projectSubdirectoryName} doesn't exist. Creating directory.");
Directory.CreateDirectory(junctionSourceDirectory);
}
sourceFolders.Add(new JunctionData()
{
SourcePath = junctionSourceDirectory,
BasePath = projectSubdirectoryName
});
}
return(sourceFolders);
}
public static void OpenEditorFolder(ModProjectData modProjectData)
{
if (MainData != null)
{
string startPath = Path.Combine(MainData.Settings.DOS2DEDataDirectory, "Editor/Mods");
string directory = Path.Combine(Path.GetFullPath(startPath), modProjectData.FolderName);
if (Directory.Exists(directory))
{
Process.Start(directory);
}
else
{
if (Directory.Exists(startPath))
{
Process.Start(startPath);
}
else
{
Log.Here().Error($"Editor directory for project {modProjectData.FolderName} does not exist!");
}
}
}
}
public static List <ModProjectData> LoadModProjects(DOS2DEModuleData Data, bool clearExisting = false)
{
if (clearExisting)
{
Data.ModProjects.Clear();
Log.Here().Important("Cleared mod project data.");
}
List <ModProjectData> newItems = new List <ModProjectData>();
if (Data.Settings != null && !String.IsNullOrEmpty(Data.Settings.DOS2DEDataDirectory))
{
if (Directory.Exists(Data.Settings.DOS2DEDataDirectory))
{
string projectsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Projects");
string modsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Mods");
if (Directory.Exists(modsPath))
{
Log.Here().Activity("Loading DOS2 projects from mods directory at: {0}", modsPath);
DirectoryEnumerationFilters filters = new DirectoryEnumerationFilters()
{
InclusionFilter = (f) =>
{
return(!IgnoredFolders.Contains(f.FileName));
},
};
var modFolders = Directory.EnumerateDirectories(modsPath, DirectoryEnumerationOptions.Folders, filters, PathFormat.LongFullPath);
if (modFolders != null)
{
foreach (string modFolder in modFolders)
{
var modFolderName = Path.GetFileName(modFolder);
//Log.Here().Activity("Checking project mod folder: {0}", modFolderName);
var metaFilePath = Path.Combine(modFolder, "meta.lsx");
if (File.Exists(metaFilePath))
{
//Log.Here().Activity("Meta file found for project {0}. Reading file.", modFolderName);
ModProjectData modProjectData = new ModProjectData();
modProjectData.LoadAllData(metaFilePath, projectsPath);
//Log.Here().Activity("Finished reading meta files for mod: {0}", modProjectData.ModuleInfo.Name);
if (!clearExisting)
{
var previous = Data.ModProjects.Items.FirstOrDefault(p => p.FolderName == modProjectData.FolderName);
if (previous != null)
{
if (previous.DataIsNewer(modProjectData))
{
previous.UpdateData(modProjectData);
}
}
else
{
newItems.Add(modProjectData);
}
}
else
{
newItems.Add(modProjectData);
}
}
}
}
}
}
else
{
Log.Here().Error("Loading available projects failed. DOS2 data directory not found at {0}", Data.Settings.DOS2DEDataDirectory);
}
}
return(newItems);
}
public static async Task <List <ModProjectData> > LoadModProjectsAsync(DOS2DEModuleData Data, bool clearExisting = false)
{
if (clearExisting)
{
Log.Here().Important("Clearing mod projects");
if (Thread.CurrentThread.IsBackground)
{
await Observable.Start(() =>
{
Data.ModProjects.Clear();
return(Unit.Default);
}, RxApp.MainThreadScheduler);
}
else
{
Data.ModProjects.Clear();
}
}
List <ModProjectData> newItems = new List <ModProjectData>();
if (Data.Settings != null && !String.IsNullOrEmpty(Data.Settings.DOS2DEDataDirectory))
{
if (Directory.Exists(Data.Settings.DOS2DEDataDirectory))
{
string projectsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Projects");
string modsPath = Path.Combine(Data.Settings.DOS2DEDataDirectory, "Mods");
if (Directory.Exists(modsPath))
{
Log.Here().Activity($"Loading DOS2 projects from mods directory at: {modsPath}");
//DirectoryInfo modsRoot = new DirectoryInfo(modsPath);
//var modFolders = modsRoot.GetDirectories().Where(s => !IgnoredFolders.Contains(s.Name));
DirectoryEnumerationFilters filters = new DirectoryEnumerationFilters()
{
InclusionFilter = (f) =>
{
return(!IgnoredFolders.Contains(f.FileName));
},
};
//var modFolders = await Observable.Start(() =>
//{
// return Directory.EnumerateDirectories(modsPath, DirectoryEnumerationOptions.Folders, filters, PathFormat.LongFullPath);
//}, RxApp.TaskpoolScheduler);
var modFolders = Directory.EnumerateDirectories(modsPath, DirectoryEnumerationOptions.Folders, filters, PathFormat.LongFullPath);
if (modFolders != null)
{
foreach (string modFolder in modFolders)
{
try
{
var modFolderName = Path.GetFileName(modFolder);
Log.Here().Activity($"Checking project mod folder: {modFolderName}");
var metaFilePath = Path.Combine(modFolder, "meta.lsx");
if (File.Exists(metaFilePath))
{
Log.Here().Activity($"Meta file found for project {modFolderName}. Reading file.");
ModProjectData modProjectData = new ModProjectData();
await modProjectData.LoadAllDataAsync(metaFilePath, projectsPath);
Log.Here().Activity($"Finished reading meta files for mod: {modProjectData.ModuleInfo.Name}");
if (!clearExisting)
{
var previous = Data.ModProjects.Items.FirstOrDefault(p => p.FolderName == modProjectData.FolderName);
if (previous != null)
{
if (previous.DataIsNewer(modProjectData))
{
if (Thread.CurrentThread.IsBackground)
{
await Observable.Start(() =>
{
previous.UpdateData(modProjectData);
return(Unit.Default);
}, RxApp.MainThreadScheduler);
}
else
{
previous.UpdateData(modProjectData);
}
}
}
else
{
newItems.Add(modProjectData);
}
}
else
{
newItems.Add(modProjectData);
}
}
}
catch (Exception ex)
{
Log.Here().Error($"Error parsing mod folder ${modFolder}:");
Log.Here().Error(ex.ToString());
}
}
}
}
}
else
{
Log.Here().Error("Loading available projects failed. DOS2 data directory not found at {0}", Data.Settings.DOS2DEDataDirectory);
}
}
return(newItems);
}
public static void LoadManagedProjects(DOS2ModuleData Data, bool ClearExisting = true)
{
if (Data.ManagedProjects == null)
{
Data.ManagedProjects = new ObservableImmutableList <ModProjectData>();
BindingOperations.EnableCollectionSynchronization(Data.ManagedProjects, Data.ManagedProjectsLock);
}
else
{
if (ClearExisting)
{
Data.ManagedProjects.DoOperation(data => data.Clear());
BindingOperations.EnableCollectionSynchronization(Data.ManagedProjects, Data.ManagedProjectsLock);
}
}
string projectsAppDataPath = DefaultPaths.ModuleAddedProjectsFile(Data);
if (Data.Settings != null && File.Exists(Data.Settings.AddedProjectsFile))
{
projectsAppDataPath = Data.Settings.AddedProjectsFile;
}
if (!String.IsNullOrEmpty(projectsAppDataPath) && File.Exists(projectsAppDataPath))
{
//projectsAppDataPath = Path.GetFullPath(projectsAppDataPath);
try
{
Data.ManagedProjectsData = JsonInterface.DeserializeObject <ManagedProjectsData>(projectsAppDataPath);
}
catch (Exception ex)
{
Log.Here().Error("Error deserializing managed projects data at {0}: {1}", projectsAppDataPath, ex.ToString());
}
}
if (Data.ManagedProjectsData == null)
{
Data.ManagedProjectsData = new ManagedProjectsData();
}
else
{
foreach (var project in Data.ManagedProjectsData.SavedProjects.Items)
{
//var modProject = Data.ModProjects.Where(x => x.Name == project.Name && x.ModuleInfo.UUID == project.GUID).FirstOrDefault();
var modProject = Data.ModProjects.Where(x => x.UUID == project.UUID).FirstOrDefault();
if (modProject != null)
{
ModProjectData existingData = null;
if (!ClearExisting)
{
existingData = Data.ManagedProjects.Where(p => p.ProjectName == project.Name && p.UUID == project.UUID).FirstOrDefault();
}
if (ClearExisting || existingData == null)
{
Data.ManagedProjects.Add(modProject);
if (!String.IsNullOrWhiteSpace(project.LastBackupUTC))
{
DateTime lastBackup;
var success = DateTime.TryParse(project.LastBackupUTC, out lastBackup);
if (success)
{
//Log.Here().Activity($"Successully parsed {modProject.LastBackup} to DateTime.");
modProject.LastBackup = lastBackup.ToLocalTime();
}
else
{
Log.Here().Error($"Could not convert {project.LastBackupUTC} to DateTime.");
}
}
}
else if (existingData != null)
{
existingData.ReloadData();
}
}
}
}
}
public async Task <FileCreationTaskResult> BackupProjectAsync(ModProjectData modProject, string OutputDirectory = "", BackupMode mode = BackupMode.Zip)
{
if (String.IsNullOrWhiteSpace(OutputDirectory))
{
OutputDirectory = Path.Combine(Path.GetFullPath(Data.Settings.BackupRootDirectory), modProject.ProjectName);
Directory.CreateDirectory(OutputDirectory);
}
else
{
OutputDirectory = Path.GetFullPath(OutputDirectory);
}
string sysFormat = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern.Replace("/", "-");
//Log.Here().Important($"System date format: {sysFormat}");
string archiveName = modProject.ProjectName + "_" + DateTime.Now.ToString(sysFormat + "_HH-mm-ss") + ".zip";
string archivePath = Path.Combine(OutputDirectory, archiveName);
string gitProjectDirectory = "";
/*
* bool gitProjectDetected = false;
*
* if (!String.IsNullOrEmpty(Data.Settings.GitRootDirectory))
* {
* gitProjectDirectory = Path.Combine(Data.Settings.GitRootDirectory, modProject.ProjectName);
* if (Directory.Exists(gitProjectDirectory))
* {
* gitProjectDirectory = Path.Combine(Data.Settings.GitRootDirectory, modProject.ProjectName);
* gitProjectDetected = true;
* AppController.Main.UpdateProgressLog("Git repository detected.");
* }
* }
*/
var sourceFolders = PrepareDirectories(modProject, Data.Settings.DirectoryLayouts);
if (!modProject.GitGenerated)
{
AppController.Main.UpdateProgressLog("Creating zip archive from project folders...");
//Log.Here().Activity($"Git project not found. Archiving project {modProject.ProjectName} from project folders directly.");
return(await BackupGenerator.CreateArchiveFromRoot(Data.Settings.DOS2DataDirectory.Replace("/", "\\\\"), sourceFolders, archivePath, true, cancellationTokenSource.Token).ConfigureAwait(false));
}
else
{
gitProjectDirectory = Path.Combine(Data.Settings.GitRootDirectory, modProject.ProjectName);
if (mode == BackupMode.GitArchive)
{
AppController.Main.UpdateProgressLog("Running git archive command...");
var success = await GitGenerator.Archive(gitProjectDirectory, archivePath).ConfigureAwait(false);
return(success ? FileCreationTaskResult.Success : FileCreationTaskResult.Error);
}
else
{
AppController.Main.UpdateProgressLog("Creating zip archive...");
return(await BackupGenerator.CreateArchiveFromRepo(gitProjectDirectory, Data.Settings.DOS2DataDirectory.Replace("/", "\\\\"), sourceFolders, archivePath, true, cancellationTokenSource.Token).ConfigureAwait(false));
}
//Seems to have a problem with junctions and long paths
//return BackupGenerator.CreateArchiveFromRepo(gitProjectDirectory, archivePath);
}
}
private async Task <bool> GenerateGitFilesAsync(ModProjectData modProject, GitGenerationSettings generationSettings)
{
if (modProject == null)
{
return(false);
}
//Log.Here().Activity($"[Progress] percentageIncrement is {percentageIncrement} / {endPercentage}");
if (!string.IsNullOrEmpty(Data.Settings.GitRootDirectory))
{
string gitProjectRootDirectory = Path.Combine(Data.Settings.GitRootDirectory, modProject.ProjectName);
AppController.Main.UpdateProgressLog("Creating git project directory...");
var rootRepoDirectory = Directory.CreateDirectory(gitProjectRootDirectory);
if (!Directory.Exists(gitProjectRootDirectory))
{
Directory.CreateDirectory(gitProjectRootDirectory);
}
if (generationSettings.InitGit)
{
AppController.Main.UpdateProgressLog("Initializing git repo...");
var author = Data.Settings.DefaultAuthor;
if (modProject.ModuleInfo != null && !String.IsNullOrWhiteSpace(modProject.ModuleInfo.Author))
{
author = modProject.ModuleInfo.Author;
}
var result = await GitGenerator.InitRepository(gitProjectRootDirectory, author);
if (result)
{
Log.Here().Activity("Created git repository for project ({0}) at {1}", modProject.ProjectName, gitProjectRootDirectory);
}
else
{
Log.Here().Error("Error creating git repository for project {0}.", modProject.ProjectName);
}
}
bool commitGit = false;
string commitMessage = "";
if (generationSettings.CreateJunctions)
{
AppController.Main.UpdateProgressLog("Creating junctions...");
var sourceFolders = PrepareDirectories(modProject, Data.Settings.DirectoryLayouts);
var result = GitGenerator.CreateJunctions(modProject.ProjectName, sourceFolders, Data);
if (result)
{
Log.Here().Activity("[{0}] Successfully created junctions.", modProject.ProjectName);
commitGit = true;
commitMessage = "Junctioned project folders";
}
else
{
Log.Here().Error("[{0}] Problem creating junctions.", modProject.ProjectName);
}
}
if (generationSettings.TemplateSettings != null && generationSettings.TemplateSettings.Count > 0)
{
AppController.Main.UpdateProgressLog("Generating templates...");
foreach (var templateSetting in generationSettings.TemplateSettings)
{
var templateData = Data.Templates.Where(t => t.Name == templateSetting.TemplateName).FirstOrDefault();
if (templateData != null)
{
if (templateSetting.Enabled)
{
string outputFilePath = Path.Combine(gitProjectRootDirectory, templateData.ExportPath);
string outputText = GitGenerator.ReplaceKeywords(templateData.EditorText, modProject, MainAppData, Data);
if (!FileCommands.WriteToFile(outputFilePath, outputText))
{
Log.Here().Error("[{0}] Failed to create template file at {1}", modProject.ProjectName, templateData.ExportPath);
}
else
{
commitGit = true;
commitMessage += (", added " + templateData.Name);
}
}
else
{
Log.Here().Activity("[{0}] Skipping {1}", modProject.ProjectName, templateSetting.TemplateName);
}
}
}
}
if (generationSettings.SelectedLicense != LicenseType.None)
{
AppController.Main.UpdateProgressLog("Generating license...");
string outputText = "";
if (generationSettings.SelectedLicense == LicenseType.Custom)
{
var customLicenseTemplate = Data.Templates.Where(t => t.Name == "LICENSE").FirstOrDefault();
if (customLicenseTemplate != null)
{
outputText = customLicenseTemplate.EditorText;
}
}
else
{
switch (generationSettings.SelectedLicense)
{
case LicenseType.MIT:
outputText = Properties.Resources.License_MIT;
break;
case LicenseType.Apache:
outputText = Properties.Resources.License_Apache;
break;
case LicenseType.GPL:
outputText = Properties.Resources.License_GPL;
break;
}
}
if (!String.IsNullOrEmpty(outputText))
{
outputText = GitGenerator.ReplaceKeywords(outputText, modProject, MainAppData, Data);
}
string licenseFile = Path.Combine(gitProjectRootDirectory, "LICENSE");
if (!FileCommands.WriteToFile(licenseFile, outputText))
{
Log.Here().Error("[{0}] Failed to write license template file at {1}", modProject.ProjectName, licenseFile);
}
else
{
commitGit = true;
commitMessage += ", added license";
}
}
if (generationSettings.InitGit && commitGit)
{
AppController.Main.UpdateProgressLog("Committing new files...");
var result = await GitGenerator.Commit(gitProjectRootDirectory, commitMessage);
if (result)
{
AppController.Main.UpdateProgressLog($"Successfully commited git repo for project {modProject.DisplayName}.");
}
else
{
AppController.Main.UpdateProgressLog($"Git repo failed to commit for project {modProject.DisplayName}.");
}
}
AppController.Main.UpdateProgressLog("Generating source control data file...");
SourceControlData sourceControlData = new SourceControlData()
{
ProjectName = modProject.ProjectName,
ProjectUUID = modProject.UUID
};
modProject.GitData = sourceControlData;
FileCommands.Save.SaveSourceControlData(sourceControlData, gitProjectRootDirectory);
AppController.Main.UpdateProgressAndMax(1);
return(true);
}
//}
//catch(Exception ex)
//{
// Log.Here().Error($"Error generating git files: {ex.ToString()}");
//}
return(false);
}
public void LoadData(ModProjectData projectData)
{
initialVersionData = new ProjectVersionData(projectData.ModuleInfo.Version);
SelectedProject = projectData;
DataContext = SelectedProject;
}
public static void EditProjectVersion(ModProjectData projectData)
{
_instance.EditVersionWindow.LoadData(projectData);
_instance.EditVersionWindow.Owner = _instance.MainWindow;
_instance.EditVersionWindow.Show();
}
public void AddProjects(List <AvailableProjectViewData> selectedItems)
{
bool bSaveData = false;
foreach (AvailableProjectViewData project in selectedItems)
{
Log.Here().Activity($"Adding project {project.Name} data to managed projects.");
var modData = Data.ModProjects.Where(p => p.ProjectName == project.Name).FirstOrDefault();
if (modData != null)
{
//ManagedProjects.Add(new ProjectEntryData(modData.ProjectInfo, modData.ModInfo));
Data.ManagedProjects.Add(modData);
var availableProject = Data.NewProjects.Where(p => p.Name == project.Name).FirstOrDefault();
if (availableProject != null)
{
Data.NewProjects.Remove(availableProject);
}
if (Data.ManagedProjectsData.SavedProjects.Items.Any(p => p.UUID == modData.UUID))
{
if (modData.ProjectAppData == null)
{
ProjectAppData data = Data.ManagedProjectsData.SavedProjects.Items.Where(p => p.UUID == modData.ModuleInfo.UUID).FirstOrDefault();
if (data != null)
{
modData.ProjectAppData = data;
Log.Here().Activity($"Linked project {modData.ProjectName} data to managed project data.");
}
}
}
else
{
ProjectAppData data = new ProjectAppData()
{
Name = modData.ProjectName,
UUID = modData.ModuleInfo.UUID,
LastBackupUTC = null
};
Data.ManagedProjectsData.SavedProjects.AddOrUpdate(data);
modData.ProjectAppData = data;
Log.Here().Activity($"Added project {modData.DisplayName} to managed projects.");
bSaveData = true;
}
}
else
{
#if DEBUG
Data.ManagedProjects.Add(ModProjectData.Test(project.Name));
#else
MainWindow.FooterError($"Error adding project {project.Name} to managed projects: Mod data doesn't exist.");
#endif
}
}
Data.RaisePropertyChanged("NewProjects");
if (bSaveData)
{
if (DOS2Commands.SaveManagedProjects(Data))
{
MainWindow.FooterLog("Saved Managed Projects data to {0}.", Data.Settings.AddedProjectsFile);
}
else
{
MainWindow.FooterError("Error saving Managed Projects data to {0}.", Data.Settings.AddedProjectsFile);
}
}
}
public static string CustomLocaleDirectory(DOS2DEModuleData Data, ModProjectData modProject)
{
return(Path.Combine(Data.Settings.GitRootDirectory, modProject.ProjectName, @"LocaleEditor\"));
}
public static void LoadModProjects(DOS2ModuleData Data, bool ClearPrevious = true)
{
if (Data.ModProjects == null)
{
Data.ModProjects = new ObservableImmutableList <ModProjectData>();
BindingOperations.EnableCollectionSynchronization(Data.ModProjects, Data.ModProjectsLock);
}
else
{
if (ClearPrevious)
{
Data.ModProjects.DoOperation(data => data.Clear());
BindingOperations.EnableCollectionSynchronization(Data.ModProjects, Data.ModProjectsLock);
}
}
if (Data.Settings != null && !String.IsNullOrEmpty(Data.Settings.DOS2DataDirectory))
{
if (Directory.Exists(Data.Settings.DOS2DataDirectory))
{
string projectsPath = Path.Combine(Data.Settings.DOS2DataDirectory, "Projects");
string modsPath = Path.Combine(Data.Settings.DOS2DataDirectory, "Mods");
if (Directory.Exists(modsPath))
{
Log.Here().Activity("Loading DOS2 projects from mods directory at: {0}", modsPath);
DirectoryInfo modsRoot = new DirectoryInfo(modsPath);
var modFolders = modsRoot.GetDirectories().Where(s => !ignoredFolders.Contains(s.Name));
if (modFolders != null)
{
foreach (DirectoryInfo modFolderInfo in modFolders)
{
var modFolderName = modFolderInfo.Name;
Log.Here().Activity("Checking project mod folder: {0}", modFolderName);
var metaFile = modFolderInfo.GetFiles("meta.lsx").FirstOrDefault();
if (metaFile != null)
{
Log.Here().Activity("Meta file found for project {0}. Reading file.", modFolderName);
ModProjectData modProjectData = new ModProjectData(metaFile, projectsPath);
Log.Here().Activity("Finished reading meta files for mod: {0}", modProjectData.ModuleInfo.Name);
if (!ClearPrevious)
{
var previous = Data.ModProjects.Where(p => p.FolderName == modProjectData.FolderName).FirstOrDefault();
if (previous != null)
{
if (previous.DataIsNewer(modProjectData))
{
previous.UpdateData(modProjectData);
}
}
else
{
Data.ModProjects.DoOperation(data => data.Add(modProjectData));
}
}
else
{
Data.ModProjects.DoOperation(data => data.Add(modProjectData));
}
}
}
}
}
}
else
{
Log.Here().Error("Loading available projects failed. DOS2 data directory not found at {0}", Data.Settings.DOS2DataDirectory);
}
}
}