Codebasis als Dateien ins Arbeitsrepo statt als Gitlink

QuellCode/CentronERP war nur als Gitlink (Submodul-Referenz auf 79c1142)
getrackt, ohne .gitmodules und ohne erreichbares Remote. Der
Untersuchungsgegenstand der Versuchsreihe war damit nicht reproduzierbar
gesichert: Ein Klon haette ein leeres Verzeichnis erhalten, und die Belege
der 3.287 Anforderungen waeren nicht ueberpruefbar gewesen.

Umstellung:
- Historie nach c:\DEV\CentronERP_git_snapshot_79c1142 ausgelagert
  (vollstaendig lesbar, enthaelt 79c1142 und Vorgaenger 89ccfd6)
- Gitlink aus dem Index entfernt
- Dateiinhalt aufgenommen: 24.557 Dateien, rund 333 MB

Die verschachtelte .gitignore der Codebasis gilt weiter, Build-Artefakte
bleiben ausgeschlossen. Details in Versuche/Versuch_01/_Codebasis-Nachweis.md

QuellCode/CentronERP/scripts/Scripts/CentronPaths.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+
+namespace Scripts
+{
+#pragma warning disable CA1034
+#pragma warning disable CA1819
+    public static class CentronPaths
+    {
+        public static string SolutionDirectory
+        {
+            get
+            {
+                var currentFolder = new DirectoryInfo(Path.GetDirectoryName(typeof(CentronPaths).Assembly.Location)!);
+                return currentFolder.Parent?.Parent?.Parent?.Parent?.Parent?.FullName ?? throw new InvalidOperationException("Could not determine the SolutionDirectory");
+            }
+        }
+        public static string ArtifactsDirectory => Path.Combine(SolutionDirectory, "artifacts");
+
+        public static ReadOnlyCollection<string> ProjectDirectories => new[]
+            {
+                CentronNexus.ProjectDirectory,
+                Installer.ProjectDirectory,
+                Tests.ProjectDirectory,
+            }.ToList().AsReadOnly();
+        public static ReadOnlyCollection<string> BinAndObjDirectories => new[]
+            {
+                ProjectDirectories.Select(f => Path.Combine(f, "bin")),
+                ProjectDirectories.Select(f => Path.Combine(f, "obj")),
+            }.SelectMany(f => f).ToList().AsReadOnly();
+
+        public static class CentronNexus
+        {
+            public static string TargetFramework => "net10.0";
+            public static string ProjectName => "CentronNexus.Host";
+            public static string ProjectDirectory => Path.Combine(SolutionDirectory, "src", "nexus", ProjectName);
+            public static string CsProj => Path.Combine(ProjectDirectory, $"{ProjectName}.csproj");
+            public static string PublishDirectory => Path.Combine(ProjectDirectory, "bin", "Release", TargetFramework, "win-x64", "publish");
+            public static string[] PublishedFilesToSign => new string[] {};
+            public static string ArtifactsFile => Path.Combine(ArtifactsDirectory, "CentronNexus.zip");
+
+            public static class Linux
+            {
+                public static string PublishDirectory => Path.Combine(ProjectDirectory, "bin", "Release", TargetFramework, "linux-x64", "publish");
+                public static string ArtifactsFile => Path.Combine(ArtifactsDirectory, "CentronNexusLinux.zip");
+            }
+        }
+
+        public static class Installer
+        {
+            public static string ProjectName => "WixSharpInstaller";
+            public static string ProjectDirectory => Path.Combine(SolutionDirectory, "deployment", ProjectName);
+            public static string InputDirectory => Path.Combine(ProjectDirectory, "Files");
+            public static string CsProj => Path.Combine(ProjectDirectory, $"{ProjectName}.csproj");
+            public static string PublishDirectory => Path.Combine(ProjectDirectory, "bin", "Release", "net10.0-windows");
+            public static string PublishedApplication => Path.Combine(PublishDirectory, $"{ProjectName}.exe");
+            public static string PublishedInstaller => Path.Combine(PublishDirectory, "c-entron Nexus.msi");
+            public static string ArtifactsFile => Path.Combine(ArtifactsDirectory, "c-entron Nexus Installer.zip");
+        }
+
+        public static class Tests
+        {
+            public static string TargetFramework => "net10.0";
+            public static string ProjectName => "CentronNexusTests";
+            public static string ProjectDirectory => Path.Combine(SolutionDirectory, "tests", ProjectName);
+            public static string CsProj => Path.Combine(ProjectDirectory, $"{ProjectName}.csproj");
+            public static string ArtifactsFileName => "TestResults.trx";
+        }
+    }
+#pragma warning restore CA1819
+#pragma warning restore CA1034
+}

