ScriptCollection 3.5.5__py3-none-any.whl → 3.5.8__py3-none-any.whl

ScriptCollection/ScriptCollectionCore.py

@@ -29,7 +29,7 @@ from .ProgramRunnerBase import ProgramRunnerBase
 from .ProgramRunnerPopen import ProgramRunnerPopen
 from .ProgramRunnerEpew import ProgramRunnerEpew, CustomEpewArgument
 
-version = "3.5.5"
+version = "3.5.8"
 __version__ = version
 
 
@@ -94,8 +94,7 @@ class ScriptCollectionCore:
         versiononlyregex = f"^{versionregex}$"
         pattern = re.compile(versiononlyregex)
         if pattern.match(new_version):
-            GeneralUtilities.write_text_to_file(nuspec_file, re.sub(
-                f"<version>{versionregex}<\\/version>", f"<version>{new_version}</version>", GeneralUtilities.read_text_from_file(nuspec_file)))
+            GeneralUtilities.write_text_to_file(nuspec_file, re.sub(f"<version>{versionregex}<\\/version>", f"<version>{new_version}</version>", GeneralUtilities.read_text_from_file(nuspec_file)))
         else:
             raise ValueError(
                 f"Version '{new_version}' does not match version-regex '{versiononlyregex}'")
@@ -129,17 +128,14 @@ class ScriptCollectionCore:
 
     @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}")]
+        result = [file for file in GeneralUtilities.get_direct_files_of_folder(folder) if file.endswith(f".{extension}")]
         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}'.")
         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}'.")
 
     @GeneralUtilities.check_arguments
     def commit_is_signed_by_key(self, repository_folder: str, revision_identifier: str, key: str) -> bool:
@@ -203,8 +199,7 @@ class ScriptCollectionCore:
         elif exit_code == 1:
             return False
         else:
-            raise ValueError(
-                f"Can not calculate if {ancestor} is an ancestor of {descendant} in repository {repository_folder}.")
+            raise ValueError(f"Can not calculate if {ancestor} is an ancestor of {descendant} in repository {repository_folder}.")
 
     @GeneralUtilities.check_arguments
     def __git_changes_helper(self, repository_folder: str, arguments_as_array: list[str]) -> bool:
@@ -245,8 +240,7 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_get_commit_id(self, repository_folder: str, commit: str = "HEAD") -> str:
-        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)
+        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
@@ -259,31 +253,50 @@ class ScriptCollectionCore:
 
     @GeneralUtilities.check_arguments
     def git_fetch(self, folder: str, remotename: str = "--all") -> None:
-        self.run_program_argsasarray("git", ["fetch", remotename, "--tags", "--prune"],
-                                     folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.run_program_argsasarray("git", ["fetch", remotename, "--tags", "--prune"], folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
     @GeneralUtilities.check_arguments
     def git_fetch_in_bare_repository(self, folder: str, remotename, localbranch: str, remotebranch: str) -> None:
-        self.run_program_argsasarray("git", [
-                                     "fetch", remotename, f"{remotebranch}:{localbranch}"], folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.run_program_argsasarray("git", ["fetch", remotename, f"{remotebranch}:{localbranch}"], folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
     @GeneralUtilities.check_arguments
     def git_remove_branch(self, folder: str, branchname: str) -> None:
-        self.run_program("git", f"branch -D {branchname}", folder,
-                         throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        self.run_program("git", f"branch -D {branchname}", folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
     @GeneralUtilities.check_arguments
     def git_push(self, folder: str, remotename: str, localbranchname: str, remotebranchname: str, forcepush: bool = False, pushalltags: bool = True, verbosity: int = 0) -> None:
-        argument = ["push", "--recurse-submodules=on-demand",
-                    remotename, f"{localbranchname}:{remotebranchname}"]
+        argument = ["push", "--recurse-submodules=on-demand", remotename, f"{localbranchname}:{remotebranchname}"]
         if (forcepush):
             argument.append("--force")
         if (pushalltags):
             argument.append("--tags")
-        result: tuple[int, str, str, int] = self.run_program_argsasarray("git", argument, folder, throw_exception_if_exitcode_is_not_zero=True,
-                                                                         verbosity=verbosity, print_errors_as_information=True)
+        result: tuple[int, str, str, int] = self.run_program_argsasarray("git", argument, folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=verbosity, print_errors_as_information=True)
         return result[1].replace('\r', '').replace('\n', '')
 
+    @GeneralUtilities.check_arguments
+    def git_pull(self, folder: str, remote: str, localbranchname: str, remotebranchname: str) -> None:
+        self.run_program("git", f"pull {folder} {remote} {remotebranchname}:{localbranchname}", folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+
+    @GeneralUtilities.check_arguments
+    def git_list_remote_branches(self, folder: str, remote: str, fetch: bool) -> list[str]:
+        if fetch:
+            self.git_fetch(folder, remote)
+        run_program_result = self.run_program("git", f"branch -rl {remote}/*", folder, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+        output = GeneralUtilities.string_to_lines(run_program_result[1])
+        result = list[str]()
+        for item in output:
+            striped_item = item.strip()
+            if GeneralUtilities.string_has_content(striped_item):
+                branch: str = None
+                if " " in striped_item:
+                    branch = striped_item.split(" ")[0]
+                else:
+                    branch = striped_item
+                branchname = branch[len(remote)+1:]
+                if branchname != "HEAD":
+                    result.append(branchname)
+        return result
+
     @GeneralUtilities.check_arguments
     def git_clone(self, clone_target_folder: str, remote_repository_path: str, include_submodules: bool = True, mirror: bool = False) -> None:
         if (os.path.isdir(clone_target_folder)):
@@ -295,19 +308,16 @@ class ScriptCollectionCore:
                 args.append("--remote-submodules")
             if mirror:
                 args.append("--mirror")
-            self.run_program_argsasarray("git", args, os.getcwd(
-            ), throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
+            self.run_program_argsasarray("git", args, os.getcwd(), throw_exception_if_exitcode_is_not_zero=True, verbosity=0)
 
     @GeneralUtilities.check_arguments
     def git_get_all_remote_names(self, directory: str) -> list[str]:
-        result = GeneralUtilities.string_to_lines(self.run_program_argsasarray(
-            "git", ["remote"], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
+        result = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", ["remote"], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
         return result
 
     @GeneralUtilities.check_arguments
     def git_get_remote_url(self, directory: str, remote_name: str) -> str:
-        result = GeneralUtilities.string_to_lines(self.run_program_argsasarray(
-            "git", ["remote", "get-url", remote_name], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
+        result = GeneralUtilities.string_to_lines(self.run_program_argsasarray("git", ["remote", "get-url", remote_name], directory, throw_exception_if_exitcode_is_not_zero=True, verbosity=0)[1], False)
         return result[0].replace('\n', '')
 
     @GeneralUtilities.check_arguments
@@ -1262,13 +1272,9 @@ class ScriptCollectionCore:
             working_directory = self.__adapt_workingdirectory(working_directory)
 
             if arguments_for_log is None:
-                arguments_for_log = ' '.join(arguments_as_array)
-            else:
-                arguments_for_log = ' '.join(arguments_for_log)
-
-            arguments_for_exception_as_string = arguments_for_log
+                arguments_for_log = arguments_as_array
 
-            arguments_for_log_as_string = arguments_for_log
+            arguments_for_log_as_string: str = ' '.join(arguments_for_log)
             cmd = f'{working_directory}>{program} {arguments_for_log_as_string}'
 
             if GeneralUtilities.string_is_none_or_whitespace(title):
@@ -1278,7 +1284,6 @@ class ScriptCollectionCore:
 
             if verbosity >= 3:
                 GeneralUtilities.write_message_to_stdout(f"Run '{info_for_log}'.")
-
             with self.__run_program_argsasarray_async_helper(program, arguments_as_array, working_directory, verbosity, print_errors_as_information, log_file, timeoutInSeconds, addLogOverhead, title, log_namespace, arguments_for_log, custom_argument, interactive) as process:
                 pid = process.pid
 
@@ -1350,14 +1355,8 @@ class ScriptCollectionCore:
                     stdout = GeneralUtilities.bytes_to_string(stdout).replace('\r', '')
                     stderr = GeneralUtilities.bytes_to_string(stderr).replace('\r', '')
 
-                if arguments_for_exception_as_string is None:
-                    arguments_for_exception_as_string = ' '.join(arguments_as_array)
-                else:
-                    arguments_for_exception_as_string = ' '.join(arguments_for_log)
-
                 if throw_exception_if_exitcode_is_not_zero and exit_code != 0:
-                    arguments_for_exception_as_string = ' '.join(arguments_for_log)
-                    raise ValueError(f"Program '{working_directory}>{program} {arguments_for_exception_as_string}' resulted in exitcode {exit_code}. (StdOut: '{stdout}', StdErr: '{stderr}')")
+                    raise ValueError(f"Program '{working_directory}>{program} {arguments_for_log_as_string}' resulted in exitcode {exit_code}. (StdOut: '{stdout}', StdErr: '{stderr}')")
 
                 result = (exit_code, stdout, stderr, pid)
                 return result
@@ -1543,13 +1542,13 @@ class ScriptCollectionCore:
         return result
 
     @GeneralUtilities.check_arguments
-    def generate_certificate_authority(self, folder: str, name: str, subj_c: str, subj_st: str, subj_l: str, subj_o: str, subj_ou: str,                                       days_until_expire: int = None, password: str = None) -> None:
+    def generate_certificate_authority(self, folder: str, name: str, subj_c: str, subj_st: str, subj_l: str, subj_o: str, subj_ou: str, days_until_expire: int = None, password: str = None) -> None:
         if days_until_expire is None:
             days_until_expire = 1825
         if password is None:
             password = GeneralUtilities.generate_password()
-        self.run_program(
-            "openssl", f'req -new -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -days {days_until_expire} -nodes -x509 -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={name}/OU={subj_ou} -passout pass:{password} -keyout {name}.key -out {name}.crt', folder)
+        GeneralUtilities.ensure_directory_exists(folder)
+        self.run_program("openssl", f'req -new -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -days {days_until_expire} -nodes -x509 -subj /C={subj_c}/ST={subj_st}/L={subj_l}/O={subj_o}/CN={name}/OU={subj_ou} -passout pass:{password} -keyout {name}.key -out {name}.crt', folder)
 
     @GeneralUtilities.check_arguments
     def generate_certificate(self, folder: str,  domain: str, filename: str, subj_c: str, subj_st: str, subj_l: str, subj_o: str, subj_ou: str, days_until_expire: int = None, password: str = None) -> None:
@@ -1598,10 +1597,8 @@ DNS                 = {domain}
         ca = os.path.join(ca_folder, ca_name)
         password_file = os.path.join(folder, f"{filename}.password")
         password = GeneralUtilities.read_text_from_file(password_file)
-        self.run_program(
-            "openssl", f'x509 -req -in {filename}.csr -CA {ca}.crt -CAkey {ca}.key -CAcreateserial -CAserial {ca}.srl -out {filename}.crt -days {days_until_expire} -sha256 -extensions v3_req -extfile {filename}.san.conf', folder)
-        self.run_program(
-            "openssl", f'pkcs12 -export -out {filename}.pfx -inkey {filename}.key -in {filename}.crt -password pass:{password}', folder)
+        self.run_program("openssl", f'x509 -req -in {filename}.csr -CA {ca}.crt -CAkey {ca}.key -CAcreateserial -CAserial {ca}.srl -out {filename}.crt -days {days_until_expire} -sha256 -extensions v3_req -extfile {filename}.san.conf', folder)
+        self.run_program("openssl", f'pkcs12 -export -out {filename}.pfx -inkey {filename}.key -in {filename}.crt -password pass:{password}', folder)
 
     @GeneralUtilities.check_arguments
     def update_dependencies_of_python_in_requirementstxt_file(self, file: str, verbosity: int):
@@ -1649,7 +1646,7 @@ DNS                 = {domain}
         GeneralUtilities.write_lines_to_file(setup_cfg_file, new_lines)
 
     @GeneralUtilities.check_arguments
-    def update_dependencies_of_dotnet_project(self, csproj_file: str, verbosity: int):
+    def update_dependencies_of_dotnet_project(self, csproj_file: str, verbosity: int, ignored_dependencies: list[str]):
         folder = os.path.dirname(csproj_file)
         csproj_filename = os.path.basename(csproj_file)
         GeneralUtilities.write_message_to_stderr(f"Check for updates in {csproj_filename}")
@@ -1658,12 +1655,12 @@ DNS                 = {domain}
             # Relevant output-lines are something like "    > NJsonSchema             10.7.0        10.7.0      10.9.0"
             if ">" in line:
                 package_name = line.replace(">", "").strip().split(" ")[0]
-                GeneralUtilities.write_message_to_stderr(f"Update package {package_name}")
-                self.run_program(
-                    "dotnet", f"add {csproj_filename} package {package_name}", folder)
+                if not (ignored_dependencies in package_name):
+                    GeneralUtilities.write_message_to_stderr(f"Update package {package_name}")
+                    self.run_program("dotnet", f"add {csproj_filename} package {package_name}", folder)
 
     @GeneralUtilities.check_arguments
-    def create_deb_package(self, toolname: str, binary_folder: str, control_file_content: str,                           deb_output_folder: str, verbosity: int, permission_of_executable_file_as_octet_triple: int) -> None:
+    def create_deb_package(self, toolname: str, binary_folder: str, control_file_content: str, deb_output_folder: str, verbosity: int, permission_of_executable_file_as_octet_triple: int) -> None:
 
         # prepare
         GeneralUtilities.ensure_directory_exists(deb_output_folder)

ScriptCollection/TasksForCommonProjectStructure.py

@@ -190,7 +190,7 @@ class TasksForCommonProjectStructure:
         GeneralUtilities.write_text_to_file(file, re.sub("version = \"\\d+\\.\\d+\\.\\d+\"", f"version = \"{new_version_value}\"", GeneralUtilities.read_text_from_file(file)))
 
     @GeneralUtilities.check_arguments
-    def standardized_tasks_run_testcases_for_python_codeunit(self, run_testcases_file: str, generate_badges: bool, verbosity: int,                                                             targetenvironmenttype: str, commandline_arguments: list[str]) -> None:
+    def standardized_tasks_run_testcases_for_python_codeunit(self, run_testcases_file: str, generate_badges: bool, verbosity: int, targetenvironmenttype: str, commandline_arguments: list[str]) -> None:
         codeunitname: str = Path(os.path.dirname(run_testcases_file)).parent.parent.name
         verbosity = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(commandline_arguments,  verbosity)
         repository_folder: str = str(Path(os.path.dirname(run_testcases_file)).parent.parent.parent.absolute())
@@ -1003,8 +1003,8 @@ class TasksForCommonProjectStructure:
 
             # Copy reference of codeunit to reference-repository
             codeunit_version = self.get_version_of_codeunit_folder(os.path.join(information.repository, codeunitname))
-            self.__export_codeunit_reference_content_to_reference_repository(f"v{project_version}", False, reference_folder, information.repository,                                                                             codeunitname, information.projectname, codeunit_version, information.public_repository_url,                                                                             f"v{project_version}")
-            self.__export_codeunit_reference_content_to_reference_repository("Latest", True, reference_folder, information.repository,                                                                             codeunitname, information.projectname, codeunit_version, information.public_repository_url,                                                                             information.target_branch_name)
+            self.__export_codeunit_reference_content_to_reference_repository(f"v{project_version}", False, reference_folder, information.repository, codeunitname, information.projectname, codeunit_version, information.public_repository_url,                                                                             f"v{project_version}")
+            self.__export_codeunit_reference_content_to_reference_repository("Latest", True, reference_folder, information.repository, codeunitname, information.projectname, codeunit_version, information.public_repository_url,                                                                             information.target_branch_name)
 
             # Generate reference
             self.__generate_entire_reference(information.projectname, project_version, reference_folder)
@@ -1092,8 +1092,7 @@ class TasksForCommonProjectStructure:
     @GeneralUtilities.check_arguments
     def push_nuget_build_artifact(self, push_script_file: str, codeunitname: str, registry_address: str, api_key: str, repository_folder_name: str):
         # when pusing to "default public" nuget-server then use registry_address: "nuget.org"
-        build_artifact_folder = GeneralUtilities.resolve_relative_path(
-            f"../../Submodules/{repository_folder_name}/{codeunitname}/Other/Artifacts/BuildResult_NuGet", os.path.dirname(push_script_file))
+        build_artifact_folder = GeneralUtilities.resolve_relative_path(f"../../Submodules/{repository_folder_name}/{codeunitname}/Other/Artifacts/BuildResult_NuGet", os.path.dirname(push_script_file))
         self.__sc.push_nuget_build_artifact(self.__sc.find_file_by_extension(build_artifact_folder, "nupkg"), registry_address, api_key)
 
     @GeneralUtilities.check_arguments
@@ -1101,18 +1100,40 @@ class TasksForCommonProjectStructure:
         if self.__sc.git_repository_has_uncommitted_changes(repository_folder):
             raise ValueError(f"Repository '{repository_folder}' has uncommitted changes.")
 
+    @GeneralUtilities.check_arguments
+    def ensure_certificate_authority_for_development_purposes_is_generated(self, script_file: str):
+        folder_of_current_file = os.path.dirname(script_file)
+        product_folder: str = GeneralUtilities.resolve_relative_path("../..", folder_of_current_file)
+        product_name: str = os.path.basename(product_folder)
+        now = datetime.now()
+        ca_name = f"{product_name}CA_{now.year:04}{now.month:02}{now.day:02}{now.hour:02}{now.min:02}{now.second:02}"
+        ca_folder = os.path.join(product_folder, "Other", "Resources", "CA")
+        generate_certificate = True
+        if os.path.isdir(ca_folder):
+            try:
+                ca_file = self.__sc.find_file_by_extension(ca_folder, "crt")  # pylint: disable=unused-variable
+                certificate_is_valid = True   # TODO check if certificate is not valid
+                generate_certificate = not certificate_is_valid
+            except FileNotFoundError:
+                pass
+        if generate_certificate:
+            self.__sc.generate_certificate_authority(ca_folder, ca_name, "DE", "SubjST", "SubjL", "SubjO", "SubjOU")
+
     @GeneralUtilities.check_arguments
     def generate_certificate_for_development_purposes_for_external_service(self, service_folder: str, domain: str = None):
         testservice_name = os.path.basename(service_folder)
-        self.__generate_certificate_for_development_purposes(testservice_name, os.path.join(service_folder,  "Resources"), domain)
+        ca_folder: str = None  # TODO
+        self.__generate_certificate_for_development_purposes(testservice_name, os.path.join(service_folder, "Resources"), ca_folder, domain)
 
     @GeneralUtilities.check_arguments
     def generate_certificate_for_development_purposes_for_codeunit(self, codeunit_folder: str, domain: str = None):
         codeunit_name = os.path.basename(codeunit_folder)
-        self.__generate_certificate_for_development_purposes(codeunit_name, os.path.join(codeunit_folder, "Other", "Resources"), domain)
+        self.ensure_product_resource_is_imported(codeunit_folder, "CA")
+        ca_folder: str = os.path.join(codeunit_folder, "Other", "Resources", "CA")
+        self.__generate_certificate_for_development_purposes(codeunit_name, os.path.join(codeunit_folder, "Other", "Resources"), ca_folder, domain)
 
     @GeneralUtilities.check_arguments
-    def __generate_certificate_for_development_purposes(self, service_name: str, resources_folder: str, domain: str = None):
+    def __generate_certificate_for_development_purposes(self, service_name: str, resources_folder: str, ca_folder: str, domain: str = None):
         if domain is None:
             domain = f"{service_name}.test.local"
         domain = domain.lower()
@@ -1120,9 +1141,6 @@ class TasksForCommonProjectStructure:
         certificate_folder: str = os.path.join(resources_folder, resource_name)
 
         resource_content_filename: str = service_name+resource_name
-        ca_resource_name: str = f"{resource_name}Authority"
-        dev_ca_name = service_name+ca_resource_name
-        ca_folder = os.path.join(resources_folder, ca_resource_name)
         certificate_file = os.path.join(certificate_folder, f"{domain}.crt")
         unsignedcertificate_file = os.path.join(certificate_folder, f"{domain}.unsigned.crt")
         certificate_exists = os.path.exists(certificate_file)
@@ -1134,15 +1152,22 @@ class TasksForCommonProjectStructure:
         if generate_new_certificate:
             GeneralUtilities.ensure_directory_does_not_exist(certificate_folder)
             GeneralUtilities.ensure_directory_exists(certificate_folder)
-            GeneralUtilities.ensure_directory_does_not_exist(ca_folder)
-            GeneralUtilities.ensure_directory_exists(ca_folder)
             GeneralUtilities.write_message_to_stdout("Generate TLS-certificate for development-purposes.")
-            self.__sc.generate_certificate_authority(ca_folder, dev_ca_name, "DE", "SubjST", "SubjL", "SubjO", "SubjOU")
             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")
-            self.__sc.sign_certificate(certificate_folder, ca_folder, dev_ca_name, domain, resource_content_filename)
+            ca_name = os.path.basename(self.__sc.find_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)
 
+    @GeneralUtilities.check_arguments
+    def ensure_product_resource_is_imported(self, codeunit_folder: str, product_resource_name: str) -> None:
+        product_folder = os.path.dirname(codeunit_folder)
+        source_folder = os.path.join(product_folder, "Other", "Resources", product_resource_name)
+        target_folder = os.path.join(codeunit_folder, "Other", "Resources", product_resource_name)
+        GeneralUtilities.ensure_directory_does_not_exist(target_folder)
+        GeneralUtilities.ensure_directory_exists(target_folder)
+        GeneralUtilities.copy_content_of_folder(source_folder, target_folder)
+
     @GeneralUtilities.check_arguments
     def get_codeunits(self, repository_folder: str, ignore_disabled_codeunits: bool = True) -> list[str]:
         result: list[str] = []
@@ -1219,8 +1244,7 @@ class TasksForCommonProjectStructure:
         # hint: arguments can be overwritten by commandline_arguments
         folder_of_this_file = os.path.dirname(create_release_file)
         verbosity = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(commandline_arguments, verbosity)
-        self.__sc.run_program("python", f"CreateRelease.py --overwrite_verbosity {str(verbosity)}",
-                              folder_of_this_file,  verbosity=verbosity, log_file=logfile, addLogOverhead=addLogOverhead)
+        self.__sc.run_program("python", f"CreateRelease.py --overwrite_verbosity {str(verbosity)}", folder_of_this_file,  verbosity=verbosity, log_file=logfile, addLogOverhead=addLogOverhead)
 
     @GeneralUtilities.check_arguments
     def __standardized_tasks_merge_to_stable_branch(self, information: MergeToStableBranchInformationForProjectInCommonProjectFormat) -> str:
@@ -1367,7 +1391,7 @@ class TasksForCommonProjectStructure:
 
         # Check codeunit-conformity
         # TODO check if foldername=="<codeunitname>[.codeunit.xml]" == <codeunitname> in file
-        supported_codeunitspecificationversion = "2.7.10"  # should always be the latest version of the ProjectTemplates-repository
+        supported_codeunitspecificationversion = "2.8.0"  # should always be the latest version of the ProjectTemplates-repository
         codeunit_file = os.path.join(codeunit_folder, f"{codeunit_name}.codeunit.xml")
         if not os.path.isfile(codeunit_file):
             raise ValueError(f'Codeunitfile "{codeunit_file}" does not exist.')
@@ -1383,6 +1407,7 @@ class TasksForCommonProjectStructure:
                 raise ValueError(f"ScriptCollection only supports processing codeunits with codeunit-specification-version={supported_codeunitspecificationversion}.")
             schemaLocation = root.xpath('//cps:codeunit/@xsi:schemaLocation', namespaces=namespaces)[0]
             xmlschema.validate(codeunit_file, schemaLocation)
+            # TODO check if the properties codeunithastestablesourcecode, codeunithasupdatabledependencies, throwexceptionifcodeunitfilecannotbevalidated, developmentState and description exist and the values are valid
         except Exception as exception:
             if self.codeunit_throws_exception_if_codeunitfile_is_not_validatable(codeunit_file):
                 raise exception
@@ -1398,8 +1423,10 @@ class TasksForCommonProjectStructure:
         # Check for mandatory files
         files = ["Other/Build/Build.py", "Other/QualityCheck/Linting.py", "Other/Reference/GenerateReference.py"]
         if self.codeunit_has_testable_sourcecode(codeunit_file):
+            # TODO check if the testsettings-section appears in the codeunit-file
             files.append("Other/QualityCheck/RunTestcases.py")
         if self.codeunit_has_updatable_dependencies(codeunit_file):
+            # TODO check if the updatesettings-section appears in the codeunit-file
             files.append("Other/UpdateDependencies.py")
         for file in files:
             combined_file = os.path.join(codeunit_folder, file)
@@ -1494,7 +1521,7 @@ class TasksForCommonProjectStructure:
         build_script_folder = os.path.dirname(build_script_file)
         codeunit_folder = GeneralUtilities.resolve_relative_path("../..", build_script_folder)
         GeneralUtilities.ensure_directory_does_not_exist(f"{codeunit_folder}/.angular")
-        self.standardized_tasks_build_for_angular_codeunit(build_script_file, build_environment_target_type, verbosity, commandline_arguments)
+        self.standardized_tasks_build_for_node_codeunit(build_script_file, build_environment_target_type, verbosity, commandline_arguments)
 
     @GeneralUtilities.check_arguments
     def standardized_tasks_build_for_node_codeunit(self, build_script_file: str, build_environment_target_type: str, verbosity: int, commandline_arguments: list[str]) -> None:
@@ -1845,17 +1872,33 @@ class TasksForCommonProjectStructure:
         for codeunit in codeunits:
             artifact_files.append(self.__sc.find_file_by_extension(f"{build_artifacts_folder}\\{productname}\\{projectversion}\\{codeunit}", "Productive.Artifacts.zip"))
         changelog_file = os.path.join(repository_folder, "Other", "Resources", "Changelog", f"v{projectversion}.md")
-        self.__sc.run_program_argsasarray("gh", ["release", "create", f"v{projectversion}", "--repo",  github_repo,  "--notes-file", changelog_file, "--title", f"Release v{projectversion}"]+artifact_files, verbosity=verbosity)
+        self.__sc.run_program_argsasarray("gh", ["release", "create", f"v{projectversion}", "--repo",  github_repo, "--notes-file", changelog_file, "--title", f"Release v{projectversion}"]+artifact_files, verbosity=verbosity)
+
+    @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'}
+        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)
+        ignoreddependencies = root.xpath('//cps:codeunit/cps:properties/cps:updatesettings/cps:ignoreddependencies/cps:ignoreddependency', namespaces=namespaces)
+        result = [x.text.replace("\\n", "").replace("\\r", "").replace("\n", "").replace("\r", "").strip() for x in ignoreddependencies]
+        if print_warnings_for_ignored_dependencies and len(result > 0):
+            GeneralUtilities.write_message_to_stderr(f"Warning: Codeunit {codeunit_name} contains the following dependencies which will are ignoed for automatic updates: "+', '.join(result))
+        return result
 
     @GeneralUtilities.check_arguments
     def update_dependencies_of_typical_flutter_codeunit(self, update_script_file: str, verbosity: int, cmd_args: list[str]) -> None:
-        pass  # TODO generalize and add option to ignore certain dependencies
+        codeunit_folder = GeneralUtilities.resolve_relative_path("..", os.path.dirname(update_script_file))
+        ignored_dependencies = self.get_dependencies_which_are_ignored_from_updates(codeunit_folder, True)
+        # TODO implement
 
     @GeneralUtilities.check_arguments
     def update_dependencies_of_typical_python_codeunit(self, update_script_file: str, verbosity: int, cmd_args: list[str]) -> None:
-        # TODO generalize and add option to ignore certain dependencies and to only update patch-versions
-        verbosity = self.get_verbosity_from_commandline_arguments(cmd_args, verbosity)
         codeunit_folder = GeneralUtilities.resolve_relative_path("..", os.path.dirname(update_script_file))
+        ignored_dependencies = self.get_dependencies_which_are_ignored_from_updates(codeunit_folder, True)
+        # TODO consider ignored_dependencies
+        verbosity = self.get_verbosity_from_commandline_arguments(cmd_args, verbosity)
         self.__sc.update_dependencies_of_python_in_setupcfg_file(os.path.join(codeunit_folder, "setup.cfg"), verbosity)
         development_requirements_file = os.path.join(codeunit_folder, "requirements.txt")
         if (os.path.isfile(development_requirements_file)):
@@ -1863,22 +1906,25 @@ class TasksForCommonProjectStructure:
 
     @GeneralUtilities.check_arguments
     def update_dependencies_of_typical_dotnet_codeunit(self, update_script_file: str, verbosity: int, cmd_args: list[str]) -> None:
-        # TODO generalize and add option to ignore certain dependencies
-        verbosity = self.get_verbosity_from_commandline_arguments(cmd_args, verbosity)
         codeunit_folder = GeneralUtilities.resolve_relative_path("..", os.path.dirname(update_script_file))
+        ignored_dependencies = self.get_dependencies_which_are_ignored_from_updates(codeunit_folder, True)
+        verbosity = self.get_verbosity_from_commandline_arguments(cmd_args, verbosity)
         codeunit_name = os.path.basename(codeunit_folder)
 
         build_folder = os.path.join(codeunit_folder, "Other", "Build")
         self.__sc.run_program("python", "Build.py", build_folder, verbosity)
 
         csproj_file = os.path.join(codeunit_folder, codeunit_name, f"{codeunit_name}.csproj")
-        self.__sc.update_dependencies_of_dotnet_project(csproj_file, verbosity)
+        self.__sc.update_dependencies_of_dotnet_project(csproj_file, verbosity, ignored_dependencies)
         test_csproj_file = os.path.join(codeunit_folder, f"{codeunit_name}Tests", f"{codeunit_name}Tests.csproj")
-        self.__sc.update_dependencies_of_dotnet_project(test_csproj_file, verbosity)
+        self.__sc.update_dependencies_of_dotnet_project(test_csproj_file, verbosity, ignored_dependencies)
 
     @GeneralUtilities.check_arguments
     def update_dependencies_of_typical_node_codeunit(self, update_script_file: str, verbosity: int, cmd_args: list[str]) -> None:
         current_folder = os.path.dirname(update_script_file)
+        codeunit_folder = GeneralUtilities.resolve_relative_path("..", os.path.dirname(update_script_file))
+        ignored_dependencies = self.get_dependencies_which_are_ignored_from_updates(codeunit_folder, True)
+        # TODO consider ignored_dependencies
         result = self.run_with_epew("npm", "outdated", current_folder, verbosity, throw_exception_if_exitcode_is_not_zero=False)
         if result[0] == 0:
             return  # all dependencies up to date
@@ -1963,9 +2009,9 @@ class TasksForCommonProjectStructure:
     @GeneralUtilities.check_arguments
     def create_artifact_for_development_certificate(self, codeunit_folder: str):
         ce_source_folder = GeneralUtilities.resolve_relative_path("Other/Resources/DevelopmentCertificate", codeunit_folder)
-        ca_source_folder = GeneralUtilities.resolve_relative_path("Other/Resources/DevelopmentCertificateAuthority", 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)
-        ca_target_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts/DevelopmentCertificateAuthority", codeunit_folder)
+        ca_target_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts/A", codeunit_folder)
 
         GeneralUtilities.ensure_directory_exists(ce_target_folder)
         GeneralUtilities.copy_content_of_folder(ce_source_folder, ce_target_folder)
@@ -2006,8 +2052,7 @@ class TasksForCommonProjectStructure:
         # TODO handle additional_arguments_file
         # TODO add option to allow building different codeunits in same project with different images due to their demands
         # TODO check if image provides all demands of codeunit
-        self.__sc.run_program(
-            "docker", f"run --volume {repository_folder}:/Workspace/Repository " + f"-e repositoryfolder=/Workspace/Repository -e verbosity={verbosity} -e targetenvironment={target_environmenttype} {image}", repository_folder)
+        self.__sc.run_program("docker", f"run --volume {repository_folder}:/Workspace/Repository " + f"-e repositoryfolder=/Workspace/Repository -e verbosity={verbosity} -e targetenvironment={target_environmenttype} {image}", repository_folder)
 
     @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] = []) -> None:
@@ -2025,6 +2070,14 @@ class TasksForCommonProjectStructure:
             raise ValueError(f'Repository "{repository_folder}" has uncommitted changes.')
         subfolders = [os.path.join(repository_folder, codeunit) for codeunit in codeunits]
         codeunits_with_dependent_codeunits: dict[str, set[str]] = dict[str, set[str]]()
+
+        project_resources_folder = os.path.join(repository_folder, "Other", "Scripts")
+        PrepareBuildCodeunits_script_name = "PrepareBuildCodeunits.py"
+        prepare_build_codeunits_scripts = os.path.join(project_resources_folder, PrepareBuildCodeunits_script_name)
+        if os.path.isfile(prepare_build_codeunits_scripts):
+            GeneralUtilities.write_message_to_stdout(f'Run "{PrepareBuildCodeunits_script_name}"')
+            self.__sc.run_program("python", f"{PrepareBuildCodeunits_script_name}", project_resources_folder)
+
         for subfolder in subfolders:
             codeunit_name: str = os.path.basename(subfolder)
             codeunit_file = os.path.join(subfolder, f"{codeunit_name}.codeunit.xml")
@@ -2250,7 +2303,7 @@ class TasksForCommonProjectStructure:
         deb_output_folder = GeneralUtilities.resolve_relative_path("Other/Artifacts/BuildResult_Deb", codeunit_folder)
         control_file = GeneralUtilities.resolve_relative_path("Other/Build/DebControlFile.txt", codeunit_folder)
         installedsize = self.calculate_deb_package_size(binary_folder)
-        control_file_content = self.load_deb_control_file_content(control_file, codeunit_name, self.get_version_of_codeunit_folder(codeunit_folder),                                                                  installedsize, maintainername, maintaineremail, description)
+        control_file_content = self.load_deb_control_file_content(control_file, codeunit_name, self.get_version_of_codeunit_folder(codeunit_folder), installedsize, maintainername, maintaineremail, description)
         self.__sc.create_deb_package(codeunit_name, binary_folder, control_file_content, deb_output_folder, verbosity, 555)
 
     @GeneralUtilities.check_arguments
@@ -2425,6 +2478,7 @@ class TasksForCommonProjectStructure:
                 GeneralUtilities.ensure_directory_exists(os.path.join(update_dependencies_script_folder, "Resources", "CodeAnalysisResult"))
                 self.__sc.run_program("python", "UpdateDependencies.py", update_dependencies_script_folder, verbosity)
                 if self.__sc.git_repository_has_uncommitted_changes(repository_folder):
+                    updated_dependencies = True
                     version_of_project = self.get_version_of_project(repository_folder)
                     changelog_file = os.path.join(repository_folder, "Other", "Resources", "Changelog", f"v{version_of_project}.md")
                     if not os.path.isfile(changelog_file):
@@ -2435,7 +2489,6 @@ class TasksForCommonProjectStructure:
 - Updated dependencies.
 """)
                         GeneralUtilities.write_message_to_stdout(f"Updated dependencies in codeunit {codeunit}.")
-                    updated_dependencies = True
                 else:
                     GeneralUtilities.write_message_to_stdout(f"There are no dependencies to update in codeunit {codeunit}.")
         if updated_dependencies:
@@ -2461,15 +2514,26 @@ class TasksForCommonProjectStructure:
 
         repository_folder = GeneralUtilities.resolve_relative_path(f"../../Submodules/{generic_prepare_new_release_arguments.product_name}", folder_of_this_file)
         verbosity: int = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(generic_prepare_new_release_arguments.commandline_arguments, 1)
-        merge_source_branch = "other/next-release"
+
+        merge_source_branch = "other/next-release"  # TODO make this configurable
+        main_branch = "main"  # TODO make this configurable
 
         # prepare
         self.assert_no_uncommitted_changes(repository_folder)
         self.__sc.git_checkout(repository_folder, merge_source_branch)
+        self.assert_no_uncommitted_changes(repository_folder)
+
         if "--dependencyupdate" in generic_prepare_new_release_arguments.commandline_arguments:
             self.generic_update_dependencies(repository_folder)
-        self.merge_to_main_branch(repository_folder, merge_source_branch, verbosity=verbosity, fast_forward_source_branch=True)
-        self.__sc.git_commit(build_repository_folder, "Updated submodule due to merge to main-branch.")
+            self.assert_no_uncommitted_changes(repository_folder)
+
+        merge_source_branch_commit_id = self.__sc.git_get_commit_id(repository_folder, merge_source_branch)
+        main_branch_commit_id = self.__sc.git_get_commit_id(repository_folder, main_branch)
+        if merge_source_branch_commit_id == main_branch_commit_id:
+            GeneralUtilities.write_message_to_stdout("Release will not be prepared because there are no changed which can be released.")
+        else:
+            self.merge_to_main_branch(repository_folder, merge_source_branch, verbosity=verbosity, fast_forward_source_branch=True)
+            self.__sc.git_commit(build_repository_folder, "Updated submodule due to merge to main-branch.")
 
     class GenericCreateReleaseArguments():
         current_file: str
@@ -2486,28 +2550,33 @@ class TasksForCommonProjectStructure:
             self.commandline_arguments = commandline_arguments
 
     @GeneralUtilities.check_arguments
-    def generic_create_release(self, generic_create_release_arguments: GenericCreateReleaseArguments) -> str:
+    def generic_create_release(self, generic_create_release_arguments: GenericCreateReleaseArguments) -> tuple[bool, str]:
         folder_of_this_file = os.path.dirname(generic_create_release_arguments.current_file)
         build_repository_folder = GeneralUtilities.resolve_relative_path("../..", folder_of_this_file)
         repository_folder_name = generic_create_release_arguments.product_name
         repository_folder = GeneralUtilities.resolve_relative_path(f"../../Submodules/{generic_create_release_arguments.product_name}", folder_of_this_file)
-        additional_arguments_file = os.path.join(folder_of_this_file, "AdditionalArguments.configuration")
-        verbosity: int = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(generic_create_release_arguments.commandline_arguments, 1)
-        createReleaseConfiguration: CreateReleaseConfiguration = CreateReleaseConfiguration(
-            generic_create_release_arguments.product_name, generic_create_release_arguments.common_remote_name, generic_create_release_arguments.artifacts_target_folder, folder_of_this_file, verbosity, repository_folder, additional_arguments_file, repository_folder_name)
-
-        reference_repo: str = os.path.join(build_repository_folder, "Submodules", f"{generic_create_release_arguments.product_name}Reference")
-        self.__sc.git_commit(reference_repo, "Updated reference")
-
-        self.__sc.git_commit(build_repository_folder, "Updated submodule")
 
-        # create release
-        new_version = self.merge_to_stable_branch(generic_create_release_arguments.current_file, createReleaseConfiguration)
+        merge_source_branch = "main"  # TODO make this configurable
+        main_branch = "stable"  # TODO make this configurable
 
-        merge_source_branch = "other/next-release"
-        self.__sc.git_checkout(repository_folder, merge_source_branch)
+        additional_arguments_file = os.path.join(folder_of_this_file, "AdditionalArguments.configuration")
+        verbosity: int = TasksForCommonProjectStructure.get_verbosity_from_commandline_arguments(generic_create_release_arguments.commandline_arguments, 1)
+        createReleaseConfiguration: CreateReleaseConfiguration = CreateReleaseConfiguration(generic_create_release_arguments.product_name, generic_create_release_arguments.common_remote_name, generic_create_release_arguments.artifacts_target_folder, folder_of_this_file, verbosity, repository_folder, additional_arguments_file, repository_folder_name)
 
-        return new_version
+        merge_source_branch_commit_id = self.__sc.git_get_commit_id(repository_folder, merge_source_branch)
+        main_branch_commit_id = self.__sc.git_get_commit_id(repository_folder, main_branch)
+        if merge_source_branch_commit_id == main_branch_commit_id:
+            GeneralUtilities.write_message_to_stdout("Release will not be done because there are no changed which can be released.")
+            return False, None
+        else:
+            reference_repo: str = os.path.join(build_repository_folder, "Submodules", f"{generic_create_release_arguments.product_name}Reference")
+            self.__sc.git_commit(reference_repo, "Updated reference")
+            self.__sc.git_commit(build_repository_folder, "Updated submodule")
+
+            # create release
+            new_version = self.merge_to_stable_branch(generic_create_release_arguments.current_file, createReleaseConfiguration)
+            self.__sc.git_checkout(repository_folder, merge_source_branch)
+            return True, new_version
 
     class UpdateHTTPDocumentationArguments:
         current_file: str

{ScriptCollection-3.5.5.dist-info → ScriptCollection-3.5.8.dist-info}/METADATA

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

{ScriptCollection-3.5.5.dist-info → ScriptCollection-3.5.8.dist-info}/RECORD

@@ -5,12 +5,12 @@ ScriptCollection/ProgramRunnerBase.py,sha256=W4MaDroJHARRtcvPkBC2AS_qgDSRIqOkMvG
 ScriptCollection/ProgramRunnerEpew.py,sha256=lx_jR3W8KavBpZo44u2FrOca_EWWgUb3_w_YKGRrAyM,6471
 ScriptCollection/ProgramRunnerPopen.py,sha256=5QFplojwfGS8_WdYrg5nE6__QFB5iaMA0EP8OGfgPoY,3526
 ScriptCollection/RPStream.py,sha256=NRRHL3YSP3D9MuAV2jB_--0KUKCsvJGxeKnxgrRZ9kY,1545
-ScriptCollection/ScriptCollectionCore.py,sha256=2HgYhQ22DDDs9s1Qjuvd7fKUWsOPrnaYSoHimWbC_ow,97054
-ScriptCollection/TasksForCommonProjectStructure.py,sha256=kz6AZENxwC7oYJp3Neuhs-oLbyXkn-p0j-2AQ6fHBMA,181486
+ScriptCollection/ScriptCollectionCore.py,sha256=muGC1Xd3xbBU8ZkIocvnE4_5IJd8mfHdE2b4fwzBGB4,97508
+ScriptCollection/TasksForCommonProjectStructure.py,sha256=jExRHYZQfRJWY4NDboREI1NfYjHMvIabsKZ05qi8DoA,186707
 ScriptCollection/UpdateCertificates.py,sha256=lfmVuify-Fqq-vGJusDDUsJVhA-rVLwW2Jx9iLwmkBo,7916
 ScriptCollection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ScriptCollection-3.5.5.dist-info/METADATA,sha256=K1hVO826FAyAgMcqSqTxuf1lJ3F_Y4rIQbQ7QVffMQg,7679
-ScriptCollection-3.5.5.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
-ScriptCollection-3.5.5.dist-info/entry_points.txt,sha256=dwvB9HRGvqst5xlYIGmmwuFN7lBKhxvndmnNrQOfu8w,2153
-ScriptCollection-3.5.5.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
-ScriptCollection-3.5.5.dist-info/RECORD,,
+ScriptCollection-3.5.8.dist-info/METADATA,sha256=Ek02QzQWx7ZT6xSxEDI8TvGBhUFCRdb735Xj6BjIveE,7679
+ScriptCollection-3.5.8.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+ScriptCollection-3.5.8.dist-info/entry_points.txt,sha256=dwvB9HRGvqst5xlYIGmmwuFN7lBKhxvndmnNrQOfu8w,2153
+ScriptCollection-3.5.8.dist-info/top_level.txt,sha256=hY2hOVH0V0Ce51WB76zKkIWTUNwMUdHo4XDkR2vYVwg,17
+ScriptCollection-3.5.8.dist-info/RECORD,,