scriptcollection 4.2.81__py3-none-any.whl

ScriptCollection/TFCPS/Flutter/TFCPS_CodeUnitSpecific_Flutter.py

@@ -0,0 +1,137 @@
+import os
+import shutil
+import re
+import zipfile
+from ...GeneralUtilities import GeneralUtilities
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_Flutter_Functions(TFCPS_CodeUnitSpecific_Base):
+ 
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool,is_pre_merge:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache,is_pre_merge)
+
+
+    @GeneralUtilities.check_arguments
+    def build(self,package_name:str,targets:list[str]) -> None:
+        codeunit_folder = self.get_codeunit_folder()
+        codeunit_name = os.path.basename(codeunit_folder)
+        src_folder: str = None
+        if package_name is None:
+            src_folder = codeunit_folder
+        else:
+            src_folder = GeneralUtilities.resolve_relative_path(package_name, codeunit_folder) # TODO replace packagename
+        artifacts_folder = os.path.join(codeunit_folder, "Other", "Artifacts")
+        
+        target_names: dict[str, str] = {
+            "web": "WebApplication",
+            "windows": "Windows",
+            "ios": "IOS",
+            "appbundle": "Android",
+        }
+        for target in targets:
+            self._protected_sc.log.log(f"Build flutter-codeunit {codeunit_name} for target {target_names[target]}...")
+            self._protected_sc.run_with_epew("flutter", f"build {target}", src_folder)
+            if target == "web":
+                web_relase_folder = os.path.join(src_folder, "build/web")
+                web_folder = os.path.join(artifacts_folder, "BuildResult_WebApplication")
+                GeneralUtilities.ensure_directory_does_not_exist(web_folder)
+                GeneralUtilities.ensure_directory_exists(web_folder)
+                GeneralUtilities.copy_content_of_folder(web_relase_folder, web_folder)
+            elif target == "windows":
+                enabled=False
+                if enabled:#TODO move to external because this is not platform indepent
+                    windows_release_folder = os.path.join(src_folder, "build/windows/x64/runner/Release")
+                    windows_folder = os.path.join(artifacts_folder, "BuildResult_Windows")
+                    GeneralUtilities.ensure_directory_does_not_exist(windows_folder)
+                    GeneralUtilities.ensure_directory_exists(windows_folder)
+                    GeneralUtilities.copy_content_of_folder(windows_release_folder, windows_folder)
+            elif target == "ios":
+                enabled=False
+                if enabled:#TODO move to external because this is not platform indepent
+                    raise ValueError("building for ios is not implemented yet")
+            elif target == "appbundle":
+                enabled=False
+                if enabled:#TODO move to external because this is not platform indepent
+                    aab_folder = os.path.join(artifacts_folder, "BuildResult_AAB")
+                    GeneralUtilities.ensure_directory_does_not_exist(aab_folder)
+                    GeneralUtilities.ensure_directory_exists(aab_folder)
+                    aab_relase_folder = os.path.join(src_folder, "build/app/outputs/bundle/release")
+                    aab_file_original = self._protected_sc.find_file_by_extension(aab_relase_folder, "aab")
+                    aab_file = os.path.join(aab_folder, f"{codeunit_name}.aab")
+                    shutil.copyfile(aab_file_original, aab_file)
+                    
+                    bundletool = self.tfcps_Tools_General.ensure_androidappbundletool_is_available(None,self.use_cache())
+                    apk_folder = os.path.join(artifacts_folder, "BuildResult_APK")
+                    GeneralUtilities.ensure_directory_does_not_exist(apk_folder)
+                    GeneralUtilities.ensure_directory_exists(apk_folder)
+                    apks_file = f"{apk_folder}/{codeunit_name}.apks"
+                    self._protected_sc.run_program("java", f"-jar {bundletool} build-apks --bundle={aab_file} --output={apks_file} --mode=universal", aab_relase_folder)
+                    with zipfile.ZipFile(apks_file, "r") as zip_ref:
+                        zip_ref.extract("universal.apk", apk_folder)
+                    GeneralUtilities.ensure_file_does_not_exist(apks_file)
+                    os.rename(f"{apk_folder}/universal.apk", f"{apk_folder}/{codeunit_name}.apk")
+            else:
+                raise ValueError(f"Not supported target: {target}")
+        self.copy_source_files_to_output_directory()
+
+    @GeneralUtilities.check_arguments
+    def linting(self) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def do_common_tasks(self,current_codeunit_version:str )-> None:
+        self.do_common_tasks_base(current_codeunit_version)
+
+    @GeneralUtilities.check_arguments
+    def generate_reference(self) -> None:
+        self.generate_reference_using_docfx()
+
+    
+    @GeneralUtilities.check_arguments
+    def run_testcases(self,package_name:str) -> None:
+        codeunit_folder = self.get_codeunit_folder()
+        repository_folder = GeneralUtilities.resolve_relative_path("..", codeunit_folder)
+        codeunit_name = os.path.basename(codeunit_folder)
+        src_folder = GeneralUtilities.resolve_relative_path(package_name, codeunit_folder)
+        
+        self._protected_sc.run_with_epew("flutter", "test --coverage", src_folder)
+        test_coverage_folder_relative = "Other/Artifacts/TestCoverage"
+        test_coverage_folder = GeneralUtilities.resolve_relative_path(test_coverage_folder_relative, codeunit_folder)
+        GeneralUtilities.ensure_directory_exists(test_coverage_folder)
+        coverage_file_relative = f"{test_coverage_folder_relative}/TestCoverage.xml"
+        coverage_file = GeneralUtilities.resolve_relative_path(coverage_file_relative, codeunit_folder)
+        self._protected_sc.run_with_epew("lcov_cobertura", f"coverage/lcov.info --base-dir . --excludes test --output ../{coverage_file_relative} --demangle", src_folder)
+
+        # format correctly
+        content = GeneralUtilities.read_text_from_file(coverage_file)
+        content = re.sub('<![^<]+>', '', content)
+        content = re.sub('\\\\', '/', content)
+        content = re.sub('\\ name=\\"lib\\"', '', content)
+        content = re.sub('\\ filename=\\"lib/', f' filename="{package_name}/lib/', content)
+        GeneralUtilities.write_text_to_file(coverage_file, content)
+        self.tfcps_Tools_General.merge_packages(coverage_file, self.get_codeunit_name())
+        self.tfcps_Tools_General.calculate_entire_line_rate(coverage_file)
+        self.run_testcases_common_post_task(repository_folder, codeunit_name, True, self.get_target_environment_type())
+    
+    
+    def get_dependencies(self)->dict[str,set[str]]:
+        return dict[str,set[str]]()#TODO
+    
+    @GeneralUtilities.check_arguments
+    def get_available_versions(self,dependencyname:str)->list[str]:
+        return []#TODO
+    
+    def set_dependency_version(self,name:str,new_version:str)->None:
+        raise ValueError(f"Operation is not implemented.")
+    
+class TFCPS_CodeUnitSpecific_Flutter_CLI:
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def parse(file:str)->TFCPS_CodeUnitSpecific_Flutter_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_Flutter_Functions=TFCPS_CodeUnitSpecific_Flutter_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache,args.ispremerge)
+        return result