QuellCode/CentronERP/scripts/Scripts/EnvironmentHelper.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Scripts;
+
+public static class EnvironmentHelper
+{
+    public static string? GetEnvironmentVariable(string name)
+    {
+        var targets = new[] { EnvironmentVariableTarget.Process, EnvironmentVariableTarget.User, EnvironmentVariableTarget.Machine };
+
+        foreach (var target in targets)
+        {
+            var value = Environment.GetEnvironmentVariable(name, target);
+
+            if (string.IsNullOrWhiteSpace(value) == false)
+                return value;
+        }
+
+        return null;
+    }
+}

QuellCode/CentronERP/scripts/Scripts/EnvironmentVariables.cs

@@ -0,0 +1,7 @@
+namespace Scripts;
+
+public static class EnvironmentVariables
+{
+    public static string CodeSigningCertificateCentron => "CENTRON_BUILD_CODE_SIGNING_CERTIFICATE";
+    public static string CodeSigningCertificatePasswordCentron => "CENTRON_BUILD_CODE_SIGNING_CERTIFICATE_PASSWORD";
+}

QuellCode/CentronERP/scripts/Scripts/FileHelper.cs

@@ -0,0 +1,115 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Linq;
+using System.Xml.Serialization;
+
+namespace Scripts
+{
+    public static class FileHelper
+    {
+        public static void DeleteSubDirectoriesOtherThan(string directory, params string[] allowedSubDirectories)
+        {
+            var allowedSubDirectoriesFullPaths = allowedSubDirectories.Select(f => Path.Combine(directory, f)).ToList();
+            var allSubDirectories = Directory.GetDirectories(directory);
+            foreach (var subDirectory in allSubDirectories)
+            {
+                if (allowedSubDirectoriesFullPaths.Contains(subDirectory) == false)
+                {
+                    DeleteDirectory(subDirectory);
+                }
+            }
+        }
+
+        public static void DeleteDirectory(string directory)
+        {
+            if (Directory.Exists(directory) == false)
+                return;
+
+            Directory.Delete(directory, recursive: true);
+        }
+
+        public static void MoveDirectory(string fromDirectory, string toDirectory)
+        {
+            MoveFiles(fromDirectory, toDirectory, "*.*");
+        }
+
+        public static void MoveFiles(string fromDirectory, string toDirectory, string filePattern = "*.*", SearchOption searchOption = SearchOption.AllDirectories, bool skipAlreadyExistingFiles = false)
+        {
+            MoveOrCopyFilesInternal((file, targetFile) => File.Move(file, targetFile), fromDirectory, toDirectory, filePattern, searchOption, skipAlreadyExistingFiles);
+        }
+
+        public static void CopyFiles(string fromDirectory, string toDirectory, string filePattern = "*.*", SearchOption searchOption = SearchOption.AllDirectories, bool skipAlreadyExistingFiles = false)
+        {
+            MoveOrCopyFilesInternal((file, targetFile) => File.Copy(file, targetFile), fromDirectory, toDirectory, filePattern, searchOption, skipAlreadyExistingFiles);
+        }
+
+        private static void MoveOrCopyFilesInternal(Action<string, string> action, string fromDirectory, string toDirectory, string filePattern = "*.*", SearchOption searchOption = SearchOption.AllDirectories, bool skipAlreadyExistingFiles = false)
+        {
+            if (Directory.Exists(toDirectory) == false)
+                Directory.CreateDirectory(toDirectory);
+
+            foreach (var file in Directory.GetFiles(fromDirectory, filePattern, searchOption))
+            {
+                var targetFile = file.Replace(fromDirectory, toDirectory, StringComparison.Ordinal) ?? string.Empty;
+                var targetDirectory = Path.GetDirectoryName(targetFile) ?? string.Empty;
+
+                if (Directory.Exists(targetDirectory) == false)
+                    Directory.CreateDirectory(targetDirectory);
+
+                if (skipAlreadyExistingFiles && File.Exists(targetFile))
+                    continue;
+
+                action(file, targetFile);
+            }
+        }
+
+        public static void DeleteFiles(string directory, string filePattern)
+        {
+            foreach (var file in Directory.GetFiles(directory, filePattern))
+            {
+                File.Delete(file);
+            }
+        }
+
+        public static void RenameFile(string directory, string fileName, string newFileName)
+        {
+            File.Move(Path.Combine(directory, fileName), Path.Combine(directory, newFileName));
+        }
+
+        public static void ZipDirectory(string directory, string outputFilePath)
+        {
+            if (File.Exists(outputFilePath))
+                File.Delete(outputFilePath);
+
+            var outputDirectory = Path.GetDirectoryName(outputFilePath) ?? throw new ArgumentException("Invalid output filepath.", nameof(outputFilePath));
+            if (Directory.Exists(outputDirectory) == false)
+                Directory.CreateDirectory(outputDirectory);
+
+            ZipFile.CreateFromDirectory(directory, outputFilePath);
+        }
+
+        public static void ZipSingleFile(string file, string outputFilePath)
+        {
+            var tempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(tempDirectory);
+
+            var targetFilePath = Path.Combine(tempDirectory, Path.GetFileName(file));
+
+            File.Move(file, targetFilePath);
+
+            ZipDirectory(tempDirectory, outputFilePath);
+            Directory.Delete(tempDirectory, recursive: true);
+        }
+
+        public static void ExtractZip(string archive, string directory)
+        {
+            ZipFile.ExtractToDirectory(archive, directory);
+        }
+    }
+}

