ScriptCollection 4.0.11__py3-none-any.whl → 4.0.13__py3-none-any.whl

ScriptCollection/AnionBuildPlatform.py

@@ -0,0 +1,2 @@
+class AnionBuildPlatform:
+    pass

ScriptCollection/ScriptCollectionCore.py

@@ -36,7 +36,7 @@ from .ProgramRunnerPopen import ProgramRunnerPopen
 from .ProgramRunnerEpew import ProgramRunnerEpew, CustomEpewArgument
 from .SCLog import SCLog, LogLevel
 
-version = "4.0.11"
+version = "4.0.13"
 __version__ = version
 
 

ScriptCollection/TFCPS/Docker/TFCPS_CodeUnitSpecific_Docker.py

@@ -0,0 +1,88 @@
+import os
+from ...GeneralUtilities import GeneralUtilities
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_Docker_Functions(TFCPS_CodeUnitSpecific_Base):
+
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache)
+
+
+    @GeneralUtilities.check_arguments
+    def build(self=None) -> None:
+        use_cache: bool = False
+        
+        codeunitname: str =self.get_codeunit_name()
+        codeunit_folder =self.get_codeunit_folder()
+        codeunitname_lower = codeunitname.lower()
+        codeunit_file =self.get_codeunit_file()
+        codeunitversion = self.tfcps_Tools_General.get_version_of_codeunit(codeunit_file)
+        args = ["image", "build", "--pull", "--force-rm", "--progress=plain", "--build-arg", f"TargetEnvironmentType={self.get_target_environment_type()}", "--build-arg", f"CodeUnitName={codeunitname}", "--build-arg", f"CodeUnitVersion={codeunitversion}", "--build-arg", f"CodeUnitOwnerName={self.tfcps_Tools_General.get_codeunit_owner_name(self.get_codeunit_file())}", "--build-arg", f"CodeUnitOwnerEMailAddress={self.tfcps_Tools_General.get_codeunit_owner_emailaddress(self.get_codeunit_file())}"]
+        custom_arguments:dict[str,str]={}#TODO must be setable from outside
+        if custom_arguments is not None:
+            for custom_argument_key, custom_argument_value in custom_arguments.items():
+                args.append("--build-arg")
+                args.append(f"{custom_argument_key}={custom_argument_value}")
+        args = args+["--tag", f"{codeunitname_lower}:latest", "--tag", f"{codeunitname_lower}:{codeunitversion}", "--file", f"{codeunitname}/Dockerfile"]
+        if not use_cache:
+            args.append("--no-cache")
+        args.append(".")
+        codeunit_content_folder = os.path.join(codeunit_folder)
+        self._protected_sc.run_program_argsasarray("docker", args, codeunit_content_folder, print_errors_as_information=True)
+        artifacts_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts", codeunit_folder)
+        app_artifacts_folder = os.path.join(artifacts_folder, "BuildResult_OCIImage")
+        GeneralUtilities.ensure_directory_does_not_exist(app_artifacts_folder)
+        GeneralUtilities.ensure_directory_exists(app_artifacts_folder)
+        self._protected_sc.run_program_argsasarray("docker", ["save", "--output", f"{codeunitname}_v{codeunitversion}.tar", f"{codeunitname_lower}:{codeunitversion}"], app_artifacts_folder, print_errors_as_information=True)
+        self.copy_source_files_to_output_directory()
+        self.__generate_sbom_for_docker_image()
+
+
+    @GeneralUtilities.check_arguments
+    def __generate_sbom_for_docker_image(self) -> None:
+        
+        codeunitname=self.get_codeunit_name()
+        codeunit_folder =self.get_codeunit_folder()
+        artifacts_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts", codeunit_folder)
+        codeunitname_lower = codeunitname.lower()
+        sbom_folder = os.path.join(artifacts_folder, "BOM")
+        codeunitversion = self.tfcps_Tools_General.get_version_of_codeunit(self.get_codeunit_file())
+        GeneralUtilities.ensure_directory_exists(sbom_folder)
+        self._protected_sc.run_program_argsasarray("docker", ["sbom", "--format", "cyclonedx", f"{codeunitname_lower}:{codeunitversion}", "--output", f"{codeunitname}.{codeunitversion}.sbom.xml"], sbom_folder, print_errors_as_information=True)
+        self._protected_sc.format_xml_file(sbom_folder+f"/{codeunitname}.{codeunitversion}.sbom.xml")
+ 
+    @GeneralUtilities.check_arguments
+    def linting(self=None) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def do_common_tasks(self,current_codeunit_version:str )-> None:
+        codeunitname =self.get_codeunit_name()
+        codeunit_folder = self.get_codeunit_folder()
+        codeunit_version = current_codeunit_version
+        self._protected_sc.replace_version_in_dockerfile_file(GeneralUtilities.resolve_relative_path(f"./{codeunitname}/Dockerfile", codeunit_folder), codeunit_version)
+        self.do_common_tasks_base(current_codeunit_version)
+        self.tfcps_Tools_General.standardized_tasks_update_version_in_docker_examples(codeunit_folder,codeunit_version)
+ 
+    @GeneralUtilities.check_arguments
+    def generate_reference(self=None) -> None:
+        self.generate_reference_using_docfx()
+
+    @GeneralUtilities.check_arguments
+    def update_dependencies(self=None) -> None:
+        pass#TODO
+    
+    @GeneralUtilities.check_arguments
+    def run_testcases(self=None) -> None:
+        pass#TODO
+
+class TFCPS_CodeUnitSpecific_Docker_CLI:
+
+    @staticmethod
+    def parse(file:str)->TFCPS_CodeUnitSpecific_Docker_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_Docker_Functions=TFCPS_CodeUnitSpecific_Docker_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache)
+        return result

