ScriptCollection 3.5.47__py3-none-any.whl → 3.5.49__py3-none-any.whl

ScriptCollection/GeneralUtilities.py

@@ -890,11 +890,17 @@ class GeneralUtilities:
             GeneralUtilities.write_message_to_stdout(f"Result: {result}")
         return result
 
+    @staticmethod
+    @check_arguments
+    def is_git_repository(folder: str) -> bool:
+        combined = os.path.join(folder, ".git")
+        # TODO consider check for bare-repositories
+        return os.path.isdir(combined) or os.path.isfile(combined)
+
     @staticmethod
     @check_arguments
     def assert_is_git_repository(folder: str) -> str:
-        git_file_or_folder = os.path.join(folder, ".git")
-        GeneralUtilities.assert_condition(os.path.isdir(git_file_or_folder) or os.path.isfile(git_file_or_folder), f"'{folder}' is not a git-repository.")
+        GeneralUtilities.assert_condition(GeneralUtilities.is_git_repository(folder), f"'{folder}' is not a git-repository.")
 
     @staticmethod
     @check_arguments

ScriptCollection/ScriptCollectionCore.py

@@ -31,7 +31,7 @@ from .ProgramRunnerBase import ProgramRunnerBase
 from .ProgramRunnerPopen import ProgramRunnerPopen
 from .ProgramRunnerEpew import ProgramRunnerEpew, CustomEpewArgument
 
-version = "3.5.47"
+version = "3.5.49"
 __version__ = version
 
 
@@ -117,38 +117,38 @@ class ScriptCollectionCore:
         self.run_program("dotnet", f"nuget push {nupkg_file_name} --force-english-output --source {registry_address} --api-key {api_key}", nupkg_file_folder, verbosity)
 
     @GeneralUtilities.check_arguments
-    def dotnet_build(self, repository_folder: str, projectname: str, configuration: str):
-        self.run_program("dotnet", f"clean -c {configuration}", repository_folder)
-        self.run_program("dotnet", f"build {projectname}/{projectname}.csproj -c {configuration}", repository_folder)
+    def dotnet_build(self, folder: str, projectname: str, configuration: str):
+        self.run_program("dotnet", f"clean -c {configuration}", folder)
+        self.run_program("dotnet", f"build {projectname}/{projectname}.csproj -c {configuration}", folder)
 
     @GeneralUtilities.check_arguments
-    def find_file_by_extension(self, folder: str, extension: str):
-        result = [file for file in GeneralUtilities.get_direct_files_of_folder(folder) if file.endswith(f".{extension}")]
+    def find_file_by_extension(self, folder: str, extension_without_dot: str):
+        result = [file for file in GeneralUtilities.get_direct_files_of_folder(folder) if file.endswith(f".{extension_without_dot}")]
         result_length = len(result)
         if result_length == 0:
-            raise FileNotFoundError(f"No file available in folder '{folder}' with extension '{extension}'.")
+            raise FileNotFoundError(f"No file available in folder '{folder}' with extension '{extension_without_dot}'.")
         if result_length == 1:
             return result[0]
         else:
-            raise ValueError(f"Multiple values available in folder '{folder}' with extension '{extension}'.")
+            raise ValueError(f"Multiple values available in folder '{folder}' with extension '{extension_without_dot}'.")
 
     @GeneralUtilities.check_arguments
-    def find_latest_file_by_extension(self, folder: str, extension: str) -> str:
+    def find_last_file_by_extension(self, folder: str, extension_without_dot: str) -> str:
         files: list[str] = GeneralUtilities.get_direct_files_of_folder(folder)
         possible_results: list[str] = []
         for file in files:
-            if file.endswith(f".{extension}"):
+            if file.endswith(f".{extension_without_dot}"):
                 possible_results.append(file)
         result_length = len(possible_results)
         if result_length == 0:
-            raise FileNotFoundError(f"No file available in folder '{folder}' with extension '{extension}'.")
+            raise FileNotFoundError(f"No file available in folder '{folder}' with extension '{extension_without_dot}'.")
         else:
             return possible_results[-1]
 
     @GeneralUtilities.check_arguments
     def commit_is_signed_by_key(self, repository_folder: str, revision_identifier: str, key: str) -> bool:
-        result = self.run_program(
-            "git", f"verify-commit {revision_identifier}", repository_folder, throw_exception_if_exitcode_is_not_zero=False)
+        GeneralUtilities.assert_is_git_repository(repository_folder)
+        result = self.run_program("git", f"verify-commit {revision_identifier}", repository_folder, throw_exception_if_exitcode_is_not_zero=False)
         if (result[0] != 0):
             return False
         if (not GeneralUtilities.contains_line(result[1].splitlines(), f"gpg\\:\\ using\\ [A-Za-z0-9]+\\ key\\ [A-Za-z0-9]+{key}")):
@@ -161,10 +161,12 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_parent_commit_ids_of_commit(self, repository_folder: str, commit_id: str) -> str:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         return self.run_program("git", f'log --pretty=%P -n 1 "{commit_id}"', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].replace("\r", "").replace("\n", "").split(" ")
 
     @GeneralUtilities.check_arguments
     def get_all_authors_and_committers_of_repository(self, repository_folder: str, subfolder: str = None, verbosity: int = 1) -> list[tuple[str, str]]:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         space_character = "_"
         if subfolder is None:
             subfolder_argument = ""
@@ -184,6 +186,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_commit_ids_between_dates(self, repository_folder: str, since: datetime, until: datetime, ignore_commits_which_are_not_in_history_of_head: bool = True) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         since_as_string = self.__datetime_to_string_for_git(since)
         until_as_string = self.__datetime_to_string_for_git(until)
         result = filter(lambda line: not GeneralUtilities.string_is_none_or_whitespace(line), self.run_program("git", f'log --since "{since_as_string}" --until "{until_as_string}" --pretty=format:"%H" --no-patch', repository_folder, throw_exception_if_exitcode_is_not_zero=True)[1].split("\n").replace("\r", ""))
@@ -198,6 +201,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_commit_is_ancestor(self, repository_folder: str,  ancestor: str, descendant: str = "HEAD") -> bool:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         result = self.run_program_argsasarray("git", ["merge-base", "--is-ancestor", ancestor, descendant], repository_folder, throw_exception_if_exitcode_is_not_zero=False)
         exit_code = result[0]
         if exit_code == 0:
@@ -209,6 +213,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def __git_changes_helper(self, repository_folder: str, arguments_as_array: list[str]) -> bool:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         lines = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", arguments_as_array, repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
         for line in lines:
             if GeneralUtilities.string_has_content(line):
@@ -216,27 +221,32 @@ class ScriptCollectionCore:
         return False
 
     @GeneralUtilities.check_arguments