QuellCode/CentronERP/scripts/Scripts/Program.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Threading.Tasks;
+using static Bullseye.Targets;
+using static Scripts.CentronPaths;
+using static Scripts.FileHelper;
+using static Scripts.RunHelper;
+using static Scripts.SignHelper;
+
+namespace Scripts
+{
+    public static class Program
+    {
+        public static async Task Main(string[] args)
+        {
+            Target("clean", () =>
+            {
+                DeleteDirectory(ArtifactsDirectory);
+                Console.WriteLine("Cleaned artifacts directory");
+
+                DeleteDirectory(Installer.InputDirectory);
+                Console.WriteLine("Cleaned installer input directory");
+
+                foreach (var directory in BinAndObjDirectories)
+                {
+                    DeleteDirectory(directory);
+                }
+                Console.WriteLine("Cleaned all bin and obj directories");
+            });
+
+            Target("test", ["clean"], () =>
+            {
+                RunDotNetTest($"\"{Tests.CsProj}\" -c Release -f {Tests.TargetFramework} --logger \"trx;LogFileName={Tests.ArtifactsFileName}\" --results-directory \"{ArtifactsDirectory}\"");
+                Console.WriteLine("Executed all tests");
+            });
+
+            Target("build", ["test"], () =>
+            {
+                RunDotNet($"publish \"{CentronNexus.CsProj}\" -r win-x64 --self-contained true -c \"Release\" -f {CentronNexus.TargetFramework}");
+                Console.WriteLine("Published the CentronNexus project");
+
+                DeleteFiles(CentronNexus.PublishDirectory, "appsettings.Development.json");
+                DeleteSubDirectoriesOtherThan(CentronNexus.PublishDirectory, "wwwroot", "de", "en-US");
+                Console.WriteLine("Deleted unneeded files");
+
+                if (SignFiles("c-entron Nexus",
+                              EnvironmentVariables.CodeSigningCertificateCentron,
+                              EnvironmentVariables.CodeSigningCertificatePasswordCentron,
+                              CentronNexus.PublishedFilesToSign))
+                {
+                    Console.WriteLine("Signed the c-entron Nexus files");
+                }
+
+                ZipDirectory(CentronNexus.PublishDirectory, CentronNexus.ArtifactsFile);
+                Console.WriteLine("Created a zip-archive of all the source-code files");
+            });
+
+            Target("build-linux", ["test"], () =>
+            {
+                RunDotNet($"publish \"{CentronNexus.CsProj}\" -r linux-x64 --self-contained false -c \"Release\" -f {CentronNexus.TargetFramework}");
+                Console.WriteLine("Published the CentronNexus project");
+
+                DeleteFiles(CentronNexus.Linux.PublishDirectory, "appsettings.Development.json");
+                DeleteSubDirectoriesOtherThan(CentronNexus.Linux.PublishDirectory, "wwwroot");
+                Console.WriteLine("Deleted unneeded files");
+
+                ZipDirectory(CentronNexus.Linux.PublishDirectory, CentronNexus.Linux.ArtifactsFile);
+                Console.WriteLine("Created a zip-archive of all the source-code files");
+            });
+
+            Target("build-installer", ["build"], () =>
+            {
+                ExtractZip(CentronNexus.ArtifactsFile, Installer.InputDirectory);
+                Console.WriteLine("Extracted the build artifacts into the installer input directory");
+
+                RunDotNet($"build \"{Installer.CsProj}\" -c \"Release\"");
+                Console.WriteLine("Built the installer project");
+
+                Run(Installer.PublishedApplication, string.Empty, Installer.PublishDirectory);
+                Console.WriteLine("Created the installer");
+
+                if (SignFiles("c-entron Nexus Installer",
+                              EnvironmentVariables.CodeSigningCertificateCentron,
+                              EnvironmentVariables.CodeSigningCertificatePasswordCentron,
+                              Installer.PublishedInstaller))
+                {
+                    Console.WriteLine("Signed the c-entron Nexus Installer");
+                }
+
+                ZipSingleFile(Installer.PublishedInstaller, Installer.ArtifactsFile);
+                Console.WriteLine("Moved the installer into the artifacts directory");
+            });
+
+            Target("build-nexus", () =>
+            {
+                RunDotNet($"publish \"{CentronNexus.CsProj}\" -r win-x64 --self-contained true -c \"Release\" -f {CentronNexus.TargetFramework}");
+                Console.WriteLine("Published the CentronNexus project");
+
+                DeleteFiles(CentronNexus.PublishDirectory, "appsettings.Development.json");
+                DeleteSubDirectoriesOtherThan(CentronNexus.PublishDirectory, "wwwroot", "de", "en-US");
+                Console.WriteLine("Deleted unneeded files");
+            });
+
+            Target("zip-nexus-directory", () =>
+            {
+                ZipDirectory(CentronNexus.PublishDirectory, CentronNexus.ArtifactsFile);
+                Console.WriteLine("Created a zip-archive of all the source-code files");
+            });
+
+            Target("build-nexus-installer", () =>
+            {
+                ExtractZip(CentronNexus.ArtifactsFile, Installer.InputDirectory);
+                Console.WriteLine("Extracted the build artifacts into the installer input directory");
+
+                RunDotNet($"build \"{Installer.CsProj}\" -c \"Release\"");
+                Console.WriteLine("Built the installer project");
+
+                Run(Installer.PublishedApplication, string.Empty, Installer.PublishDirectory);
+                Console.WriteLine($"Created the installer at '{Installer.PublishedInstaller}'");
+            });
+
+            Target("zip-nexus-singleFile", () =>
+            {
+                ZipSingleFile(Installer.PublishedInstaller, Installer.ArtifactsFile);
+                Console.WriteLine("Moved the installer into the artifacts directory");
+            });
+
+            Target("test-only", () =>
+            {
+                RunDotNetTest($"\"{Tests.CsProj}\" -c Release -f {Tests.TargetFramework} --logger \"trx;LogFileName={Tests.ArtifactsFileName}\" --results-directory \"{ArtifactsDirectory}\"");
+                Console.WriteLine("Executed all tests");
+            });
+
+            Target("default", ["build-installer"]);
+
+            await RunTargetsAndExitAsync(args);
+        }
+    }
+}