ScriptCollection/TFCPS/DotNet/CertificateGeneratorInformationBase.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+
+class CertificateGeneratorInformationBase(ABC):
+    
+    @abstractmethod
+    def generate_certificate(self)->bool:
+        raise ValueError("Method is abstract")

ScriptCollection/TFCPS/DotNet/CertificateGeneratorInformationGenerate.py

@@ -0,0 +1,6 @@
+from .CertificateGeneratorInformationBase import CertificateGeneratorInformationBase
+
+class CertificateGeneratorInformationGenerate(CertificateGeneratorInformationBase):
+    
+    def generate_certificate(self)->bool:
+        return True

ScriptCollection/TFCPS/DotNet/CertificateGeneratorInformationNoGenerate.py

@@ -0,0 +1,7 @@
+from .CertificateGeneratorInformationBase import CertificateGeneratorInformationBase
+
+
+class CertificateGeneratorInformationNoGenerate(CertificateGeneratorInformationBase):
+    
+    def generate_certificate(self)->bool:
+        return False

ScriptCollection/TFCPS/DotNet/TFCPS_CodeUnitSpecific_DotNet.py

@@ -0,0 +1,479 @@
+import os
+import re
+import shutil
+import tempfile
+import uuid
+import json
+from lxml import etree
+import yaml
+
+from .CertificateGeneratorInformationBase import CertificateGeneratorInformationBase
+from ...GeneralUtilities import GeneralUtilities
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_DotNet_Functions(TFCPS_CodeUnitSpecific_Base):
+ 
+    is_library:bool
+    csproj_file:bool
+
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache)
+        self.csproj_file=os.path.join(self.get_codeunit_folder(), self.get_codeunit_name(), self.get_codeunit_name() + ".csproj")
+        self.is_library="<OutputType>Library</OutputType>" in GeneralUtilities.read_text_from_file(self.csproj_file)#TODO do a real check
+
+    @GeneralUtilities.check_arguments
+    def build(self,runtimes:list[str],generate_open_api_spec:bool) -> None:
+        if self.is_library:
+            self.standardized_tasks_build_for_dotnet_library_project(runtimes)
+            GeneralUtilities.assert_condition(not generate_open_api_spec,"OpenAPI-Specification can not be generated for a library.")
+        else:
+            self.standardized_tasks_build_for_dotnet_project(runtimes)
+            if generate_open_api_spec:
+                self.generate_openapi_file(runtimes[0])
+
+    @GeneralUtilities.check_arguments
+    def generate_openapi_file(self, runtime: str) -> None:
+        swagger_document_name: str = "APISpecification"
+        self._protected_sc.log.log("Generate OpenAPI-specification-file...")
+        codeunitname =self.get_codeunit_name()
+        repository_folder =self.get_repository_folder()
+        codeunit_folder = os.path.join(repository_folder, codeunitname)
+        artifacts_folder = os.path.join(codeunit_folder, "Other", "Artifacts")
+        GeneralUtilities.ensure_directory_exists(os.path.join(artifacts_folder, "APISpecification"))
+        codeunit_version = self.tfcps_Tools_General.get_version_of_codeunit(os.path.join(codeunit_folder,f"{codeunitname}.codeunit.xml"))
+
+        versioned_api_spec_file = f"APISpecification/{codeunitname}.v{codeunit_version}.api.json"
+        self._protected_sc.run_program("swagger", f"tofile --output {versioned_api_spec_file} BuildResult_DotNet_{runtime}/{codeunitname}.dll {swagger_document_name}", artifacts_folder)
+        api_file: str = os.path.join(artifacts_folder, versioned_api_spec_file)
+        shutil.copyfile(api_file, os.path.join(artifacts_folder, f"APISpecification/{codeunitname}.latest.api.json"))
+
+        resources_folder = os.path.join(codeunit_folder, "Other", "Resources")
+        GeneralUtilities.ensure_directory_exists(resources_folder)
+        resources_apispec_folder = os.path.join(resources_folder, "APISpecification")
+        GeneralUtilities.ensure_directory_exists(resources_apispec_folder)
+        resource_target_file = os.path.join(resources_apispec_folder, f"{codeunitname}.api.json")
+        GeneralUtilities.ensure_file_does_not_exist(resource_target_file)
+        shutil.copyfile(api_file, resource_target_file)
+
+        with open(api_file, encoding="utf-8") as api_file_content:
+            reloaded_json = json.load(api_file_content)
+
+            yamlfile1: str = str(os.path.join(artifacts_folder, f"APISpecification/{codeunitname}.v{codeunit_version}.api.yaml"))
+            GeneralUtilities.ensure_file_does_not_exist(yamlfile1)
+            GeneralUtilities.ensure_file_exists(yamlfile1)
+            with open(yamlfile1, "w+", encoding="utf-8") as yamlfile:
+                yaml.dump(reloaded_json, yamlfile, allow_unicode=True)
+ 
+            yamlfile2: str = str(os.path.join(artifacts_folder, f"APISpecification/{codeunitname}.latest.api.yaml"))
+            GeneralUtilities.ensure_file_does_not_exist(yamlfile2)
+            shutil.copyfile(yamlfile1, yamlfile2)
+
+            yamlfile3: str = str(os.path.join(resources_apispec_folder, f"{codeunitname}.api.yaml"))
+            GeneralUtilities.ensure_file_does_not_exist(yamlfile3)
+            shutil.copyfile(yamlfile1, yamlfile3)
+
+    @GeneralUtilities.check_arguments
+    def __standardized_tasks_build_for_dotnet_build(self, csproj_file: str, originaloutputfolder: str, files_to_sign: dict[str, str], commitid: str, runtimes: list[str],  target_environmenttype_mapping:  dict[str, str], copy_license_file_to_target_folder: bool, repository_folder: str, codeunit_name: str) -> None:
+        self._protected_sc.assert_is_git_repository(repository_folder)
+        csproj_filename = os.path.basename(csproj_file)
+        self._protected_sc.log.log(f"Build {csproj_filename}...")
+        dotnet_build_configuration: str = self.get_target_environment_type()
+        codeunit_folder = os.path.join(repository_folder, codeunit_name)
+        csproj_file_folder = os.path.dirname(csproj_file)
+        csproj_file_name = os.path.basename(csproj_file)
+        csproj_file_name_without_extension = csproj_file_name.split(".")[0]
+        sarif_folder = os.path.join(codeunit_folder, "Other", "Resources", "CodeAnalysisResult")
+        GeneralUtilities.ensure_directory_exists(sarif_folder)
+        gitkeep_file = os.path.join(sarif_folder, ".gitkeep")
+        GeneralUtilities.ensure_file_exists(gitkeep_file)
+        for runtime in runtimes:
+            outputfolder = originaloutputfolder+runtime
+            GeneralUtilities.ensure_directory_does_not_exist(os.path.join(csproj_file_folder, "obj"))
+            GeneralUtilities.ensure_directory_does_not_exist(outputfolder)
+            self._protected_sc.run_program("dotnet", "clean", csproj_file_folder)
+            GeneralUtilities.ensure_directory_exists(outputfolder)
+            self._protected_sc.run_program("dotnet", "restore", codeunit_folder)
+            self._protected_sc.run_program_argsasarray("dotnet", ["build", csproj_file_name, "-c", dotnet_build_configuration, "-o", outputfolder, "--runtime", runtime], csproj_file_folder)
+            if copy_license_file_to_target_folder:
+                license_file = os.path.join(repository_folder, "License.txt")
+                target = os.path.join(outputfolder, f"{codeunit_name}.License.txt")
+                shutil.copyfile(license_file, target)
+            if 0 < len(files_to_sign):
+                for key, value in files_to_sign.items():
+                    dll_file = key
+                    snk_file = value
+                    dll_file_full = os.path.join(outputfolder, dll_file)
+                    if os.path.isfile(dll_file_full):
+                        GeneralUtilities.assert_condition(self._protected_sc.run_program("sn", f"-vf {dll_file}", outputfolder, throw_exception_if_exitcode_is_not_zero=False)[0] == 1, f"Pre-verifying of {dll_file} failed.")
+                        self._protected_sc.run_program_argsasarray("sn", ["-R", dll_file, snk_file], outputfolder)
+                        GeneralUtilities.assert_condition(self._protected_sc.run_program("sn", f"-vf {dll_file}", outputfolder, throw_exception_if_exitcode_is_not_zero=False)[0] == 0, f"Verifying of {dll_file} failed.")
+            sarif_filename = f"{csproj_file_name_without_extension}.sarif"
+            sarif_source_file = os.path.join(sarif_folder, sarif_filename)
+            if os.path.exists(sarif_source_file):
+                sarif_folder_target = os.path.join(codeunit_folder, "Other", "Artifacts", "CodeAnalysisResult")
+                GeneralUtilities.ensure_directory_exists(sarif_folder_target)
+                sarif_target_file = os.path.join(sarif_folder_target, sarif_filename)
+                GeneralUtilities.ensure_file_does_not_exist(sarif_target_file)
+                shutil.copyfile(sarif_source_file, sarif_target_file)
+        #TODO check for updateable dependencies (in a unified way)
+
+    @GeneralUtilities.check_arguments
+    def standardized_tasks_build_for_dotnet_project(self,runtimes:list[str]) -> None:
+        self.__standardized_tasks_build_for_dotnet_project(runtimes)
+
+    @GeneralUtilities.check_arguments
+    def standardized_tasks_build_for_dotnet_library_project(self,runtimes:list[str]) -> None:
+        self.__standardized_tasks_build_for_dotnet_project( runtimes)
+        self.__standardized_tasks_build_nupkg_for_dotnet_create_package(runtimes)
+
+ 
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def get_filestosign_from_commandline_arguments( default_value: dict[str, str]) -> dict[str, str]:
+        result_plain =None# TODO TasksForCommonProjectStructure.get_property_from_commandline_arguments(commandline_arguments, "sign")
+        if result_plain is None:
+            return default_value
+        else:
+            result: dict[str, str] = dict[str, str]()
+            files_tuples = GeneralUtilities.to_list(result_plain, ";")
+            for files_tuple in files_tuples:
+                splitted = files_tuple.split("=")
+                result[splitted[0]] = splitted[1]
+            return result
+
+    @GeneralUtilities.check_arguments
+    def __standardized_tasks_build_for_dotnet_project(self,runtimes:list[str]) -> None:
+
+        target_environment_type: str=self.get_target_environment_type()
+        copy_license_file_to_target_folder: bool=True
+        codeunitname: str = self.get_codeunit_name()
+        
+        files_to_sign: dict[str, str] = self.get_filestosign_from_commandline_arguments(  dict())
+        repository_folder: str = self.get_repository_folder()
+        commitid = self._protected_sc.git_get_commit_id(repository_folder)
+        outputfolder = GeneralUtilities.resolve_relative_path("./Other/Artifacts", self.get_codeunit_folder())
+        codeunit_folder = os.path.join(repository_folder, codeunitname)
+        csproj_file = os.path.join(codeunit_folder, codeunitname, codeunitname + ".csproj")
+        csproj_test_file = os.path.join(codeunit_folder, codeunitname+"Tests", codeunitname+"Tests.csproj")
+        self.__standardized_tasks_build_for_dotnet_build(csproj_file,  os.path.join(outputfolder, "BuildResult_DotNet_"), files_to_sign, commitid, runtimes, target_environment_type,  copy_license_file_to_target_folder, repository_folder, codeunitname)
+        self.__standardized_tasks_build_for_dotnet_build(csproj_test_file,  os.path.join(outputfolder, "BuildResultTests_DotNet_"), files_to_sign, commitid, runtimes, target_environment_type,  copy_license_file_to_target_folder, repository_folder, codeunitname)
+        self.generate_sbom_for_dotnet_project(codeunit_folder)
+        self.copy_source_files_to_output_directory()
+
+    @GeneralUtilities.check_arguments
+    def __standardized_tasks_build_nupkg_for_dotnet_create_package(self,runtimes:list[str]) -> None:
+        codeunitname: str = self.get_codeunit_name()        
+        repository_folder: str =self.get_repository_folder()
+        build_folder = os.path.join(repository_folder, codeunitname, "Other", "Build")
+        outputfolder = GeneralUtilities.resolve_relative_path("./Other/Artifacts/BuildResult_NuGet",self.get_codeunit_folder())
+        root: etree._ElementTree = etree.parse(os.path.join(build_folder, f"{codeunitname}.nuspec"))
+        current_version = root.xpath("//*[name() = 'package']/*[name() = 'metadata']/*[name() = 'version']/text()")[0]
+        nupkg_filename = f"{codeunitname}.{current_version}.nupkg"
+        nupkg_file = f"{build_folder}/{nupkg_filename}"
+        GeneralUtilities.ensure_file_does_not_exist(nupkg_file)
+        commit_id = self._protected_sc.git_get_commit_id(repository_folder)
+        self._protected_sc.run_program("nuget", f"pack {codeunitname}.nuspec -Properties \"commitid={commit_id}\"", build_folder)
+        GeneralUtilities.ensure_directory_does_not_exist(outputfolder)
+        GeneralUtilities.ensure_directory_exists(outputfolder)
+        os.rename(nupkg_file, f"{outputfolder}/{nupkg_filename}")
+
+    @GeneralUtilities.check_arguments
+    def generate_sbom_for_dotnet_project(self, codeunit_folder: str) -> None:
+        self._protected_sc.log.log("Generate SBOM...")
+        codeunit_name = os.path.basename(codeunit_folder)
+        bomfile_folder = "Other\\Artifacts\\BOM"
+        self._protected_sc.run_program_argsasarray("dotnet", ["CycloneDX", f"{codeunit_name}\\{codeunit_name}.csproj", "-o", bomfile_folder, "--disable-github-licenses"], codeunit_folder)
+        codeunitversion = self.tfcps_Tools_General.get_version_of_codeunit(os.path.join(codeunit_folder, f"{codeunit_name}.codeunit.xml"))
+        target = f"{codeunit_folder}\\{bomfile_folder}\\{codeunit_name}.{codeunitversion}.sbom.xml"
+        GeneralUtilities.ensure_file_does_not_exist(target)
+        os.rename(f"{codeunit_folder}\\{bomfile_folder}\\bom.xml", target)
+        self._protected_sc.format_xml_file(target) 
+
+    @GeneralUtilities.check_arguments
+    def linting(self=None) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def do_common_tasks(self,current_codeunit_version:str,certificateGeneratorInformation:CertificateGeneratorInformationBase,run_t4:bool)-> None:
+        self.do_common_tasks_base(current_codeunit_version)
+        codeunit_name =self.get_codeunit_name()
+        codeunit_version = self.tfcps_Tools_General.get_version_of_project(self.get_repository_folder())  # Should always be the same as the project-version #TODO make this configurable from outside
+        folder_of_current_file =os.path.join(self.get_codeunit_folder(),"Other")
+        self._protected_sc.replace_version_in_csproj_file(GeneralUtilities.resolve_relative_path(f"../{codeunit_name}/{codeunit_name}.csproj", folder_of_current_file), codeunit_version)
+        self._protected_sc.replace_version_in_csproj_file(GeneralUtilities.resolve_relative_path(f"../{codeunit_name}Tests/{codeunit_name}Tests.csproj", folder_of_current_file), codeunit_version)
+        if self.is_library:
+            self._protected_sc.replace_version_in_nuspec_file(GeneralUtilities.resolve_relative_path(f"./Build/{codeunit_name}.nuspec", folder_of_current_file), codeunit_version)
+        if certificateGeneratorInformation.generate_certificate():
+            self.tfcps_Tools_General.set_constants_for_certificate_private_information(self.get_codeunit_folder())
+        if run_t4:
+            self.tfcps_Tools_General.t4_transform(self.get_codeunit_folder(),True,self.use_cache())
+        self.standardized_task_verify_standard_format_csproj_files()
+
+    @GeneralUtilities.check_arguments
+    def standardized_task_verify_standard_format_csproj_files(self) -> bool:
+        codeunit_folder=self.get_codeunit_folder()
+        repository_folder = os.path.dirname(codeunit_folder)
+        codeunit_name = os.path.basename(codeunit_folder)
+        codeunit_folder = os.path.join(repository_folder, codeunit_name)
+        codeunit_version = self.tfcps_Tools_General.get_version_of_codeunit(self.get_codeunit_file())
+
+        csproj_project_name = codeunit_name
+        csproj_file = os.path.join(codeunit_folder, csproj_project_name, csproj_project_name+".csproj")
+        result1: tuple[bool, str, list[str]] = self.__standardized_task_verify_standard_format_for_project_csproj_file(csproj_file, codeunit_folder, codeunit_name, codeunit_version)
+        if not result1[0]:
+            hints: str = "\n".join(result1[2])
+            raise ValueError(f"'{csproj_file}' with content '{GeneralUtilities.read_text_from_file(csproj_file)}' does not match the standardized .csproj-file-format which is defined by the regex '{result1[1]}'.\n{hints}")
+
+        test_csproj_project_name = csproj_project_name+"Tests"
+        test_csproj_file = os.path.join(codeunit_folder, test_csproj_project_name, test_csproj_project_name+".csproj")
+        result2: tuple[bool, str, list[str]] = self.__standardized_task_verify_standard_format_for_test_csproj_file(test_csproj_file, codeunit_name, codeunit_version)
+        if not result2[0]:
+            hints: str = "\n".join(result2[2])
+            raise ValueError(f"'{test_csproj_file}' with content '{GeneralUtilities.read_text_from_file(test_csproj_file)}' does not match the standardized .csproj-file-format which is defined by the regex '{result2[1]}'.\n{hints}")
+
+    def __standardized_task_verify_standard_format_for_project_csproj_file(self, csproj_file: str, codeunit_folder: str, codeunit_name: str, codeunit_version: str) -> tuple[bool, str, str]:
+        codeunit_name_regex = re.escape(codeunit_name)
+        codeunit_description = self.tfcps_Tools_General.get_codeunit_description(self.get_codeunit_file())
+        codeunit_version_regex = re.escape(codeunit_version)
+        codeunit_description_regex = re.escape(codeunit_description)
+        regex = f"""^<Project Sdk=\\"Microsoft\\.NET\\.Sdk\\">
+    <PropertyGroup>
+        <TargetFramework>([^<]+)<\\/TargetFramework>
+        <Authors>([^<]+)<\\/Authors>
+        <Version>{codeunit_version_regex}<\\/Version>
+        <AssemblyVersion>{codeunit_version_regex}<\\/AssemblyVersion>
+        <FileVersion>{codeunit_version_regex}<\\/FileVersion>
+        <SelfContained>false<\\/SelfContained>
+        <IsPackable>false<\\/IsPackable>
+        <PreserveCompilationContext>false<\\/PreserveCompilationContext>
+        <GenerateRuntimeConfigurationFiles>true<\\/GenerateRuntimeConfigurationFiles>
+        <Copyright>([^<]+)<\\/Copyright>
+        <Description>{codeunit_description_regex}<\\/Description>
+        <PackageProjectUrl>https:\\/\\/([^<]+)<\\/PackageProjectUrl>
+        <RepositoryUrl>https:\\/\\/([^<]+)\\.git<\\/RepositoryUrl>
+        <RootNamespace>([^<]+)\\.Core<\\/RootNamespace>
+        <ProduceReferenceAssembly>false<\\/ProduceReferenceAssembly>
+        <Nullable>(disable|enable|warnings|annotations)<\\/Nullable>
+        <Configurations>Development;QualityCheck;Productive<\\/Configurations>
+        <IsTestProject>false<\\/IsTestProject>
+        <LangVersion>([^<]+)<\\/LangVersion>
+        <PackageRequireLicenseAcceptance>true<\\/PackageRequireLicenseAcceptance>
+        <GenerateSerializationAssemblies>Off<\\/GenerateSerializationAssemblies>
+        <AppendTargetFrameworkToOutputPath>false<\\/AppendTargetFrameworkToOutputPath>
+        <OutputPath>\\.\\.\\\\Other\\\\Artifacts\\\\BuildResult_DotNet_win\\-x64<\\/OutputPath>
+        <PlatformTarget>([^<]+)<\\/PlatformTarget>
+        <WarningLevel>\\d<\\/WarningLevel>
+        <Prefer32Bit>false<\\/Prefer32Bit>
+        <SignAssembly>true<\\/SignAssembly>
+        <AssemblyOriginatorKeyFile>\\.\\.\\\\\\.\\.\\\\Other\\\\Resources\\\\PublicKeys\\\\StronglyNamedKey\\\\([^<]+)PublicKey\\.snk<\\/AssemblyOriginatorKeyFile>
+        <DelaySign>true<\\/DelaySign>
+        <NoWarn>([^<]+)<\\/NoWarn>
+        <WarningsAsErrors>([^<]+)<\\/WarningsAsErrors>
+        <ErrorLog>\\.\\.\\\\Other\\\\Resources\\\\CodeAnalysisResult\\\\{codeunit_name_regex}\\.sarif<\\/ErrorLog>
+        <OutputType>([^<]+)<\\/OutputType>
+        <DocumentationFile>\\.\\.\\\\Other\\\\Artifacts\\\\MetaInformation\\\\{codeunit_name_regex}\\.xml<\\/DocumentationFile>(\\n|.)*
+    <\\/PropertyGroup>
+    <PropertyGroup Condition=\\\"'\\$\\(Configuration\\)'=='Development'\\\">
+        <DebugType>full<\\/DebugType>
+        <DebugSymbols>true<\\/DebugSymbols>
+        <Optimize>false<\\/Optimize>
+        <DefineConstants>TRACE;DEBUG;Development<\\/DefineConstants>
+        <ErrorReport>prompt<\\/ErrorReport>
+    <\\/PropertyGroup>
+    <PropertyGroup Condition=\\\"'\\$\\(Configuration\\)'=='QualityCheck'\\\">
+        <DebugType>portable<\\/DebugType>
+        <DebugSymbols>true<\\/DebugSymbols>
+        <Optimize>false<\\/Optimize>
+        <DefineConstants>TRACE;QualityCheck<\\/DefineConstants>
+        <ErrorReport>none<\\/ErrorReport>
+    <\\/PropertyGroup>
+    <PropertyGroup Condition=\\\"'\\$\\(Configuration\\)'=='Productive'\\\">
+        <DebugType>none<\\/DebugType>
+        <DebugSymbols>false<\\/DebugSymbols>
+        <Optimize>true<\\/Optimize>
+        <DefineConstants>Productive<\\/DefineConstants>
+        <ErrorReport>none<\\/ErrorReport>
+    <\\/PropertyGroup>(\\n|.)*
+<\\/Project>$"""
+        result = self.__standardized_task_verify_standard_format_for_csproj_files(regex, csproj_file)
+        return (result[0], regex, result[1])
+
+    def __standardized_task_verify_standard_format_for_test_csproj_file(self, csproj_file: str, codeunit_name: str, codeunit_version: str) -> tuple[bool, str, str]:
+        codeunit_name_regex = re.escape(codeunit_name)
+        codeunit_version_regex = re.escape(codeunit_version)
+        regex = f"""^<Project Sdk=\\"Microsoft\\.NET\\.Sdk\\">
+    <PropertyGroup>
+        <TargetFramework>([^<]+)<\\/TargetFramework>
+        <Authors>([^<]+)<\\/Authors>
+        <Version>{codeunit_version_regex}<\\/Version>
+        <AssemblyVersion>{codeunit_version_regex}<\\/AssemblyVersion>
+        <FileVersion>{codeunit_version_regex}<\\/FileVersion>
+        <SelfContained>false<\\/SelfContained>
+        <IsPackable>false<\\/IsPackable>
+        <PreserveCompilationContext>false<\\/PreserveCompilationContext>
+        <GenerateRuntimeConfigurationFiles>true<\\/GenerateRuntimeConfigurationFiles>
+        <Copyright>([^<]+)<\\/Copyright>
+        <Description>{codeunit_name_regex}Tests is the test-project for {codeunit_name_regex}\\.<\\/Description>
+        <PackageProjectUrl>https:\\/\\/([^<]+)<\\/PackageProjectUrl>
+        <RepositoryUrl>https:\\/\\/([^<]+)\\.git</RepositoryUrl>
+        <RootNamespace>([^<]+)\\.Tests<\\/RootNamespace>
+        <ProduceReferenceAssembly>false<\\/ProduceReferenceAssembly>
+        <Nullable>(disable|enable|warnings|annotations)<\\/Nullable>
+        <Configurations>Development;QualityCheck;Productive<\\/Configurations>
+        <IsTestProject>true<\\/IsTestProject>
+        <LangVersion>([^<]+)<\\/LangVersion>
+        <PackageRequireLicenseAcceptance>true<\\/PackageRequireLicenseAcceptance>
+        <GenerateSerializationAssemblies>Off<\\/GenerateSerializationAssemblies>
+        <AppendTargetFrameworkToOutputPath>false<\\/AppendTargetFrameworkToOutputPath>
+        <OutputPath>\\.\\.\\\\Other\\\\Artifacts\\\\BuildResultTests_DotNet_win\\-x64<\\/OutputPath>
+        <PlatformTarget>([^<]+)<\\/PlatformTarget>
+        <WarningLevel>\\d<\\/WarningLevel>
+        <Prefer32Bit>false<\\/Prefer32Bit>
+        <SignAssembly>true<\\/SignAssembly>
+        <AssemblyOriginatorKeyFile>\\.\\.\\\\\\.\\.\\\\Other\\\\Resources\\\\PublicKeys\\\\StronglyNamedKey\\\\([^<]+)PublicKey\\.snk<\\/AssemblyOriginatorKeyFile>
+        <DelaySign>true<\\/DelaySign>
+        <NoWarn>([^<]+)<\\/NoWarn>
+        <WarningsAsErrors>([^<]+)<\\/WarningsAsErrors>
+        <ErrorLog>\\.\\.\\\\Other\\\\Resources\\\\CodeAnalysisResult\\\\{codeunit_name_regex}Tests\\.sarif<\\/ErrorLog>
+        <OutputType>Library<\\/OutputType>(\\n|.)*
+    <\\/PropertyGroup>
+    <PropertyGroup Condition=\\\"'\\$\\(Configuration\\)'=='Development'\\\">
+        <DebugType>full<\\/DebugType>
+        <DebugSymbols>true<\\/DebugSymbols>
+        <Optimize>false<\\/Optimize>
+        <DefineConstants>TRACE;DEBUG;Development<\\/DefineConstants>
+        <ErrorReport>prompt<\\/ErrorReport>
+    <\\/PropertyGroup>
+    <PropertyGroup Condition=\\\"'\\$\\(Configuration\\)'=='QualityCheck'\\\">
+        <DebugType>portable<\\/DebugType>
+        <DebugSymbols>true<\\/DebugSymbols>
+        <Optimize>false<\\/Optimize>
+        <DefineConstants>TRACE;QualityCheck<\\/DefineConstants>
+        <ErrorReport>none<\\/ErrorReport>
+    <\\/PropertyGroup>
+    <PropertyGroup Condition=\\\"'\\$\\(Configuration\\)'=='Productive'\\\">
+        <DebugType>none<\\/DebugType>
+        <DebugSymbols>false<\\/DebugSymbols>
+        <Optimize>true<\\/Optimize>
+        <DefineConstants>Productive<\\/DefineConstants>
+        <ErrorReport>none<\\/ErrorReport>
+    <\\/PropertyGroup>(\\n|.)*
+<\\/Project>$"""
+        result = self.__standardized_task_verify_standard_format_for_csproj_files(regex, csproj_file)
+        return (result[0], regex, result[1])
+
+    def __standardized_task_verify_standard_format_for_csproj_files(self, regex: str, csproj_file: str) -> tuple[bool, list[str]]:
+        filename = os.path.basename(csproj_file)
+        self._protected_sc.log.log(f"Check {filename}...",LogLevel.Debug)
+        file_content = GeneralUtilities.read_text_from_file(csproj_file)
+        regex_for_check = regex.replace("\r", GeneralUtilities.empty_string).replace("\n", "\\n")
+        file_content = file_content.replace("\r", GeneralUtilities.empty_string)
+        match = re.match(regex_for_check, file_content)
+        result = match is not None
+        hints = None
+        if not result:
+            hints = self.get_hints_for_csproj(regex, file_content)
+        return (result, hints)
+
+    @GeneralUtilities.check_arguments
+    def get_hints_for_csproj(self, regex: str, file_content: str) -> list[str]:
+        result: list[str] = []
+        regex_lines = GeneralUtilities.string_to_lines(regex)
+        file_content_lines = GeneralUtilities.string_to_lines(file_content)
+        #amount_of_regexes = len(regex_lines)
+        amount_of_lines = len(file_content_lines)
+        if amount_of_lines< len(regex_lines):
+            result.append("csproj-file has less lines than the regex requires.")
+            return result
+        for i in range(35):
+            s = file_content_lines[i]
+            r = regex_lines[i]
+            if not re.match(r, s):
+                result.append(f"Line {i+1} does not match: Regex='{r}' String='{s}'")
+        return result
+
+    @GeneralUtilities.check_arguments
+    def generate_reference(self) -> None:
+        self.generate_reference_using_docfx()
+
+    @GeneralUtilities.check_arguments
+    def update_dependencies(self) -> None:
+        self.update_year_for_dotnet_codeunit()
+        #TODO
+    
+    @GeneralUtilities.check_arguments
+    def update_year_for_dotnet_codeunit(self) -> None:
+        codeunit_folder:str=self.get_codeunit_folder()
+        codeunit_name = os.path.basename(codeunit_folder)
+        csproj_file = os.path.join(codeunit_folder, codeunit_name, f"{codeunit_name}.csproj")
+        self._protected_sc.update_year_in_copyright_tags(csproj_file)
+        csprojtests_file = os.path.join(codeunit_folder, f"{codeunit_name}Tests", f"{codeunit_name}Tests.csproj")
+        self._protected_sc.update_year_in_copyright_tags(csprojtests_file)
+        nuspec_file = os.path.join(codeunit_folder, "Other", "Build", f"{codeunit_name}.nuspec")
+        if os.path.isfile(nuspec_file):
+            self._protected_sc.update_year_in_copyright_tags(nuspec_file)
+ 
+    @GeneralUtilities.check_arguments
+    def run_testcases(self) -> None:
+        self._protected_sc.log.log("Run testcases...")
+        dotnet_build_configuration: str = self.get_target_environment_type()
+        codeunit_name: str = self.get_codeunit_name()
+        
+        repository_folder: str = self.get_repository_folder().replace("\\", "/")
+        coverage_file_folder = os.path.join(repository_folder, codeunit_name, "Other/Artifacts/TestCoverage")
+        temp_folder = os.path.join(tempfile.gettempdir(), str(uuid.uuid4()))
+        GeneralUtilities.ensure_directory_exists(temp_folder)
+        runsettings_file = "runsettings.xml"
+        codeunit_folder = f"{repository_folder}/{codeunit_name}"
+        arg = f"test . -c {dotnet_build_configuration} -o {temp_folder}"
+        if os.path.isfile(os.path.join(codeunit_folder, runsettings_file)):
+            arg = f"{arg} --settings {runsettings_file}"
+        arg = f"{arg} /p:CollectCoverage=true /p:CoverletOutput=../Other/Artifacts/TestCoverage/Testcoverage /p:CoverletOutputFormat=cobertura"
+        self._protected_sc.run_program("dotnet", arg, codeunit_folder, print_live_output=True)
+        target_file = os.path.join(coverage_file_folder,  "TestCoverage.xml")
+        GeneralUtilities.ensure_file_does_not_exist(target_file)
+        os.rename(os.path.join(coverage_file_folder,  "Testcoverage.cobertura.xml"), target_file)
+        self.__remove_unrelated_package_from_testcoverage_file(target_file, codeunit_name)
+        root: etree._ElementTree = etree.parse(target_file)
+        source_base_path_in_coverage_file: str = root.xpath("//coverage/sources/source/text()")[0].replace("\\", "/")
+        content = GeneralUtilities.read_text_from_file(target_file)
+        GeneralUtilities.assert_condition(source_base_path_in_coverage_file.startswith(repository_folder) or repository_folder.startswith(source_base_path_in_coverage_file), f"Unexpected path for coverage. Sourcepath: \"{source_base_path_in_coverage_file}\"; repository: \"{repository_folder}\"")
+        content = re.sub('\\\\', '/', content)
+        content = re.sub("filename=\"([^\"]+)\"", lambda match: self.__standardized_tasks_run_testcases_for_dotnet_project_helper(source_base_path_in_coverage_file, codeunit_folder, match), content)
+        GeneralUtilities.write_text_to_file(target_file, content)
+        self.run_testcases_common_post_task(repository_folder, codeunit_name, True, self.get_target_environment_type())
+        artifacts_folder = os.path.join(repository_folder, codeunit_name, "Other", "Artifacts")
+        for subfolder in GeneralUtilities.get_direct_folders_of_folder(artifacts_folder):
+            if os.path.basename(subfolder).startswith("BuildResultTests_DotNet_"):
+                GeneralUtilities.ensure_directory_does_not_exist(subfolder)
+
+
+    @GeneralUtilities.check_arguments
+    def __remove_unrelated_package_from_testcoverage_file(self, file: str, codeunit_name: str) -> None:
+        root: etree._ElementTree = etree.parse(file)
+        packages = root.xpath('//coverage/packages/package')
+        for package in packages:
+            if package.attrib['name'] != codeunit_name:
+                package.getparent().remove(package)
+        result = etree.tostring(root).decode("utf-8")
+        GeneralUtilities.write_text_to_file(file, result)
+
+    @GeneralUtilities.check_arguments
+    def __standardized_tasks_run_testcases_for_dotnet_project_helper(self, source: str, codeunit_folder: str, match: re.Match) -> str:
+        filename = match.group(1)
+        file = os.path.join(source, filename)
+        GeneralUtilities.assert_condition(file.startswith(codeunit_folder), f"Unexpected path for coverage-file. File: \"{file}\"; codeunitfolder: \"{codeunit_folder}\"")
+        filename_relative = f".{file[len(codeunit_folder):]}"
+        return f'filename="{filename_relative}"'
+
+
+class TFCPS_CodeUnitSpecific_DotNet_CLI:
+
+    @staticmethod
+    def parse(file:str)->TFCPS_CodeUnitSpecific_DotNet_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_DotNet_Functions=TFCPS_CodeUnitSpecific_DotNet_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache)
+        return result