ScriptCollection/TFCPS/Go/TFCPS_CodeUnitSpecific_Go.py

@@ -0,0 +1,72 @@
+import os
+from lxml import etree
+from ...GeneralUtilities import GeneralUtilities
+from ...ScriptCollectionCore import ScriptCollectionCore
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_Go_Functions(TFCPS_CodeUnitSpecific_Base):
+
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool,is_pre_merge:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache,is_pre_merge)
+
+    @GeneralUtilities.check_arguments
+    def build(self) -> None:
+        #TODO
+        self.__generate_sbom_for_go_image()
+
+    @GeneralUtilities.check_arguments
+    def __generate_sbom_for_go_image(self) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def linting(self) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def __update_coverage_file(self,coverage_file:str) -> None:
+        tree = etree.parse(coverage_file)
+        root = tree.getroot()
+        for package in root.findall(".//package"):
+            package.set("name",self.get_codeunit_name())
+        for cls in root.findall(".//class"):
+            filename = cls.get("filename")
+            if filename:
+                cls.set("filename", f"./{filename}")
+            cls.set("name",str(filename).rsplit("/", 1)[-1])
+        tree.write(coverage_file, encoding="utf-8", xml_declaration=True, pretty_print=True)
+
+    @GeneralUtilities.check_arguments
+    def run_testcases(self) -> None:
+        test_coverage_folder = os.path.join(self.get_codeunit_folder(), "Other", "Artifacts", "TestCoverage").replace("\\", "/")
+        GeneralUtilities.ensure_directory_exists(test_coverage_folder)
+        src_folder = GeneralUtilities.resolve_relative_path(self.get_codeunit_name(), self.get_codeunit_folder())
+        sc: ScriptCollectionCore = ScriptCollectionCore()
+        sc.run_program_argsasarray("go", ["install", "github.com/t-yuki/gocover-cobertura@latest"], src_folder)
+        sc.run_program_argsasarray("go", ["test", "-coverprofile=coverage.out", "./..."], src_folder)
+        coverage_file:str=f"{test_coverage_folder}/TestCoverage.xml"
+        sc.run_program_argsasarray("sh", ["-c", f"gocover-cobertura < coverage.out > {coverage_file}"], src_folder)
+        self.__update_coverage_file(coverage_file)
+        self.run_testcases_common_post_task(self.get_repository_folder(),self.get_codeunit_name(),True,self.get_type_environment_type())
+
+    def get_dependencies(self)->dict[str,set[str]]:
+        return dict[str,set[str]]()#TODO
+    
+    @GeneralUtilities.check_arguments
+    def get_available_versions(self,dependencyname:str)->list[str]:
+        return []#TODO
+    
+    @GeneralUtilities.check_arguments
+    def set_dependency_version(self,name:str,new_version:str)->None:
+        raise ValueError(f"Operation is not implemented.")
+    
+class TFCPS_CodeUnitSpecific_Go_CLI:
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def parse(file:str)->TFCPS_CodeUnitSpecific_Go_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_Go_Functions=TFCPS_CodeUnitSpecific_Go_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache,args.ispremerge)
+        return result