QuellCode/CentronERP/scripts/Scripts/RunHelper.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace Scripts
+{
+    public static class RunHelper
+    {
+        private static string MsBuildPath { get; } = GetMsBuildPath();
+
+        private static string GetMsBuildPath()
+        {
+            var vsWhere = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "Microsoft Visual Studio", "Installer", "vswhere.exe");
+            var path = Read(vsWhere, "-products * -requires Microsoft.Component.MSBuild -property installationPath -version 16.0 -prerelease").Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries).First();
+
+            var msbuildPath = Path.Combine(path, "MSBuild", "Current", "Bin", "MSBuild.exe");
+            if (File.Exists(msbuildPath) == false)
+                throw new FileNotFoundException("msbuild.exe not found. Is Visual Studio 2019 installed?");
+
+            return msbuildPath;
+        }
+
+        public static void RunDotNet(string arguments)
+        {
+            Run("dotnet", arguments);
+        }
+
+        public static void RunDotNetTest(string arguments)
+        {
+            try
+            {
+                Run("dotnet", "test " + arguments);
+            }
+            catch (Exception e) when (e.Data.Contains("ExitCode") && (int?)e.Data["ExitCode"] == 1)
+            {
+                //The test run failed, but we don't want to error
+                //Instead return and allow the rest of the process to read the TestResults file
+            }
+        }
+        public static void RunDotNetTool(string arguments)
+        {
+            Run("dotnet", "tool " + arguments);
+        }
+        public static void RunMsBuild(string arguments)
+        {
+            Run(MsBuildPath, arguments);
+        }
+
+        public static void RunSignTool(string certificate, string password, string timeServer, string description, params string[] files)
+        {
+            var possibleSignToolPaths = new[]
+            {
+                @"C:\Program Files (x86)\Windows Kits\8.1\bin\x86\signtool.exe",
+                @"C:\Program Files (x86)\Windows Kits\10\bin\x86\signtool.exe",
+                @"C:\Program Files (x86)\Microsoft SDKs\ClickOnce\SignTool\signtool.exe",
+            };
+
+            var signToolToUse = possibleSignToolPaths.FirstOrDefault(File.Exists) ?? throw new FileNotFoundException("signtool.exe not found");
+            var arguments = $"sign /fd sha384 /tr \"{timeServer}\" /td sha384 /d \"{description}\" {string.Join(" ", files.Select(f => "\"" + f + "\""))} ";
+
+            Run(signToolToUse, arguments);
+        }
+
+        public static void Run(string name, string args, string? workingDirectory = null)
+        {
+            Read(name, args, workingDirectory);
+        }
+
+        public static string Read(string name, string args, string? workingDirectory = null)
+        {
+            using var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = name,
+                    Arguments = args,
+                    WorkingDirectory = workingDirectory ?? string.Empty,
+                    UseShellExecute = false,
+                    RedirectStandardError = true,
+                    RedirectStandardOutput = true,
+                }
+            };
+
+            process.Start();
+
+            var output = process.StandardOutput.ReadToEnd(); //Make sure to read the output before we WaitForExit, or the process might hang forever
+            process.WaitForExit();
+
+            if (process.ExitCode != 0)
+                throw new InvalidOperationException($"The command \"{name} {args}\" failed!{Environment.NewLine}{output}")
+                {
+                    Data =
+                    {
+                        ["ExitCode"] = process.ExitCode
+                    }
+                };
+
+            return output;
+        }
+    }
+}

QuellCode/CentronERP/scripts/Scripts/Scripts.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Bullseye" Version="6.1.0" />
+  </ItemGroup>
+
+</Project>

QuellCode/CentronERP/scripts/Scripts/SignHelper.cs

@@ -0,0 +1,25 @@
+using static Scripts.EnvironmentHelper;
+using static Scripts.RunHelper;
+
+namespace Scripts;
+
+public static class SignHelper
+{
+    public static bool SignFiles(string description, string codeSigningCertificateEnvironmentVariable, string codeSigningCertificatePasswordEnvironmentVariable, params string[] files)
+    {
+        var certificateFilePath = GetEnvironmentVariable(codeSigningCertificateEnvironmentVariable);
+        var certificatePassword = GetEnvironmentVariable(codeSigningCertificatePasswordEnvironmentVariable);
+
+        if (string.IsNullOrWhiteSpace(certificateFilePath) ||
+            string.IsNullOrWhiteSpace(certificatePassword))
+        {
+            return false;
+        }
+
+        var timeServer = "http://timestamp.digicert.com";
+
+        RunSignTool(certificateFilePath, certificatePassword, timeServer, description, files);
+
+        return true;
+    }
+}