-    def git_repository_has_new_untracked_files(self, repositoryFolder: str):
-        return self.__git_changes_helper(repositoryFolder, ["ls-files", "--exclude-standard", "--others"])
+    def git_repository_has_new_untracked_files(self, repository_folder: str):
+        GeneralUtilities.assert_is_git_repository(repository_folder)
+        return self.__git_changes_helper(repository_folder, ["ls-files", "--exclude-standard", "--others"])
 
     @GeneralUtilities.check_arguments
-    def git_repository_has_unstaged_changes_of_tracked_files(self, repositoryFolder: str):
-        return self.__git_changes_helper(repositoryFolder, ["--no-pager", "diff"])
+    def git_repository_has_unstaged_changes_of_tracked_files(self, repository_folder: str):
+        GeneralUtilities.assert_is_git_repository(repository_folder)
+        return self.__git_changes_helper(repository_folder, ["--no-pager", "diff"])
 
     @GeneralUtilities.check_arguments
-    def git_repository_has_staged_changes(self, repositoryFolder: str):
-        return self.__git_changes_helper(repositoryFolder, ["--no-pager", "diff", "--cached"])
+    def git_repository_has_staged_changes(self, repository_folder: str):
+        GeneralUtilities.assert_is_git_repository(repository_folder)
+        return self.__git_changes_helper(repository_folder, ["--no-pager", "diff", "--cached"])
 
     @GeneralUtilities.check_arguments
-    def git_repository_has_uncommitted_changes(self, repositoryFolder: str) -> bool:
-        if (self.git_repository_has_unstaged_changes(repositoryFolder)):
+    def git_repository_has_uncommitted_changes(self, repository_folder: str) -> bool:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
+        if (self.git_repository_has_unstaged_changes(repository_folder)):
             return True
-        if (self.git_repository_has_staged_changes(repositoryFolder)):
+        if (self.git_repository_has_staged_changes(repository_folder)):
             return True
         return False
 
     @GeneralUtilities.check_arguments
     def git_repository_has_unstaged_changes(self, repository_folder: str) -> bool:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         if (self.git_repository_has_unstaged_changes_of_tracked_files(repository_folder)):
             return True
         if (self.git_repository_has_new_untracked_files(repository_folder)):