ScriptCollection/TFCPS/Maven/TFCPS_CodeUnitSpecific_Maven.py

@@ -0,0 +1,42 @@
+from ...GeneralUtilities import GeneralUtilities
+from ...SCLog import LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base, TFCPS_CodeUnitSpecific_Base_CLI
+
+class TFCPS_CodeUnitSpecific_Maven_Functions(TFCPS_CodeUnitSpecific_Base):
+
+    def __init__(self, current_file: str, verbosity: LogLevel, targetenvironmenttype: str, use_cache: bool, is_pre_merge: bool):
+        super().__init__(current_file, verbosity, targetenvironmenttype, use_cache, is_pre_merge)
+
+    @GeneralUtilities.check_arguments
+    def build(self) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def linting(self) -> None:
+        pass#TODO
+
+    @GeneralUtilities.check_arguments
+    def run_testcases(self) -> None:
+        pass#TODO
+
+    def get_dependencies(self) -> dict[str, set[str]]:
+        return dict[str, set[str]]()#TODO
+
+    @GeneralUtilities.check_arguments
+    def get_available_versions(self, dependencyname: str) -> list[str]:
+        return []#TODO
+
+    @GeneralUtilities.check_arguments
+    def set_dependency_version(self, name: str, new_version: str) -> None:
+        raise ValueError("Operation is not implemented.")
+
+class TFCPS_CodeUnitSpecific_Maven_CLI:
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def parse(file: str) -> TFCPS_CodeUnitSpecific_Maven_Functions:
+        parser = TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args = parser.parse_args()
+        result: TFCPS_CodeUnitSpecific_Maven_Functions = TFCPS_CodeUnitSpecific_Maven_Functions(file, LogLevel(int(args.verbosity)), args.targetenvironmenttype, not args.nocache, args.ispremerge)
+        return result

ScriptCollection/TFCPS/NodeJS/TFCPS_CodeUnitSpecific_NodeJS.py

