internal static SourceControlCollection DeserializeSourceControlCollection(JsonElement element)
{
IReadOnlyList <SourceControlData> value = default;
Optional <string> nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
List <SourceControlData> array = new List <SourceControlData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(SourceControlData.DeserializeSourceControlData(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new SourceControlCollection(value, nextLink.Value));
}
public bool SaveSourceControlData(IProjectData data, string folderPath)
{
SourceControlData sourceControlData = new SourceControlData()
{
ProjectName = data.ProjectName,
ProjectUUID = data.UUID,
RepositoryPath = folderPath,
SourceFile = Path.Combine(folderPath, DefaultPaths.SourceControlGeneratorDataFile)
};
return(SaveSourceControlData(sourceControlData, folderPath));
}
public static async Task <bool> LoadSourceControlDataAsync(DOS2DEModuleData Data, IEnumerable <ModProjectData> modProjects)
{
try
{
if (Directory.Exists(Data.Settings.GitRootDirectory))
{
int totalSuccess = 0;
var sourceFiles = new List <SourceControlData>();
var folders = Directory.EnumerateDirectories(Data.Settings.GitRootDirectory);
foreach (var folder in folders)
{
var sourceFile = Path.Combine(folder, "SourceControlGenerator.json");
if (File.Exists(sourceFile))
{
sourceFiles.Add(await SourceControlData.FromPathAsync(sourceFile));
}
}
foreach (var project in modProjects)
{
var sourceControlData = sourceFiles.FirstOrDefault(x => x.ProjectUUID == project.UUID || x.ProjectUUID == project.ProjectInfo.UUID);
if (sourceControlData != null)
{
project.GitData = sourceControlData;
project.GitGenerated = true;
var gitDirectory = Path.Combine(Path.GetDirectoryName(sourceControlData.SourceFile), ".git");
if (Directory.Exists(gitDirectory))
{
var lastModifiedDate = File.GetLastWriteTime(gitDirectory);
if (lastModifiedDate != null && project.ModuleInfo.ModifiedDate.Ticks < lastModifiedDate.Ticks)
{
project.ModuleInfo.ModifiedDate = lastModifiedDate;
}
}
totalSuccess += 1;
}
}
return(totalSuccess > 0);
}
}
catch (Exception ex)
{
Log.Here().Error("Error loading source control data:");
Log.Here().Error(ex.ToString());
}
return(false);
}
public SourceControlData LoadSourceControlData(string filePath)
{
if (!String.IsNullOrEmpty(filePath) && File.Exists(filePath))
{
try
{
SourceControlData data = JsonConvert.DeserializeObject <SourceControlData>(File.ReadAllText(filePath));
data.RepositoryPath = Directory.GetDirectoryRoot(filePath);
return(data);
}
catch (Exception ex)
{
Log.Here().Error("Error deserializing {0}: {1}", filePath, ex.ToString());
}
}
return(null);
}
public bool SaveSourceControlData(SourceControlData data, string folderPath)
{
if (!String.IsNullOrEmpty(folderPath) && Directory.Exists(folderPath))
{
Log.Here().Important("Serializing and saving source control data.");
var filePath = Path.Combine(folderPath, DefaultPaths.SourceControlGeneratorDataFile);
try
{
string json = JsonConvert.SerializeObject(data, Newtonsoft.Json.Formatting.Indented);
return(FileCommands.WriteToFile(filePath, json));
}
catch (Exception ex)
{
Log.Here().Error("Error serializing source control data at {0}: {1}", filePath, ex.ToString());
}
}
return(false);
}
public async Task <SourceControlData> LoadSourceControlDataAsync(string filePath)
{
if (!String.IsNullOrEmpty(filePath) && File.Exists(filePath))
{
try
{
var contents = await FileCommands.ReadFileAsync(filePath);
SourceControlData data = JsonConvert.DeserializeObject <SourceControlData>(contents);
data.RepositoryPath = Directory.GetDirectoryRoot(filePath);
return(data);
}
catch (Exception ex)
{
Log.Here().Error("Error deserializing {0}: {1}", filePath, ex.ToString());
}
}
return(null);
}
public static bool LoadSourceControlData(DOS2DEModuleData Data, IEnumerable <ModProjectData> modProjects)
{
if (Directory.Exists(Data.Settings.GitRootDirectory))
{
int totalSuccess = 0;
var projectFiles = Directory.EnumerateFiles(Data.Settings.GitRootDirectory, DirectoryEnumerationOptions.Files | DirectoryEnumerationOptions.Recursive, new DirectoryEnumerationFilters
{
InclusionFilter = (f) =>
{
return(f.FileName.Equals("SourceControlGenerator.json", StringComparison.OrdinalIgnoreCase));
}
}).Select(x => SourceControlData.FromPath(x));
foreach (var project in modProjects)
{
var sourceControlData = projectFiles.FirstOrDefault(x => x.ProjectUUID == project.UUID);
if (sourceControlData != null)
{
project.GitData = sourceControlData;
project.GitGenerated = true;
var gitDirectory = Path.Combine(Path.GetDirectoryName(sourceControlData.SourceFile), ".git");
if (Directory.Exists(gitDirectory))
{
var lastModifiedDate = File.GetLastWriteTime(gitDirectory);
if (lastModifiedDate != null && project.ModuleInfo.ModifiedDate.Ticks < lastModifiedDate.Ticks)
{
project.ModuleInfo.ModifiedDate = lastModifiedDate;
}
}
totalSuccess += 1;
}
}
return(totalSuccess > 0);
}
return(false);
}
public void OpenProjectReadmeInMarkdownConverter(object obj)
{
Log.Here().Activity("Opening readme...");
if (obj is IProjectData projectData)
{
var projectGitFolder = "";
if (projectData.GitData != null && !String.IsNullOrEmpty(projectData.GitData.RepositoryPath) && Directory.Exists(projectData.GitData.RepositoryPath))
{
projectGitFolder = projectData.GitData.RepositoryPath;
Log.Here().Activity($"Project has git data. Setting project git folder to '{projectGitFolder}'");
}
else
{
Log.Here().Activity($"Project does not have git data. Looking for SourceControlGenerator.json files.");
var projectFiles = Directory.EnumerateFiles(CurrentModule.ModuleData.ModuleSettings.GitRootDirectory, DirectoryEnumerationOptions.Files | DirectoryEnumerationOptions.Recursive, new DirectoryEnumerationFilters
{
InclusionFilter = (f) =>
{
return(f.FileName.Equals("SourceControlGenerator.json", StringComparison.OrdinalIgnoreCase));
}
}).Select(x => SourceControlData.FromPath(x));
//var projectGitFolder = Path.Combine(CurrentModule.ModuleData.ModuleSettings.GitRootDirectory, projectData.ProjectFolder);
var sourceFile = projectFiles.FirstOrDefault(x => x.ProjectUUID == projectData.UUID)?.SourceFile;
if (!String.IsNullOrEmpty(sourceFile))
{
projectGitFolder = Path.GetDirectoryName(sourceFile);
}
else
{
Log.Here().Activity($"Could not find SourceControlGenerator.json for project {projectData.ProjectName} with UUID {projectData.UUID}.");
}
}
if (!String.IsNullOrEmpty(projectGitFolder) && Directory.Exists(projectGitFolder))
{
var readmeFilePath = Path.Combine(projectGitFolder, "README.md");
if (File.Exists(readmeFilePath))
{
try
{
var converterData = mainWindow.MarkdownConverterWindow.ViewData;
converterData.SetBatchExportRoot(Path.Combine(DefaultPaths.ModuleExportFolder(CurrentModule.ModuleData), projectData.ProjectName));
converterData.LoadInputFile(readmeFilePath);
converterData.Mode = MarkdownConverterMode.Batch;
MenuAction_ToggleMarkdownWindow();
}
catch (Exception ex)
{
Log.Here().Error($"Error loading ({readmeFilePath}):\n{ex.ToString()}");
}
}
else
{
Log.Here().Error($"Cannot find project README.md at '{readmeFilePath}'");
}
}
else
{
Log.Here().Error($"Cannot find project git folder at '{projectGitFolder}'");
}
}
}
private async Task <bool> GenerateGitFilesAsync(DefaultProjectData modProject, GitGenerationSettings generationSettings, int endPercentage)
{
if (modProject == null)
{
return(false);
}
int percentageIncrement = endPercentage / 9;
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.UpdateProgress(percentageIncrement, "Creating git project directory...");
var rootRepoDirectory = Directory.CreateDirectory(gitProjectRootDirectory);
if (!Directory.Exists(gitProjectRootDirectory))
{
Directory.CreateDirectory(gitProjectRootDirectory);
}
if (generationSettings.InitGit)
{
AppController.Main.UpdateProgress(percentageIncrement, "Initializing git repo...");
var result = await GitGenerator.InitRepository(gitProjectRootDirectory, Data.Settings.DefaultAuthor).ConfigureAwait(false);
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.TemplateSettings != null && generationSettings.TemplateSettings.Count > 0)
{
AppController.Main.UpdateProgress(percentageIncrement, "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 = await GitGenerator.ReplaceKeywords(templateData.EditorText, modProject, MainAppData, Data).ConfigureAwait(false);
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.UpdateProgress(percentageIncrement, "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 = await GitGenerator.ReplaceKeywords(outputText, modProject, MainAppData, Data).ConfigureAwait(false);
}
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.UpdateProgress(percentageIncrement, "Committing new files...");
var result = await GitGenerator.Commit(gitProjectRootDirectory, commitMessage).ConfigureAwait(false);
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.UpdateProgress(percentageIncrement, "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.UpdateProgress(percentageIncrement);
return(true);
}
//}
//catch(Exception ex)
//{
// Log.Here().Error($"Error generating git files: {ex.ToString()}");
//}
return(false);
}