@@ -245,11 +255,13 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_get_commit_id(self, repository_folder: str, commit: str = "HEAD") -> str:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         result: tuple[int, str, str, int] = self.run_program_argsasarray("git", ["rev-parse", "--verify", commit], repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
         return result[1].replace('\n', '')
 
     @GeneralUtilities.check_arguments
     def git_get_commit_date(self, repository_folder: str, commit: str = "HEAD") -> datetime:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         result: tuple[int, str, str, int] = self.run_program_argsasarray("git", ["show", "-s", "--format=%ci", commit], repository_folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
         date_as_string = result[1].replace('\n', '')
         result = datetime.strptime(date_as_string, '%Y-%m-%d %H:%M:%S %z')
@@ -448,7 +460,7 @@ class ScriptCollectionCore:
     def git_fetch_or_clone_all_in_directory(self, source_directory: str, target_directory: str) -> None:
         for subfolder in GeneralUtilities.get_direct_folders_of_folder(source_directory):
             foldername = os.path.basename(subfolder)
-            if self.is_git_repository(subfolder):
+            if GeneralUtilities.is_git_repository(subfolder):
                 source_repository = subfolder
                 target_repository = os.path.join(target_directory, foldername)
                 if os.path.isdir(target_directory):
@@ -465,12 +477,6 @@ class ScriptCollectionCore:
             result.append(submodule_line.split(' ')[1])
         return result
 
-    @GeneralUtilities.check_arguments
-    def is_git_repository(self, folder: str) -> bool:
-        combined = os.path.join(folder, ".git")
-        # TODO consider check for bare-repositories
-        return os.path.isdir(combined) or os.path.isfile(combined)
-
     @GeneralUtilities.check_arguments
     def file_is_git_ignored(self, file_in_repository: str, repositorybasefolder: str) -> None:
         exit_code = self.run_program_argsasarray("git", ['check-ignore', file_in_repository], repositorybasefolder, throw_exception_if_exitcode_is_not_zero=False, verbosity=0)[0]
@@ -524,25 +530,28 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_current_git_branch_has_tag(self, repository_folder: str) -> bool:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         result = self.run_program_argsasarray("git", ["describe", "--tags", "--abbrev=0"], repository_folder, verbosity=0, throw_exception_if_exitcode_is_not_zero=False)
         return result[0] == 0
 
     @GeneralUtilities.check_arguments
     def get_latest_git_tag(self, repository_folder: str) -> str:
-        result = self.run_program_argsasarray(
-            "git", ["describe", "--tags", "--abbrev=0"], repository_folder, verbosity=0)
+        GeneralUtilities.assert_is_git_repository(repository_folder)
+        result = self.run_program_argsasarray("git", ["describe", "--tags", "--abbrev=0"], repository_folder, verbosity=0)
         result = result[1].replace("\r", "").replace("\n", "")
         return result
 
     @GeneralUtilities.check_arguments
     def get_staged_or_committed_git_ignored_files(self, repository_folder: str) -> list[str]:
-        tresult = self.run_program_argsasarray("git", ["ls-files", "-i", "-c", "--exclude-standard"], repository_folder, verbosity=0)
-        tresult = tresult[1].replace("\r", "")
-        result = [line for line in tresult.split("\n") if len(line) > 0]
+        GeneralUtilities.assert_is_git_repository(repository_folder)
+        temp_result = self.run_program_argsasarray("git", ["ls-files", "-i", "-c", "--exclude-standard"], repository_folder, verbosity=0)
+        temp_result = temp_result[1].replace("\r", "")
+        result = [line for line in temp_result.split("\n") if len(line) > 0]
         return result
 
     @GeneralUtilities.check_arguments
     def git_repository_has_commits(self, repository_folder: str) -> bool:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         return self.run_program_argsasarray("git", ["rev-parse", "--verify", "HEAD"], repository_folder, throw_exception_if_exitcode_is_not_zero=False)[0] == 0
 
     @GeneralUtilities.check_arguments
@@ -1107,6 +1116,7 @@ class ScriptCollectionCore:
         return tor_version
 
     def run_testcases_for_python_project(self, repository_folder: str):
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         self.run_program("coverage", "run -m pytest", repository_folder)
         self.run_program("coverage", "xml", repository_folder)
         GeneralUtilities.ensure_directory_exists(os.path.join(repository_folder, "Other/TestCoverage"))
@@ -1398,10 +1408,17 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def __adapt_workingdirectory(self, workingdirectory: str) -> str:
+        result: str = None
         if workingdirectory is None:
-            return os.getcwd()
+            result = os.getcwd()
         else:
-            return GeneralUtilities.resolve_relative_path_from_current_working_directory(workingdirectory)
+            if os.path.isabs(workingdirectory):
+                result = workingdirectory
+            else:
+                result = GeneralUtilities.resolve_relative_path_from_current_working_directory(workingdirectory)
+        if not os.path.isdir(result):
+            raise ValueError(f"Working-directory '{workingdirectory}' does not exist.")
+        return result
 
     @GeneralUtilities.check_arguments
     def verify_no_pending_mock_program_calls(self):
@@ -1513,6 +1530,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def get_semver_version_from_gitversion(self, repository_folder: str) -> str:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         if (self.git_repository_has_commits(repository_folder)):
             result = self.get_version_from_gitversion(repository_folder, "MajorMinorPatch")
             if self.git_repository_has_uncommitted_changes(repository_folder):
@@ -1928,3 +1946,37 @@ TXDX
             return True
         else:
             return False
+
+    @GeneralUtilities.check_arguments
+    def ensure_local_docker_network_exists(self, network_name: str) -> None:
+        if not self.local_docker_network_exists(network_name):
+            self.create_local_docker_network(network_name)
+
+    @GeneralUtilities.check_arguments
+    def ensure_local_docker_network_does_not_exist(self, network_name: str) -> None:
+        if self.local_docker_network_exists(network_name):
+            self.remove_local_docker_network(network_name)
+
+    @GeneralUtilities.check_arguments
+    def local_docker_network_exists(self, network_name: str) -> bool:
+        return network_name in self.get_all_local_existing_docker_networks()
+
+    @GeneralUtilities.check_arguments
+    def get_all_local_existing_docker_networks(self) -> list[str]:
+        program_call_result = self.run_program("docker", "network list")
+        std_out = program_call_result[1]
+        std_out_lines = std_out.split("\n")[1:]
+        result: list[str] = []
+        for std_out_line in std_out_lines:
+            normalized_line = ';'.join(std_out_line.split())
+            splitted = normalized_line.split(";")
+            result.append(splitted[1])
+        return result
+
+    @GeneralUtilities.check_arguments
+    def remove_local_docker_network(self, network_name: str) -> None:
+        self.run_program("docker", f"network remove {network_name}")
+
+    @GeneralUtilities.check_arguments
+    def create_local_docker_network(self, network_name: str) -> None:
+        self.run_program("docker", f"network create {network_name}")

ScriptCollection/TasksForCommonProjectStructure.py

@@ -39,6 +39,7 @@ class CreateReleaseConfiguration():
 
     def __init__(self, projectname: str, remotename: str, build_artifacts_target_folder: str, push_artifacts_scripts_folder: str, verbosity: int, repository_folder: str, additional_arguments_file: str, repository_folder_name: str):
 
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         self.__sc = ScriptCollectionCore()
         self.projectname = projectname
         self.remotename = remotename
@@ -112,6 +113,17 @@ class TasksForCommonProjectStructure:
     validate_developers_of_repository: bool = True
     dotnet_runsettings_file = "runsettings.xml"
 
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def assert_is_codeunit_folder(codeunit_folder: str) -> str:
+        repo_folder = GeneralUtilities.resolve_relative_path("..", codeunit_folder)
+        if not GeneralUtilities.is_git_repository(repo_folder):
+            raise ValueError(f"'{codeunit_folder}' can not be a valid codeunit-folder because '{repo_folder}' is not a git-repository.")
+        codeunit_name = os.path.basename(codeunit_folder)
+        codeunit_file: str = os.path.join(codeunit_folder, f"{codeunit_name}.codeunit.xml")
+        if not os.path.isfile(codeunit_file):
+            raise ValueError(f"'{codeunit_folder}' is no codeunit-folder because '{codeunit_file}' does not exist.")
+
     @staticmethod
     @GeneralUtilities.check_arguments
     def get_development_environment_name() -> str:
@@ -134,14 +146,17 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_build_folder(self, repository_folder: str, codeunit_name: str) -> str:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         return os.path.join(repository_folder, codeunit_name, "Other", "Build")
 
     @GeneralUtilities.check_arguments
     def get_artifacts_folder(self, repository_folder: str, codeunit_name: str) -> str:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         return os.path.join(repository_folder, codeunit_name, "Other", "Artifacts")
 
     @GeneralUtilities.check_arguments
     def get_wheel_file(self, repository_folder: str, codeunit_name: str) -> str:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         return self.__sc.find_file_by_extension(os.path.join(self.get_artifacts_folder(repository_folder, codeunit_name), "BuildResult_Wheel"), "whl")
 
     @GeneralUtilities.check_arguments
@@ -171,6 +186,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def check_testcoverage(self, testcoverage_file_in_cobertura_format: str, repository_folder: str, codeunitname: str) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         GeneralUtilities.write_message_to_stdout("Check testcoverage..")
         root: etree._ElementTree = etree.parse(testcoverage_file_in_cobertura_format)
         if len(root.xpath('//coverage/packages/package')) != 1:
@@ -292,6 +308,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def generate_bom_for_python_project(self, verbosity: int, codeunit_folder: str, codeunitname: str, commandline_arguments: list[str]) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         verbosity = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(commandline_arguments,  verbosity)
         codeunitversion = self.get_version_of_codeunit_folder(codeunit_folder)
         bom_folder = "Other/Artifacts/BOM"
@@ -338,8 +355,7 @@ class TasksForCommonProjectStructure:
     @GeneralUtilities.check_arguments
     def get_version_of_codeunit_file_content(self, codeunit_file_content: str) -> str:
         root: etree._ElementTree = etree.fromstring(codeunit_file_content.encode("utf-8"))
-        result = str(root.xpath('//cps:version/text()',
-                     namespaces={'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure'})[0])
+        result = str(root.xpath('//cps:version/text()',  namespaces={'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure'})[0])
         return result
 
     @GeneralUtilities.check_arguments
@@ -348,6 +364,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_version_of_codeunit_folder(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_file = os.path.join(codeunit_folder, f"{os.path.basename(codeunit_folder)}.codeunit.xml")
         return self.get_version_of_codeunit(codeunit_file)
 
@@ -469,6 +486,7 @@ class TasksForCommonProjectStructure:
         GeneralUtilities.ensure_directory_does_not_exist(obj_folder)
 
     def standardized_task_verify_standard_format_csproj_files(self, codeunit_folder: str) -> bool:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(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)
@@ -488,6 +506,7 @@ class TasksForCommonProjectStructure:
             raise ValueError(test_csproj_file+message+f'"{result2[1]}".')
 
     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]:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name_regex = re.escape(codeunit_name)
         codeunit_file = os.path.join(codeunit_folder, f"{codeunit_name}.codeunit.xml")
         codeunit_description = self.get_codeunit_description(codeunit_file)
@@ -628,6 +647,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def __standardized_tasks_build_for_dotnet_build(self, csproj_file: str, originaloutputfolder: str, files_to_sign: dict[str, str], commitid: str, verbosity: int, runtimes: list[str], target_environmenttype: str, target_environmenttype_mapping:  dict[str, str], copy_license_file_to_target_folder: bool, repository_folder: str, codeunit_name: str, commandline_arguments: list[str]) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         csproj_filename = os.path.basename(csproj_file)
         GeneralUtilities.write_message_to_stdout(f"Build {csproj_filename}...")
         dotnet_build_configuration: str = target_environmenttype_mapping[target_environmenttype]
@@ -676,8 +696,7 @@ class TasksForCommonProjectStructure:
         # this function builds an exe
         target_environmenttype = self.get_targetenvironmenttype_from_commandline_arguments(commandline_arguments, default_target_environmenttype)
         self.__standardized_tasks_build_for_dotnet_project(
-            buildscript_file, target_environmenttype_mapping, default_target_environmenttype, verbosity, target_environmenttype,
-            runtimes, True, commandline_arguments)
+            buildscript_file, target_environmenttype_mapping, default_target_environmenttype, verbosity, target_environmenttype,  runtimes, True, commandline_arguments)
 
     @GeneralUtilities.check_arguments
     def standardized_tasks_build_for_dotnet_library_project(self, buildscript_file: str, default_target_environmenttype: str, target_environmenttype_mapping:  dict[str, str], runtimes: list[str], verbosity: int, commandline_arguments: list[str]) -> None:
@@ -733,6 +752,7 @@ class TasksForCommonProjectStructure:
     @GeneralUtilities.check_arguments
     def generate_sbom_for_dotnet_project(self, codeunit_folder: str, verbosity: int, commandline_arguments: list[str]) -> None:
         GeneralUtilities.write_message_to_stdout("Generate SBOM...")
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name = os.path.basename(codeunit_folder)
         sc = ScriptCollectionCore()
         bomfile_folder = "Other\\Artifacts\\BOM"
@@ -778,6 +798,7 @@ class TasksForCommonProjectStructure:
         This script expectes that the testcoverage-reportfolder is '<repositorybasefolder>/<codeunitname>/Other/Artifacts/TestCoverageReport'.
         This script expectes that a test-coverage-badges should be added to '<repositorybasefolder>/<codeunitname>/Other/Resources/Badges'."""
         GeneralUtilities.write_message_to_stdout("Generate testcoverage report..")
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         codeunit_version = self.get_version_of_codeunit(os.path.join(repository_folder, codeunitname, f"{codeunitname}.codeunit.xml"))
         verbosity = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(commandline_arguments, verbosity)
         if verbosity == 0:
@@ -847,6 +868,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def run_testcases_common_post_task(self, repository_folder: str, codeunit_name: str, verbosity: int, generate_badges: bool, targetenvironmenttype: str, commandline_arguments: list[str]) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         coverage_file_folder = os.path.join(repository_folder, codeunit_name, "Other/Artifacts/TestCoverage")
         coveragefiletarget = os.path.join(coverage_file_folder,  "TestCoverage.xml")
         self.update_path_of_source_in_testcoverage_file(repository_folder, codeunit_name)
@@ -856,6 +878,7 @@ class TasksForCommonProjectStructure:
     @staticmethod
     @GeneralUtilities.check_arguments
     def update_path_of_source_in_testcoverage_file(repository_folder: str, codeunitname: str) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         GeneralUtilities.write_message_to_stdout("Update paths of source files in testcoverage files..")
         folder = f"{repository_folder}/{codeunitname}/Other/Artifacts/TestCoverage"
         filename = "TestCoverage.xml"
@@ -865,6 +888,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def __standardized_tasks_run_testcases_for_dotnet_project_helper(self, source: str, codeunit_folder: str, match: re.Match) -> str:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         filename = match.group(1)
         file = os.path.join(source, filename)
         # GeneralUtilities.assert_condition(os.path.isfile(file),f"File \"{file}\" does not exist.")
@@ -875,6 +899,7 @@ class TasksForCommonProjectStructure:
     @staticmethod
     @GeneralUtilities.check_arguments
     def __remove_not_existing_files_from_testcoverage_file(testcoveragefile: str, repository_folder: str, codeunit_name: str) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         root: etree._ElementTree = etree.parse(testcoveragefile)
         codeunit_folder = os.path.join(repository_folder, codeunit_name)
         xpath = f"//coverage/packages/package[@name='{codeunit_name}']/classes/class"
@@ -1131,6 +1156,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def generate_certificate_for_development_purposes_for_product(self, repository_folder: str):
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         product_name = os.path.basename(repository_folder)
         ca_folder: str = os.path.join(repository_folder, "Other", "Resources", "CA")
         self.__generate_certificate_for_development_purposes(product_name, os.path.join(repository_folder, "Other", "Resources"), ca_folder, None)
@@ -1143,6 +1169,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def generate_certificate_for_development_purposes_for_codeunit(self, codeunit_folder: str, domain: str = None):
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name = os.path.basename(codeunit_folder)
         self.ensure_product_resource_is_imported(codeunit_folder, "CA")
         ca_folder: str = os.path.join(codeunit_folder, "Other", "Resources", "CA")
@@ -1171,7 +1198,7 @@ class TasksForCommonProjectStructure:
             GeneralUtilities.write_message_to_stdout("Generate TLS-certificate for development-purposes.")
             self.__sc.generate_certificate(certificate_folder, domain, resource_content_filename, "DE", "SubjST", "SubjL", "SubjO", "SubjOU")
             self.__sc.generate_certificate_sign_request(certificate_folder, domain, resource_content_filename, "DE", "SubjST", "SubjL", "SubjO", "SubjOU")
-            ca_name = os.path.basename(self.__sc.find_file_by_extension_and_return_all(ca_folder, "crt")[-1])[:-4]
+            ca_name = os.path.basename(self.__sc.find_last_file_by_extension(ca_folder, "crt"))[:-4]
             self.__sc.sign_certificate(certificate_folder, ca_folder, ca_name, domain, resource_content_filename)
             GeneralUtilities.ensure_file_does_not_exist(unsignedcertificate_file)
 
@@ -1423,6 +1450,7 @@ class TasksForCommonProjectStructure:
             raise ValueError('An empty array as argument for the "commandline_arguments"-parameter is not valid.')
         commandline_arguments = commandline_arguments[1:]
         repository_folder: str = str(Path(os.path.dirname(common_tasks_scripts_file)).parent.parent.absolute())
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         codeunit_name: str = str(os.path.basename(Path(os.path.dirname(common_tasks_scripts_file)).parent.absolute()))
         verbosity = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(commandline_arguments, verbosity)
         project_version = self.get_version_of_project(repository_folder)
@@ -1435,8 +1463,7 @@ class TasksForCommonProjectStructure:
         if not os.path.isfile(codeunit_file):
             raise ValueError(f'Codeunitfile "{codeunit_file}" does not exist.')
         # TODO implement usage of self.reference_latest_version_of_xsd_when_generating_xml
-        namespaces = {'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure',
-                      'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
+        namespaces = {'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure',  'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
         root: etree._ElementTree = etree.parse(codeunit_file)
 
         # Check codeunit-spcecification-version
@@ -1544,6 +1571,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def __suport_information_exists(self, repository_folder: str, version_of_product: str) -> bool:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         folder = os.path.join(repository_folder, "Other", "Resources", "Support")
         file = os.path.join(folder, "InformationAboutSupportedVersions.csv")
         if not os.path.isfile(file):
@@ -1556,6 +1584,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_versions(self, repository_folder: str) -> list[(str, datetime, datetime)]:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         folder = os.path.join(repository_folder, "Other", "Resources", "Support")
         file = os.path.join(folder, "InformationAboutSupportedVersions.csv")
         result: list[str] = list[(str, datetime, datetime)]()
@@ -1568,6 +1597,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_supported_versions(self, repository_folder: str, moment: datetime) -> list[(str, datetime, datetime)]:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         result: list[str] = list[(str, datetime, datetime)]()
         for entry in self.get_versions(repository_folder):
             if entry[1] <= moment and moment <= entry[2]:
@@ -1576,6 +1606,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_unsupported_versions(self, repository_folder: str, moment: datetime) -> list[(str, datetime, datetime)]:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         result: list[str] = list[(str, datetime, datetime)]()
         for entry in self.get_versions(repository_folder):
             if not (entry[1] <= moment and moment <= entry[2]):
@@ -1584,6 +1615,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def mark_current_version_as_supported(self, repository_folder: str, version_of_product: str, supported_from: datetime, supported_until: datetime):
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         if self.__suport_information_exists(repository_folder, version_of_product):
             raise ValueError(f"Version-support for v{version_of_product} already defined.")
         folder = os.path.join(repository_folder, "Other", "Resources", "Support")
@@ -1596,22 +1628,21 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_codeunit_owner_name(self, codeunit_file: str) -> None:
-        namespaces = {'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure',
-                      'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
+        namespaces = {'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure',  'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
         root: etree._ElementTree = etree.parse(codeunit_file)
         result = root.xpath('//cps:codeunit/cps:codeunitownername/text()', namespaces=namespaces)[0]
         return result
 
     @GeneralUtilities.check_arguments
     def get_codeunit_owner_emailaddress(self, codeunit_file: str) -> None:
-        namespaces = {'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure',
-                      'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
+        namespaces = {'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure', 'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
         root: etree._ElementTree = etree.parse(codeunit_file)
         result = root.xpath('//cps:codeunit/cps:codeunitowneremailaddress/text()', namespaces=namespaces)[0]
         return result
 
     @GeneralUtilities.check_arguments
     def generate_diff_report(self, repository_folder: str, codeunit_name: str, current_version: str) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         codeunit_folder = os.path.join(repository_folder, codeunit_name)
         target_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts/DiffReport", codeunit_folder)
         GeneralUtilities.ensure_directory_does_not_exist(target_folder)
@@ -1643,6 +1674,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def replace_common_variables_in_nuspec_file(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name = os.path.basename(codeunit_folder)
         codeunit_version = self.get_version_of_codeunit_folder(codeunit_folder)
         nuspec_file = os.path.join(codeunit_folder, "Other", "Build", f"{codeunit_name}.nuspec")
@@ -1666,6 +1698,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def standardized_tasks_build_bom_for_node_project(self, codeunit_folder: str, verbosity: int, commandline_arguments: list[str]) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         verbosity = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(commandline_arguments, verbosity)
         # TODO
 
@@ -1793,47 +1826,57 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def set_default_constants(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         self.set_constant_for_commitid(codeunit_folder)
         self.set_constant_for_commitdate(codeunit_folder)
-        self.set_constant_for_commitname(codeunit_folder)
+        self.set_constant_for_codeunitname(codeunit_folder)
         self.set_constant_for_codeunitversion(codeunit_folder)
         self.set_constant_for_codeunitmajorversion(codeunit_folder)
         self.set_constant_for_description(codeunit_folder)
 
     @GeneralUtilities.check_arguments
     def set_constant_for_commitid(self, codeunit_folder: str) -> None:
-        commit_id = self.__sc.git_get_commit_id(codeunit_folder)
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
+        repository = GeneralUtilities.resolve_relative_path("..", codeunit_folder)
+        commit_id = self.__sc.git_get_commit_id(repository)
         self.set_constant(codeunit_folder, "CommitId", commit_id)
 
     @GeneralUtilities.check_arguments
     def set_constant_for_commitdate(self, codeunit_folder: str) -> None:
-        commit_date: datetime = self.__sc.git_get_commit_date(codeunit_folder)
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
+        repository = GeneralUtilities.resolve_relative_path("..", codeunit_folder)
+        commit_date: datetime = self.__sc.git_get_commit_date(repository)
         self.set_constant(codeunit_folder, "CommitDate", GeneralUtilities.datetime_to_string(commit_date))
 
     @GeneralUtilities.check_arguments
-    def set_constant_for_commitname(self, codeunit_folder: str) -> None:
+    def set_constant_for_codeunitname(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name: str = os.path.basename(codeunit_folder)
         self.set_constant(codeunit_folder, "CodeUnitName", codeunit_name)
 
     @GeneralUtilities.check_arguments
     def set_constant_for_codeunitversion(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_version: str = self.get_version_of_codeunit_folder(codeunit_folder)
         self.set_constant(codeunit_folder, "CodeUnitVersion", codeunit_version)
 
     @GeneralUtilities.check_arguments
     def set_constant_for_codeunitmajorversion(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_version: str = self.get_version_of_codeunit_folder(codeunit_folder)
         major_version = int(codeunit_version.split(".")[0])
         self.set_constant(codeunit_folder, "CodeUnitMajorVersion", str(major_version))
 
     @GeneralUtilities.check_arguments
     def set_constant_for_description(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name: str = os.path.basename(codeunit_folder)
         codeunit_description: str = self.get_codeunit_description(f"{codeunit_folder}/{codeunit_name}.codeunit.xml")
         self.set_constant(codeunit_folder, "CodeUnitDescription", codeunit_description)
 
     @GeneralUtilities.check_arguments
     def set_constant(self, codeunit_folder: str, constantname: str, constant_value: str, documentationsummary: str = None, constants_valuefile: str = None) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         if documentationsummary is None:
             documentationsummary = ""
         constants_folder = os.path.join(codeunit_folder, "Other", "Resources", "Constants")
@@ -1861,16 +1904,19 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_constant_value(self, source_codeunit_folder: str, constant_name: str) -> str:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(source_codeunit_folder)
         value_file_relative = self.__get_constant_helper(source_codeunit_folder, constant_name, "path")
         value_file = GeneralUtilities.resolve_relative_path(value_file_relative, os.path.join(source_codeunit_folder, "Other", "Resources", "Constants"))
         return GeneralUtilities.read_text_from_file(value_file)
 
     @GeneralUtilities.check_arguments
     def get_constant_documentation(self, source_codeunit_folder: str, constant_name: str) -> str:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(source_codeunit_folder)
         return self.__get_constant_helper(source_codeunit_folder, constant_name, "documentationsummary")
 
     @GeneralUtilities.check_arguments
     def __get_constant_helper(self, source_codeunit_folder: str, constant_name: str, propertyname: str) -> str:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(source_codeunit_folder)
         root: etree._ElementTree = etree.parse(os.path.join(source_codeunit_folder, "Other", "Resources", "Constants", f"{constant_name}.constant.xml"))
         results = root.xpath(f'//cps:{propertyname}/text()', namespaces={
             'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure'
@@ -1885,6 +1931,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def copy_development_certificate_to_default_development_directory(self, codeunit_folder: str, build_environment: str, domain: str = None, certificate_resource_name: str = "DevelopmentCertificate") -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         if build_environment != "Productive":
             codeunit_name: str = os.path.basename(codeunit_folder)
             if domain is None:
@@ -1905,7 +1952,7 @@ class TasksForCommonProjectStructure:
     @GeneralUtilities.check_arguments
     def set_constants_for_certificate_public_information(self, codeunit_folder: str, source_constant_name: str = "DevelopmentCertificate", domain: str = None) -> None:
         """Expects a certificate-resource and generates a constant for its public information"""
-        # codeunit_name = os.path.basename(codeunit_folder)
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         certificate_file = os.path.join(codeunit_folder, "Other", "Resources", source_constant_name, f"{source_constant_name}.crt")
         with open(certificate_file, encoding="utf-8") as text_wrapper:
             certificate = crypto.load_certificate(crypto.FILETYPE_PEM, text_wrapper.read())
@@ -1915,6 +1962,7 @@ class TasksForCommonProjectStructure:
     @GeneralUtilities.check_arguments
     def set_constants_for_certificate_private_information(self, codeunit_folder: str) -> None:
         """Expects a certificate-resource and generates a constant for its sensitive information in hex-format"""
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name = os.path.basename(codeunit_folder)
         resource_name: str = "DevelopmentCertificate"
         filename: str = codeunit_name+"DevelopmentCertificate"
@@ -1923,6 +1971,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def generate_constant_from_resource_by_filename(self, codeunit_folder: str, resource_name: str, filename: str, constant_name: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         certificate_resource_folder = GeneralUtilities.resolve_relative_path(f"Other/Resources/{resource_name}", codeunit_folder)
         resource_file = os.path.join(certificate_resource_folder, filename)
         resource_file_content = GeneralUtilities.read_binary_from_file(resource_file)
@@ -1931,6 +1980,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def generate_constant_from_resource_by_extension(self, codeunit_folder: str, resource_name: str, extension: str, constant_name: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         certificate_resource_folder = GeneralUtilities.resolve_relative_path(f"Other/Resources/{resource_name}", codeunit_folder)
         resource_file = self.__sc.find_file_by_extension(certificate_resource_folder, extension)
         resource_file_content = GeneralUtilities.read_binary_from_file(resource_file)
@@ -1939,6 +1989,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def copy_constant_from_dependent_codeunit(self, codeunit_folder: str, constant_name: str, source_codeunit_name: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         source_codeunit_folder: str = GeneralUtilities.resolve_relative_path(f"../{source_codeunit_name}", codeunit_folder)
         value = self.get_constant_value(source_codeunit_folder, constant_name)
         documentation = self.get_constant_documentation(source_codeunit_folder, constant_name)
@@ -1946,6 +1997,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def copy_resources_from_dependent_codeunit(self, codeunit_folder: str, resource_name: str, source_codeunit_name: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         source_folder: str = GeneralUtilities.resolve_relative_path(f"../{source_codeunit_name}/Other/Resources/{resource_name}", codeunit_folder)
         target_folder: str = GeneralUtilities.resolve_relative_path(f"Other/Resources/{resource_name}", codeunit_folder)
         GeneralUtilities.ensure_directory_does_not_exist(target_folder)
@@ -1957,6 +2009,7 @@ class TasksForCommonProjectStructure:
         codeunitname = os.path.basename(str(Path(os.path.dirname(buildscript_file)).parent.parent.absolute()))
         repository_folder = str(Path(os.path.dirname(buildscript_file)).parent.parent.parent.absolute())
         codeunit_folder = os.path.join(repository_folder, codeunitname)
+        self.assert_is_codeunit_folder(codeunit_folder)
         artifacts_folder = os.path.join(codeunit_folder, "Other", "Artifacts")
         GeneralUtilities.ensure_directory_exists(os.path.join(artifacts_folder, "APISpecification"))
         verbosity = self.get_verbosity_from_commandline_arguments(commandline_arguments, verbosity)
@@ -1994,6 +2047,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def ensure_openapigenerator_is_available(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         openapigenerator_folder = os.path.join(codeunit_folder, "Other", "Resources", "OpenAPIGenerator")
         internet_connection_is_available = GeneralUtilities.internet_connection_is_available()
         filename = "open-api-generator.jar"
@@ -2114,6 +2168,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def add_github_release(self, productname: str, projectversion: str, build_artifacts_folder: str, github_username: str, repository_folder: str, commandline_arguments: list[str]) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         GeneralUtilities.write_message_to_stdout(f"Create GitHub-release for {productname}.")
         verbosity = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(commandline_arguments, 1)
         github_repo = f"{github_username}/{productname}"
@@ -2126,8 +2181,8 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_dependencies_which_are_ignored_from_updates(self, codeunit_folder: str, print_warnings_for_ignored_dependencies: bool) -> list[str]:
-        namespaces = {'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure',
-                      'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
+        namespaces = {'cps': 'https://projects.aniondev.de/PublicProjects/Common/ProjectTemplates/-/tree/main/Conventions/RepositoryStructure/CommonProjectStructure', 'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
         codeunit_name = os.path.basename(codeunit_folder)
         codeunit_file = os.path.join(codeunit_folder, f"{codeunit_name}.codeunit.xml")
         root: etree._ElementTree = etree.parse(codeunit_file)
@@ -2200,6 +2255,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def generate_tasksfile_from_workspace_file(self, repository_folder: str, append_cli_args_at_end: bool = False) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         sc: ScriptCollectionCore = ScriptCollectionCore()
         workspace_file: str = sc.find_file_by_extension(repository_folder, "code-workspace")
         task_file: str = os.path.join(repository_folder, "Taskfile.yml")
@@ -2320,6 +2376,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def create_artifact_for_development_certificate(self, codeunit_folder: str):
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         ce_source_folder = GeneralUtilities.resolve_relative_path("Other/Resources/DevelopmentCertificate", codeunit_folder)
         ca_source_folder = GeneralUtilities.resolve_relative_path("Other/Resources/CA", codeunit_folder)
         ce_target_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts/DevelopmentCertificate", codeunit_folder)
@@ -2342,6 +2399,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def get_project_name(self, repository_folder: str) -> str:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         for file in GeneralUtilities.get_direct_files_of_folder(repository_folder):
             if file.endswith(".code-workspace"):
                 return Path(file).stem
@@ -2354,13 +2412,14 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def build_codeunit(self, codeunit_folder: str, verbosity: int = 1, target_environmenttype: str = "QualityCheck", additional_arguments_file: str = None, is_pre_merge: bool = False, export_target_directory: str = None, assume_dependent_codeunits_are_already_built: bool = False, commandlinearguments: list[str] = []) -> None:
-        codeunit_folder = GeneralUtilities.resolve_relative_path_from_current_working_directory(codeunit_folder)
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name = os.path.basename(codeunit_folder)
         repository_folder = os.path.dirname(codeunit_folder)
         self.build_specific_codeunits(repository_folder, [codeunit_name], verbosity, target_environmenttype, additional_arguments_file, is_pre_merge, export_target_directory, assume_dependent_codeunits_are_already_built, commandlinearguments, False)
 
     @GeneralUtilities.check_arguments
     def build_codeunitsC(self, repository_folder: str, image: str, verbosity: int = 1, target_environmenttype: str = "QualityCheck", additional_arguments_file: str = None, commandlinearguments: list[str] = []) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         if target_environmenttype == "Development":
             raise ValueError(f"build_codeunitsC is not available for target_environmenttype {target_environmenttype}.")
         # TODO handle additional_arguments_file
@@ -2371,13 +2430,14 @@ class TasksForCommonProjectStructure:
     @GeneralUtilities.check_arguments
     def build_codeunits(self, repository_folder: str, verbosity: int = 1, target_environmenttype: str = "QualityCheck", additional_arguments_file: str = None, is_pre_merge: bool = False, export_target_directory: str = None, commandline_arguments: list[str] = [], do_git_clean_when_no_changes: bool = False) -> None:
         self.__check_target_environmenttype(target_environmenttype)
-        repository_folder = GeneralUtilities.resolve_relative_path_from_current_working_directory(repository_folder)
         GeneralUtilities.assert_is_git_repository(repository_folder)
+        repository_folder = GeneralUtilities.resolve_relative_path_from_current_working_directory(repository_folder)
         codeunits = self.get_codeunits(repository_folder, False)
         self.build_specific_codeunits(repository_folder, codeunits, verbosity, target_environmenttype, additional_arguments_file, is_pre_merge, export_target_directory, False, commandline_arguments, do_git_clean_when_no_changes)
 
     @GeneralUtilities.check_arguments
     def build_specific_codeunits(self, repository_folder: str, codeunits: list[str], verbosity: int = 1, target_environmenttype: str = "QualityCheck", additional_arguments_file: str = None, is_pre_merge: bool = False, export_target_directory: str = None, assume_dependent_codeunits_are_already_built: bool = True, commandline_arguments: list[str] = [], do_git_clean_when_no_changes: bool = False) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         self.__check_target_environmenttype(target_environmenttype)
         repository_folder = GeneralUtilities.resolve_relative_path_from_current_working_directory(repository_folder)
         contains_uncommitted_changes = self.__sc.git_repository_has_uncommitted_changes(repository_folder)
@@ -2409,9 +2469,10 @@ class TasksForCommonProjectStructure:
 
         now = datetime.now()
         if not self.__suport_information_exists(repository_folder, project_version):
-            support_time = timedelta(days=365*2+30*3)  # TODO make this configurable
+            support_time = timedelta(days=365*2+30*3+1)  # TODO make this configurable
             until = now + support_time
-            self.mark_current_version_as_supported(repository_folder, project_version, now, until)
+            until_day=datetime(until.year,until.month,until.day,0,0,0)
+            self.mark_current_version_as_supported(repository_folder, project_version, now, until_day)
 
         if len(sorted_codeunits) == 0:
             raise ValueError(f'No codeunit found in subfolders of "{repository_folder}".')
@@ -2449,19 +2510,15 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def __do_repository_checks(self, repository_folder: str, project_version: str) -> None:
-        self.__check_if_folder_is_git_repository(repository_folder)
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         self.__check_if_changelog_exists(repository_folder, project_version)
         self.__check_whether_security_txt_exists(repository_folder)
         self.__check_whether_workspace_file_exists(repository_folder)
         self.__check_for_staged_or_committed_ignored_files(repository_folder)
 
-    @GeneralUtilities.check_arguments
-    def __check_if_folder_is_git_repository(self, repository_folder: str) -> None:
-        if (not self.__sc.is_git_repository(repository_folder)):
-            raise ValueError(f"Folder {repository_folder} is not a git-repository")
-
     @GeneralUtilities.check_arguments
     def __check_if_changelog_exists(self, repository_folder: str, project_version: str) -> None:
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         changelog_folder = os.path.join(repository_folder, "Other", "Resources", "Changelog")
         changelog_file = os.path.join(changelog_folder, f"v{project_version}.md")
         if not os.path.isfile(changelog_file):
@@ -2507,6 +2564,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def __ensure_grylibrary_is_available(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         grylibrary_folder = os.path.join(codeunit_folder, "Other", "Resources", "GRYLibrary")
         grylibrary_dll_file = os.path.join(grylibrary_folder, "BuildResult_DotNet_win-x64", "GRYLibrary.dll")
         internet_connection_is_available = GeneralUtilities.internet_connection_is_available()
@@ -2538,6 +2596,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def ensure_ffmpeg_is_available(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         ffmpeg_folder = os.path.join(codeunit_folder, "Other", "Resources", "FFMPEG")
         internet_connection_is_available = GeneralUtilities.internet_connection_is_available()
         exe_file = f"{ffmpeg_folder}/ffmpeg.exe"
@@ -2624,6 +2683,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def create_deb_package_for_artifact(self, codeunit_folder: str, maintainername: str, maintaineremail: str, description: str, verbosity: int, cmd_arguments: list[str]) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         verbosity = self.get_verbosity_from_commandline_arguments(cmd_arguments, verbosity)
         codeunit_name = os.path.basename(codeunit_folder)
         binary_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts/BuildResult_DotNet_linux-x64", codeunit_folder)
@@ -2647,6 +2707,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def update_year_for_dotnet_codeunit(self, codeunit_folder: str) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name = os.path.basename(codeunit_folder)
         csproj_file = os.path.join(codeunit_folder, codeunit_name, f"{codeunit_name}.csproj")
         self.__sc.update_year_in_copyright_tags(csproj_file)
@@ -2662,6 +2723,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def verify_artifact_exists(self, codeunit_folder: str, artifact_name_regexes: dict[str, bool]) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         codeunit_name: str = os.path.basename(codeunit_folder)
         artifacts_folder = os.path.join(codeunit_folder, "Other/Artifacts")
         existing_artifacts = [os.path.basename(x) for x in GeneralUtilities.get_direct_folders_of_folder(artifacts_folder)]
@@ -2680,6 +2742,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def __build_codeunit(self, codeunit_folder: str, verbosity: int = 1, target_environmenttype: str = "QualityCheck", additional_arguments_file: str = None, is_pre_merge: bool = False, assume_dependent_codeunits_are_already_built: bool = False, commandline_arguments: list[str] = []) -> None:
+        TasksForCommonProjectStructure.assert_is_codeunit_folder(codeunit_folder)
         now = datetime.now()
         codeunit_folder = GeneralUtilities.resolve_relative_path_from_current_working_directory(codeunit_folder)
         codeunit_name: str = os.path.basename(codeunit_folder)
@@ -2800,6 +2863,7 @@ class TasksForCommonProjectStructure:
     @GeneralUtilities.check_arguments
     def generic_update_dependencies(self, repository_folder: str, verbosity: int = 1):
         # Prepare
+        GeneralUtilities.assert_is_git_repository(repository_folder)
         codeunits = self.get_codeunits(repository_folder)
         updated_dependencies = False
         update_dependencies_script_filename = "UpdateDependencies.py"
@@ -2955,6 +3019,7 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def create_changelog_entry(self, repositoryfolder: str, message: str, commit: bool):
+        GeneralUtilities.assert_is_git_repository(repositoryfolder)
         current_version = self.get_version_of_project(repositoryfolder)
         changelog_file = os.path.join(repositoryfolder, "Other", "Resources", "Changelog", f"v{current_version}.md")
         if os.path.isdir(changelog_file):

{ScriptCollection-3.5.47.dist-info → ScriptCollection-3.5.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ScriptCollection
-Version: 3.5.47
+Version: 3.5.49
 Summary: The ScriptCollection is the place for reusable scripts.
 Home-page: https://github.com/anionDev/ScriptCollection
 Author: Marius Göcke

{ScriptCollection-3.5.47.dist-info → ScriptCollection-3.5.49.dist-info}/RECORD

@@ -1,16 +1,16 @@
 ScriptCollection/Executables.py,sha256=ls3wGZpt48YwwtO0QGWWyIImSE87SyzbL-WxhpwQJug,20837
-ScriptCollection/GeneralUtilities.py,sha256=YLVXHzKfyN3F50SE-xzrz2YHmLtaS70OogWOSjm4mrc,37570
+ScriptCollection/GeneralUtilities.py,sha256=Kh_oSUtCyBra5LuH5_5_HkyM14YvA21ug8cK4ODsamI,37744
 ScriptCollection/ProcessesRunner.py,sha256=3mu4ZxzZleQo0Op6o9EYTCFiJfb6kx5ov2YfZfT89mU,1395
 ScriptCollection/ProgramRunnerBase.py,sha256=7QAjoqOz6XPmJH19F2k-Z1fFQB_uZnPFvn-T54IJcHQ,2324
 ScriptCollection/ProgramRunnerEpew.py,sha256=C2Rs3YWOWWWJct7XmKphp5CF1tf0j4Fp-ljV2drLTfs,6349
 ScriptCollection/ProgramRunnerPopen.py,sha256=UGWUK0345DmtnD1gsKa1B3tBLDzKKXUGnSbIuCSWzLU,3714
 ScriptCollection/RPStream.py,sha256=NRRHL3YSP3D9MuAV2jB_--0KUKCsvJGxeKnxgrRZ9kY,1545
-ScriptCollection/ScriptCollectionCore.py,sha256=PNQVi6eu-I-t76OYnVSz1N0eksO_iOhOgP7zGzfEVhs,103764
-ScriptCollection/TasksForCommonProjectStructure.py,sha256=6_ix9xbVfNo27NhATMfHN8VkCuIeRSnPfJq60MQDTTU,208674
+ScriptCollection/ScriptCollectionCore.py,sha256=CgWu2xqIYMu06BJLsBtCZ3v_GNgqzUU84xCtNKyC3O4,106702
+ScriptCollection/TasksForCommonProjectStructure.py,sha256=w19PqN9ICOF7vF9Muxbs-t5wPPh1qqJUvxsY5QAfpB8,213960
 ScriptCollection/UpdateCertificates.py,sha256=Eynbgu7k9jLxApP2D_8Il77B6BFjJap6K7oTeEAZYbk,7790
 ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ScriptCollection-3.5.47.dist-info/METADATA,sha256=jNsNTEiB18-jTBpu-Gpfa75BY50wbAqm2V4UIX1F73w,7665
-ScriptCollection-3.5.47.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-ScriptCollection-3.5.47.dist-info/entry_points.txt,sha256=_O7BmQ81LdDfrj5uOhjshg9Xc-tABHQJIxDOyOGRzzI,2397
-ScriptCollection-3.5.47.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
-ScriptCollection-3.5.47.dist-info/RECORD,,
+ScriptCollection-3.5.49.dist-info/METADATA,sha256=aqDa6blUTgJpB6VFlVPGx0SjJwBJWye0lt9ihAl2R_s,7665
+ScriptCollection-3.5.49.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ScriptCollection-3.5.49.dist-info/entry_points.txt,sha256=_O7BmQ81LdDfrj5uOhjshg9Xc-tABHQJIxDOyOGRzzI,2397
+ScriptCollection-3.5.49.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
+ScriptCollection-3.5.49.dist-info/RECORD,,