@@ -0,0 +1,232 @@
+import os
+import re
+import json
+from pathlib import Path
+import xml.etree.ElementTree as ET
+from lxml import etree
+from ...GeneralUtilities import GeneralUtilities
+from ...SCLog import  LogLevel
+from ..TFCPS_CodeUnitSpecific_Base import TFCPS_CodeUnitSpecific_Base,TFCPS_CodeUnitSpecific_Base_CLI
+from ...HTTPMaintenanceOverheadHelper import HTTPMaintenanceOverheadHelper
+
+class TFCPS_CodeUnitSpecific_NodeJS_Functions(TFCPS_CodeUnitSpecific_Base):
+
+
+    def __init__(self,current_file:str,verbosity:LogLevel,targetenvironmenttype:str,use_cache:bool,is_pre_merge:bool):
+        super().__init__(current_file, verbosity,targetenvironmenttype,use_cache,is_pre_merge)
+
+
+    @GeneralUtilities.check_arguments
+    def build(self) -> None:
+        self._protected_sc.run_with_epew("npm", "run build", self.get_codeunit_folder(),print_live_output=self.get_verbosity()==LogLevel.Debug,encode_argument_in_base64=True)
+        self.standardized_tasks_build_bom_for_node_project()
+        self.copy_source_files_to_output_directory()
+
+    @GeneralUtilities.check_arguments
+    def linting(self) -> None:
+        src_folder = os.path.join(self.get_codeunit_folder(), "src")
+        for file in GeneralUtilities.get_all_files_of_folder(src_folder):
+            if file.endswith(".html"):
+                self._protected_sc.format_html_file(file, os.path.basename(file) == "index.html")
+        self._protected_sc.run_with_epew("npm", "run lint", self.get_codeunit_folder(),print_live_output=self.get_verbosity()==LogLevel.Debug,encode_argument_in_base64=True)
+
+    @GeneralUtilities.check_arguments
+    def do_common_tasks(self,current_codeunit_version:str)-> None:
+        codeunit_version = current_codeunit_version
+        codeunit_folder = self.get_codeunit_folder()
+        self.do_common_tasks_base(current_codeunit_version)
+        self.tfcps_Tools_General.replace_version_in_packagejson_file(GeneralUtilities.resolve_relative_path("./package.json", codeunit_folder), codeunit_version)
+        self.tfcps_Tools_General.do_npm_install(codeunit_folder, True,self.use_cache())
+        #if generateAPIClientBase.generate_api_client():
+        #    generateAPIClientGenerate:GenerateAPIClientGenerate=generateAPIClientBase
+        #    self.tfcps_Tools_General.generate_api_client_from_dependent_codeunit_in_angular(codeunit_folder, generateAPIClientGenerate.name_of_api_providing_codeunit,generateAPIClientGenerate.generate_api_client)
+  
+    @GeneralUtilities.check_arguments
+    def generate_reference(self) -> None:
+        self.generate_reference_using_docfx()
+
+    
+    @GeneralUtilities.check_arguments
+    def run_testcases(self) -> None:
+        # prepare
+        codeunit_name: str =self.get_codeunit_name()
+        
+        codeunit_folder =self.get_codeunit_folder()
+        repository_folder = os.path.dirname(codeunit_folder)
+
+        # run testcases
+        self._protected_sc.run_with_epew("npm", f"run test-{self.get_target_environment_type()}", self.get_codeunit_folder(),print_live_output=self.get_verbosity()==LogLevel.Debug,encode_argument_in_base64=True)
+
+        # rename file
+        coverage_folder = os.path.join(codeunit_folder, "Other", "Artifacts", "TestCoverage")
+        target_file = os.path.join(coverage_folder, "TestCoverage.xml")
+        GeneralUtilities.ensure_file_does_not_exist(target_file)
+        os.rename(os.path.join(coverage_folder, "cobertura-coverage.xml"), target_file)
+        self.__rename_packagename_in_coverage_file(target_file, codeunit_name)
+
+        # adapt backslashs to slashs
+        content = GeneralUtilities.read_text_from_file(target_file)
+        content = re.sub('\\\\', '/', content)
+        GeneralUtilities.write_text_to_file(target_file, content)
+
+        # aggregate packages in testcoverage-file
+        roottree: etree._ElementTree = etree.parse(target_file)
+        existing_classes = list(roottree.xpath('//coverage/packages/package/classes/class'))
+
+        old_packages_list = roottree.xpath('//coverage/packages/package')
+        for package in old_packages_list:
+            package.getparent().remove(package)
+
+        root = roottree.getroot()
+        packages_element = root.find("packages")
+        package_element = etree.SubElement(packages_element, "package")
+        package_element.attrib['name'] = codeunit_name
+        package_element.attrib['lines-valid'] = root.attrib["lines-valid"]
+        package_element.attrib['lines-covered'] = root.attrib["lines-covered"]
+        package_element.attrib['line-rate'] = root.attrib["line-rate"]
+        package_element.attrib['branches-valid'] = root.attrib["branches-valid"]
+        package_element.attrib['branches-covered'] = root.attrib["branches-covered"]
+        package_element.attrib['branch-rate'] = root.attrib["branch-rate"]
+        package_element.attrib['timestamp'] = root.attrib["timestamp"]
+        package_element.attrib['complexity'] = root.attrib["complexity"]
+
+        classes_element = etree.SubElement(package_element, "classes")
+
+        for existing_class in existing_classes:
+            classes_element.append(existing_class)
+
+        result = etree.tostring(roottree, pretty_print=True).decode("utf-8")
+        GeneralUtilities.write_text_to_file(target_file, result)
+
+        # post tasks
+        self.run_testcases_common_post_task(repository_folder, codeunit_name, True, self.get_target_environment_type())
+
+    @GeneralUtilities.check_arguments
+    def __rename_packagename_in_coverage_file(self, file: str, codeunit_name: str) -> None:
+        root: etree._ElementTree = etree.parse(file)
+        packages = root.xpath('//coverage/packages/package')
+        for package in packages:
+            package.attrib['name'] = codeunit_name
+        result = etree.tostring(root).decode("utf-8")
+        GeneralUtilities.write_text_to_file(file, result)
+
+
+    @GeneralUtilities.check_arguments 
+    def standardized_tasks_build_bom_for_node_project(self) -> None:
+        relative_path_to_bom_file = f"Other/Artifacts/BOM/{os.path.basename(self.get_codeunit_folder())}.{self.tfcps_Tools_General.get_version_of_codeunit(self.get_codeunit_file())}.sbom.xml"
+        self._protected_sc.run_with_epew("cyclonedx-npm", f"--output-format xml --output-file {relative_path_to_bom_file}", self.get_codeunit_folder(),print_live_output=self._protected_sc.log.loglevel==LogLevel.Diagnostic,encode_argument_in_base64=True)
+        self._protected_sc.format_xml_file(self.get_codeunit_folder()+"/"+relative_path_to_bom_file)
+
+    def get_dependencies(self)->dict[str,set[str]]:
+        return dict[str,set[str]]()#TODO
+    
+    @GeneralUtilities.check_arguments
+    def get_available_versions(self,dependencyname:str)->list[str]:
+        return []#TODO
+    
+    @GeneralUtilities.check_arguments
+    def set_dependency_version(self,name:str,new_version:str)->None:
+        raise ValueError(f"Operation is not implemented.")
+    
+    @GeneralUtilities.check_arguments
+    def add_culture_chooser(self,site_title:str,supported_cultures:list[str])->None:
+        output_folder=self.get_codeunit_folder()+"/Other/Artifacts/BuildResult_WebApplication/browser"
+        GeneralUtilities.assert_folder_exists(output_folder)
+        cc:HTTPMaintenanceOverheadHelper=HTTPMaintenanceOverheadHelper()
+
+        index_html_file=output_folder+"/index.html"
+        GeneralUtilities.ensure_file_exists(index_html_file)
+        index_html_content=cc.get_index_html(site_title)
+        GeneralUtilities.write_text_to_file(index_html_file, index_html_content)
+
+        cc_script_file=output_folder+"/CultureChooser.js"
+        GeneralUtilities.ensure_file_exists(cc_script_file)
+        cc_script_content=cc.get_culture_chooser_script(supported_cultures)
+        GeneralUtilities.write_text_to_file(cc_script_file, cc_script_content)
+    
+    @GeneralUtilities.check_arguments
+    def add_maintenance_site(self,site_title:str)->None:
+        output_folder_base=self.get_codeunit_folder()+"/Other/Artifacts/BuildResult_WebApplication"
+        GeneralUtilities.assert_folder_exists(output_folder_base)
+        output_folder=os.path.join(output_folder_base,"maintenance")
+        GeneralUtilities.ensure_directory_exists(output_folder)
+        cc:HTTPMaintenanceOverheadHelper=HTTPMaintenanceOverheadHelper()
+
+        maintenance_file=output_folder+"/MaintenanceSite.html"
+        GeneralUtilities.ensure_file_exists(maintenance_file)
+        maintenance_content=cc.get_maintenance_file(site_title)
+        GeneralUtilities.write_text_to_file(maintenance_file, maintenance_content)
+
+    
+    @GeneralUtilities.check_arguments
+    def get_available_cultures_for_angular_app(self)->None:
+        return self._protected_sc.get_available_cultures_for_angular_app(self.get_codeunit_folder()+"/angular.json")
+
+    @GeneralUtilities.check_arguments
+    def __ensure_translations_exist(self,languages:list[str])->None:
+        base_file=os.path.join(self.get_codeunit_folder(),"Other","Resources","Translations",f"messages.xlf")
+        for language in languages:
+            target_file=os.path.join(self.get_codeunit_folder(),"Other","Resources","Translations",f"messages.{language}.xlf")
+            if not os.path.isfile(target_file):
+                GeneralUtilities.ensure_file_exists(target_file)
+                GeneralUtilities.write_text_to_file(target_file, GeneralUtilities.read_text_from_file(base_file))
+                #set new attribute
+                tree = ET.parse(target_file)
+                root = tree.getroot()
+                ns_prefix = "{urn:oasis:names:tc:xliff:document:2.0}" 
+                for unit in root.findall(f".//{ns_prefix}unit"):
+                    for segment in unit.findall(f"{ns_prefix}segment"):
+                        segment.set("state", "initial")
+                tree.write(target_file, encoding="utf-8", xml_declaration=True)
+
+        angular_json_file=self.get_codeunit_folder()+"/angular.json"
+        if os.path.isfile(angular_json_file):
+            angular_json_path = Path(angular_json_file)
+            with angular_json_path.open(encoding="utf-8") as f:
+                angular_config = json.load(f)
+            i18n_config = angular_config["projects"][self.get_codeunit_name()]["i18n"]
+            new_locales = {
+                lang: f"Other/Resources/Translations/messages.{lang}.xlf"
+                for lang in languages
+            }
+            i18n_config.setdefault("locales", {}).update(new_locales)
+            with angular_json_path.open("w", encoding="utf-8") as f:
+                json.dump(angular_config, f, ensure_ascii=False, indent=2)
+
+    @GeneralUtilities.check_arguments
+    def organize_translations(self,languages:list[str])->None:
+        self._protected_sc.run_with_epew("npm","run extract-translations",self.get_codeunit_folder())
+        self.__ensure_translations_exist(languages)
+        self._protected_sc.sync_xlf2_files("messages",languages,os.path.join(self.get_codeunit_folder(),"Other","Resources","Translations"))
+
+    @GeneralUtilities.check_arguments
+    def translate_safe(self,base_language:str="en", throw_if_no_credentials:bool=False)->None:
+        """Translates XLF files if a translation service is configured. The translation service can be configured by creating a file at ~/.ScriptCollection/TranslationServiceProperties.txt with the content 'LibreTranslateAPI=your_api_server_url'."""
+        translationservice_file:str=self._protected_sc.get_global_cache_folder()+"/TranslationServiceProperties.txt"
+        api_server:str=None
+        if os.path.isfile(translationservice_file):
+            lines=GeneralUtilities.read_nonempty_lines_from_file(translationservice_file)
+            for line in lines:
+                if line.startswith("LibreTranslateAPI="):
+                    api_server=line.replace("LibreTranslateAPI=","").strip()
+        if api_server is None:
+            if throw_if_no_credentials:
+                raise ValueError("No translation service configured. Please create a file at ~/.ScriptCollection/TranslationServiceProperties.txt with the content 'LibreTranslateAPI=your_api_server_url' to enable automatic translation of XLF files.")
+        else:
+            self.translate(api_server,base_language)
+
+    @GeneralUtilities.check_arguments
+    def translate(self,api_server:str,base_language:str="en")->None:
+        folder:str=os.path.join(self.get_codeunit_folder(),"Other","Resources","Translations")
+        self._protected_sc.translate_xlf_files_in_folder(folder, base_language, api_server)
+
+class TFCPS_CodeUnitSpecific_NodeJS_CLI:
+
+    @staticmethod
+    @GeneralUtilities.check_arguments
+    def parse(file:str)->TFCPS_CodeUnitSpecific_NodeJS_Functions:
+        parser=TFCPS_CodeUnitSpecific_Base_CLI.get_base_parser()
+        #add custom parameter if desired
+        args=parser.parse_args()
+        result:TFCPS_CodeUnitSpecific_NodeJS_Functions=TFCPS_CodeUnitSpecific_NodeJS_Functions(file,LogLevel(int(args.verbosity)),args.targetenvironmenttype,not args.nocache,args.ispremerge)
+        return result