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

ScriptCollection/TFCPS/TFCPS_CreateRelease.py

@@ -0,0 +1,97 @@
+import os
+from ..ScriptCollectionCore import ScriptCollectionCore
+from ..SCLog import LogLevel
+from .TFCPS_Tools_General import TFCPS_Tools_General
+from .TFCPS_MergeToMain import TFCPS_MergeToMain,MergeToMainConfiguration
+from .TFCPS_MergeToStable import TFCPS_MergeToStable,MergeToStableConfiguration
+ 
+
+class TFCPS_CreateReleaseConfiguration:
+    
+    product_name: str
+    branch_to_be_released:str
+    additional_arguments_file:str
+    log_level:LogLevel
+    main_branch:str
+    stable_branch:str
+    build_repository:str
+    repository:str
+    reference_repository:str
+    reference_repo:str
+    common_remote_name:str
+    build_repo_main_branch_name:str
+    reference_repo_main_branch_name:str
+    reference_remote_name:str
+    build_repo_remote_name:str
+    artifacts_target_folder:str
+    common_remote_url:str
+    
+    def __init__(self, current_file: str, product_name: str,branch_to_be_released:str,log_level:LogLevel,additional_arguments_file:str,main_branch:str,stable_branch:str,reference_repo:str,common_remote_name:str,build_repo_main_branch_name:str,reference_repo_main_branch_name:str,reference_remote_name:str,build_repo_remote_name:str,artifacts_target_folder:str,common_remote_url:str):
+        self.product_name = product_name
+        self.branch_to_be_released=branch_to_be_released
+        self.additional_arguments_file=additional_arguments_file
+        self.log_level=log_level
+        self.main_branch=main_branch
+        self.stable_branch=stable_branch
+        self.build_repository=ScriptCollectionCore().search_repository_folder(current_file)
+        self.repository=os.path.join(self.build_repository,"Submodules",product_name)
+        self.reference_repository=os.path.join(self.build_repository,"Submodules",product_name+"Reference")
+        self.reference_repo=reference_repo
+        self.common_remote_name=common_remote_name
+        self.build_repo_main_branch_name=build_repo_main_branch_name
+        self.reference_repo_main_branch_name=reference_repo_main_branch_name
+        self.reference_remote_name=reference_remote_name
+        self.build_repo_remote_name=build_repo_remote_name
+        self.artifacts_target_folder=artifacts_target_folder
+        self.common_remote_url=common_remote_url
+
+class TFCPS_CreateRelease:
+
+    sc:ScriptCollectionCore
+    tFCPS_Tools_General:TFCPS_Tools_General
+
+    def __init__(self):
+        self.sc=ScriptCollectionCore()
+        self.tFCPS_Tools_General=TFCPS_Tools_General(self.sc)
+
+    def do_release(self,tfcps_CreateReleaseConfiguration:TFCPS_CreateReleaseConfiguration)->bool:
+        self.sc.log.loglevel=tfcps_CreateReleaseConfiguration.log_level
+        return self.sc.do_and_log_task(f"Release {tfcps_CreateReleaseConfiguration.product_name}",lambda : self.__do(tfcps_CreateReleaseConfiguration))
+
+    def __do(self,tfcps_CreateReleaseConfiguration:TFCPS_CreateReleaseConfiguration)->bool:
+        self.sc.log.log("Do checks...",LogLevel.Information)
+
+        self.sc.assert_is_git_repository(tfcps_CreateReleaseConfiguration.build_repository)
+        self.sc.assert_no_uncommitted_changes(tfcps_CreateReleaseConfiguration.build_repository)
+
+        self.sc.assert_is_git_repository(tfcps_CreateReleaseConfiguration.repository)
+        self.sc.assert_no_uncommitted_changes(tfcps_CreateReleaseConfiguration.repository)
+
+        self.sc.assert_is_git_repository(tfcps_CreateReleaseConfiguration.reference_repository)
+        self.sc.assert_no_uncommitted_changes(tfcps_CreateReleaseConfiguration.reference_repository)
+
+        release_was_done:bool=False
+        
+        branch_to_be_released_commit_id = self.sc.git_get_commit_id(tfcps_CreateReleaseConfiguration.repository, tfcps_CreateReleaseConfiguration.branch_to_be_released)
+        main_branch_commit_id = self.sc.git_get_commit_id(tfcps_CreateReleaseConfiguration.repository, tfcps_CreateReleaseConfiguration.main_branch)
+        if branch_to_be_released_commit_id == main_branch_commit_id:
+            self.sc.log.log("Merge to main-branch will not be done because there are no changed which can be merged.")
+        else:
+            self.sc.log.log("Merge to main-branch...",LogLevel.Information)
+            mergeToMainConfiguration:MergeToMainConfiguration=MergeToMainConfiguration(tfcps_CreateReleaseConfiguration.current_file,tfcps_CreateReleaseConfiguration.product_name,tfcps_CreateReleaseConfiguration.product_name,tfcps_CreateReleaseConfiguration.branch_to_be_released,tfcps_CreateReleaseConfiguration.log_level,tfcps_CreateReleaseConfiguration.additional_arguments_file,tfcps_CreateReleaseConfiguration.main_branch,tfcps_CreateReleaseConfiguration.common_remote_name)
+            tFCPS_MergeToMain:TFCPS_MergeToMain=TFCPS_MergeToMain(mergeToMainConfiguration)
+            tFCPS_MergeToMain.merge_to_main_branch()
+
+        main_branch_commit_id = self.sc.git_get_commit_id(tfcps_CreateReleaseConfiguration.repository, tfcps_CreateReleaseConfiguration.main_branch)
+        stable_branch_commit_id = self.sc.git_get_commit_id(tfcps_CreateReleaseConfiguration.repository, tfcps_CreateReleaseConfiguration.stable_branch)
+        if main_branch_commit_id == stable_branch_commit_id:
+            self.sc.log.log("Merge to stable-branch will not be done because there are no changed which can be released.")
+        else:
+            self.sc.log.log("Merge to stable-branch...",LogLevel.Information)
+            mergeToStableConfiguration:MergeToStableConfiguration=MergeToStableConfiguration(tfcps_CreateReleaseConfiguration.log_level,tfcps_CreateReleaseConfiguration.main_branch,tfcps_CreateReleaseConfiguration.stable_branch,tfcps_CreateReleaseConfiguration.repository,tfcps_CreateReleaseConfiguration.build_repository,tfcps_CreateReleaseConfiguration.reference_repo,tfcps_CreateReleaseConfiguration.common_remote_name,tfcps_CreateReleaseConfiguration.build_repo_main_branch_name,tfcps_CreateReleaseConfiguration.reference_repo_main_branch_name,tfcps_CreateReleaseConfiguration.reference_remote_name,tfcps_CreateReleaseConfiguration.build_repo_remote_name,tfcps_CreateReleaseConfiguration.artifacts_target_folder,tfcps_CreateReleaseConfiguration.product_name,tfcps_CreateReleaseConfiguration.common_remote_url,tfcps_CreateReleaseConfiguration.additional_arguments_file)
+            tFCPS_MergeToStable:TFCPS_MergeToStable=TFCPS_MergeToStable(mergeToStableConfiguration)
+            tFCPS_MergeToStable.merge_to_stable_branch()
+            
+            release_was_done=True
+
+        return release_was_done

ScriptCollection/TFCPS/TFCPS_Generic.py

@@ -0,0 +1,43 @@
+import argparse
+from ..ScriptCollectionCore import ScriptCollectionCore
+from ..SCLog import  LogLevel
+from .TFCPS_Tools_General import TFCPS_Tools_General
+
+class TFCPS_Generic_Functions:
+    script_file:str
+    repository_folder:str=None
+    targetenvironmenttype:str
+    additionalargumentsfile:str
+    verbosity:LogLevel
+    sc:ScriptCollectionCore
+    tfcps_Tools_General:TFCPS_Tools_General
+    __use_cache:bool
+    
+    def __init__(self,script_file:str,targetenvironmenttype:str,additionalargumentsfile:str,verbosity:LogLevel,use_cache:bool):
+        self.verbosity=verbosity
+        self.script_file=script_file
+        self.sc=ScriptCollectionCore()
+        self.sc.log.loglevel=self.verbosity
+        self.tfcps_Tools_General=TFCPS_Tools_General(self.sc)
+        self.repository_folder=self.sc.search_repository_folder(script_file)
+        self.targetenvironmenttype=targetenvironmenttype
+        self.__use_cache=use_cache
+        self.additionalargumentsfile=additionalargumentsfile
+
+    def use_cache(self)->bool:
+        return self.__use_cache
+
+
+class TFCPS_Generic_CLI:
+
+    @staticmethod
+    def parse(file:str)->TFCPS_Generic_Functions:
+        parser = argparse.ArgumentParser()
+        verbosity_values = ", ".join(f"{lvl.value}={lvl.name}" for lvl in LogLevel)
+        parser.add_argument('-e', '--targetenvironmenttype', required=False, default="QualityCheck")
+        parser.add_argument('-a', '--additionalargumentsfile', required=False, default=None)
+        parser.add_argument('-v', '--verbosity', required=False, default=3, help=f"Sets the loglevel. Possible values: {verbosity_values}")
+        parser.add_argument('-c', '--nocache',  action='store_true', required=False, default=False)
+        args=parser.parse_args()
+        result:TFCPS_Generic_Functions=TFCPS_Generic_Functions(file,args.targetenvironmenttype,args.additionalargumentsfile,LogLevel(int(args.verbosity)),not args.nocache)
+        return result 

ScriptCollection/TFCPS/TFCPS_MergeToMain.py

@@ -0,0 +1,125 @@
+import argparse
+import os
+from ..GeneralUtilities import GeneralUtilities
+from ..SCLog import LogLevel
+from ..ScriptCollectionCore import ScriptCollectionCore
+from .TFCPS_Tools_General import TFCPS_Tools_General
+from .TFCPS_CodeUnit_BuildCodeUnits import TFCPS_CodeUnit_BuildCodeUnits
+from .TFCPS_Generic import TFCPS_Generic_Functions
+
+class MergeToMainConfiguration:
+    product_name: str
+    merge_source_branch:str
+    additional_arguments_file:str
+    log_level:LogLevel
+    main_branch:str
+    repository_folder:str
+    tFCPS_Generic_Functions:TFCPS_Generic_Functions
+    common_remote_name:str
+    sc:ScriptCollectionCore=ScriptCollectionCore()
+
+    def __init__(self, current_file: str,repository:str, product_name: str,merge_source_branch:str,log_level:LogLevel,additional_arguments_file:str,main_branch:str,common_remote_name:str):
+        self.sc.log.loglevel=log_level
+        self.repository_folder = repository
+        self.product_name = product_name
+        self.merge_source_branch=merge_source_branch
+        self.additional_arguments_file=additional_arguments_file
+        self.log_level=log_level
+        self.main_branch=main_branch
+        self.common_remote_name=common_remote_name
+
+class TFCPS_MergeToMain:
+
+    sc:ScriptCollectionCore
+    tFCPS_Tools_General:TFCPS_Tools_General
+    generic_prepare_new_release_arguments:MergeToMainConfiguration=None
+
+    def __init__(self,generic_prepare_new_release_arguments:MergeToMainConfiguration):
+        self.sc=ScriptCollectionCore()
+        self.tFCPS_Tools_General=TFCPS_Tools_General(self.sc)
+        self.generic_prepare_new_release_arguments=generic_prepare_new_release_arguments
+
+    @GeneralUtilities.check_arguments
+    def merge_to_main_branch(self ) -> None:
+        self.sc.log.loglevel=self.generic_prepare_new_release_arguments.log_level
+        self.sc.log.log("Merge to main-branch...")
+        fast_forward_source_branch: bool=True
+        source_branch: str=self.generic_prepare_new_release_arguments.merge_source_branch
+        target_branch: str=self.generic_prepare_new_release_arguments.main_branch
+        self.sc.assert_is_git_repository(self.generic_prepare_new_release_arguments.repository_folder)
+
+        GeneralUtilities.assert_condition(self.sc.git_get_commit_id(self.generic_prepare_new_release_arguments.repository_folder,source_branch)!=self.sc.git_get_commit_id(self.generic_prepare_new_release_arguments.repository_folder,target_branch),"Source- and target-branch must not be the same commit.")
+
+        self.sc.assert_no_uncommitted_changes(self.generic_prepare_new_release_arguments.repository_folder)
+        self.sc.git_checkout(self.generic_prepare_new_release_arguments.repository_folder, source_branch)
+        self.sc.assert_no_uncommitted_changes(self.generic_prepare_new_release_arguments.repository_folder)
+
+        tfcps_CodeUnit_BuildCodeUnits:TFCPS_CodeUnit_BuildCodeUnits=TFCPS_CodeUnit_BuildCodeUnits(self.generic_prepare_new_release_arguments.repository_folder,self.sc.log.loglevel,"QualityCheck",self.generic_prepare_new_release_arguments.additional_arguments_file,False,True)
+        try:
+            tfcps_CodeUnit_BuildCodeUnits.build_codeunits()
+        except Exception:
+            self.sc.git_undo_all_changes(self.generic_prepare_new_release_arguments.repository_folder)
+            raise
+
+        self.sc.git_commit(self.generic_prepare_new_release_arguments.repository_folder, 'Built codeunits', stage_all_changes=True, no_changes_behavior=0)
+        
+        if fast_forward_source_branch:
+            self.sc.git_checkout(self.generic_prepare_new_release_arguments.repository_folder, source_branch)
+            project_version:str=self.tFCPS_Tools_General.get_version_of_project(self.generic_prepare_new_release_arguments.repository_folder)
+            self.sc.git_merge(self.generic_prepare_new_release_arguments.repository_folder, source_branch, target_branch, False, True)
+            self.sc.git_merge(self.generic_prepare_new_release_arguments.repository_folder, target_branch, source_branch, True, True)
+            self.sc.git_create_tag(self.generic_prepare_new_release_arguments.repository_folder,target_branch,f"v{project_version}")
+
+        self.sc.log.log("Push branches...")
+        self.sc.git_push_with_retry(self.generic_prepare_new_release_arguments.repository_folder,self.generic_prepare_new_release_arguments.common_remote_name,source_branch,source_branch)
+        self.sc.git_push_with_retry(self.generic_prepare_new_release_arguments.repository_folder,self.generic_prepare_new_release_arguments.common_remote_name,target_branch,target_branch)
+ 
+class TFCPS_MergeToMain_CLI:
+
+    @staticmethod
+    def get_with_overwritable_defaults(file:str,default_product_name:str=None,default_merge_source_branch:str=None,default_loglevel:LogLevel=None,default_additionalargumentsfile:str=None,default_main_branch:str=None,default_common_remote_name:str=None)->TFCPS_MergeToMain:
+        parser = argparse.ArgumentParser()
+        verbosity_values = ", ".join(f"{lvl.value}={lvl.name}" for lvl in LogLevel)
+        parser.add_argument('-n', '--productname', required=False,default=None)
+        parser.add_argument('-s', '--mergesourcebranch', required=False)
+        parser.add_argument('-e', '--targetenvironmenttype', required=False, default="QualityCheck")
+        parser.add_argument('-a', '--additionalargumentsfile', required=False, default=None)
+        parser.add_argument('-t', '--mainbranch', required=False, default="main")
+        parser.add_argument('-r', '--commonremotename', required=False, default=None)
+        parser.add_argument('-v', '--verbosity', required=False, default=3, help=f"Sets the loglevel. Possible values: {verbosity_values}")
+        args=parser.parse_args()
+
+        sc:ScriptCollectionCore=ScriptCollectionCore()
+
+        build_repo=GeneralUtilities.resolve_relative_path("../../..",file)
+        sc.assert_is_git_repository(build_repo)
+
+        if args.productname is not None: 
+            default_product_name=args.productname
+        if default_product_name is None:
+            default_product_name=os.path.basename(build_repo)[:-len("Build")]
+        GeneralUtilities.assert_not_null(default_product_name,"productname is not set")
+
+        if args.mergesourcebranch is not None: 
+            default_merge_source_branch=args.mergesourcebranch#other/next-release
+        GeneralUtilities.assert_not_null(default_merge_source_branch,"mergesourcebranch is not set")
+
+        if args.verbosity is not None:
+            default_loglevel=LogLevel(int( args.verbosity))
+        GeneralUtilities.assert_not_null(default_merge_source_branch,"verbosity is not set")
+
+        if args.additionalargumentsfile is not None:
+            default_additionalargumentsfile=args.additionalargumentsfile
+
+        if args.mainbranch is not None: 
+            default_main_branch=args.mainbranch#main
+        GeneralUtilities.assert_not_null(default_main_branch,"mainbranch is not set")
+
+        if args.commonremotename is not None:
+            default_common_remote_name=args.commonremotename
+        GeneralUtilities.assert_not_null(default_common_remote_name,"commonremotename is not set")
+
+        repository=os.path.join(build_repo,"Submodules",default_product_name)
+        config:MergeToMainConfiguration=MergeToMainConfiguration(file,repository,default_product_name,default_merge_source_branch,default_loglevel,default_additionalargumentsfile,default_main_branch,default_common_remote_name)
+        tFCPS_MergeToMain:TFCPS_MergeToMain=TFCPS_MergeToMain(config)
+        return tFCPS_MergeToMain

ScriptCollection/TFCPS/TFCPS_MergeToStable.py

@@ -0,0 +1,361 @@
+import argparse
+import os
+import shutil
+from functools import cmp_to_key
+from ..GeneralUtilities import GeneralUtilities
+from ..ScriptCollectionCore import ScriptCollectionCore
+from ..SCLog import LogLevel
+from .TFCPS_Tools_General import TFCPS_Tools_General
+from .TFCPS_MergeToMain import TFCPS_MergeToMain
+from .TFCPS_CodeUnit_BuildCodeUnits import TFCPS_CodeUnit_BuildCodeUnits
+ 
+
+
+class MergeToStableConfiguration:
+    log_level:LogLevel
+    source_branch:str#main
+    target_branch:str#stable
+    repository:str
+    build_repo:str
+    reference_repo:str
+    common_remote_name:str
+    build_repo_main_branch_name:str
+    reference_repo_main_branch_name:str
+    reference_remote_name:str
+    build_repo_remote_name:str
+    artifacts_target_folder:str
+    product_name:str
+    common_remote_url:str
+    additional_arguments_file:str
+
+    def __init__(self,loglevel:LogLevel,source_branch:str,target_branch:str,repository:str,build_repo:str,reference_repo:str,common_remote_name:str,build_repo_main_branch_name:str,reference_repo_main_branch_name:str,reference_remote_name:str,build_repo_remote_name:str,artifacts_target_folder:str,product_name:str,common_remote_url:str,additional_arguments_file:str):
+        self.log_level=loglevel
+        self.source_branch=source_branch
+        self.target_branch=target_branch
+        self.repository=repository
+        self.build_repo=build_repo
+        self.reference_repo=reference_repo
+        self.common_remote_name=common_remote_name
+        self.build_repo_main_branch_name=build_repo_main_branch_name
+        self.reference_repo_main_branch_name=reference_repo_main_branch_name
+        self.reference_remote_name=reference_remote_name
+        self.build_repo_remote_name=build_repo_remote_name
+        self.artifacts_target_folder=artifacts_target_folder
+        self.product_name=product_name
+        self.common_remote_url=common_remote_url
+        self.additional_arguments_file=additional_arguments_file
+
+class TFCPS_MergeToStable:
+
+    sc:ScriptCollectionCore
+    tFCPS_Tools_General:TFCPS_Tools_General
+    createRelease_configuration: MergeToStableConfiguration
+
+    def __init__(self, createRelease_configuration: MergeToStableConfiguration):
+        self.sc=ScriptCollectionCore()
+        self.tFCPS_Tools_General=TFCPS_Tools_General(self.sc)
+        self.createRelease_configuration=createRelease_configuration
+ 
+    @GeneralUtilities.check_arguments
+    def merge_to_stable_branch(self):
+        self.sc.log.loglevel=self.createRelease_configuration.log_level
+        self.sc.log.log("Merge to stable-branch...")
+        product_name:str=self.createRelease_configuration.product_name
+
+        GeneralUtilities.assert_condition(self.sc.git_get_commit_id(self.createRelease_configuration.repository,self.createRelease_configuration.source_branch)!=self.sc.git_get_commit_id(self.createRelease_configuration.repository,self.createRelease_configuration.target_branch),"Source- and target-branch must not be the same commit.")
+
+        self.sc.assert_is_git_repository(self.createRelease_configuration.repository)
+        self.sc.assert_no_uncommitted_changes(self.createRelease_configuration.repository)
+        self.sc.git_checkout(self.createRelease_configuration.repository, self.createRelease_configuration.source_branch)
+        self.sc.assert_no_uncommitted_changes(self.createRelease_configuration.repository)
+
+        self.sc.assert_is_git_repository(self.createRelease_configuration.reference_repo)
+        self.sc.assert_no_uncommitted_changes(self.createRelease_configuration.reference_repo)
+
+        self.sc.assert_is_git_repository(self.createRelease_configuration.build_repo)
+        self.sc.assert_no_uncommitted_changes(self.createRelease_configuration.build_repo)
+
+        product_version:str=self.tFCPS_Tools_General.get_version_of_project(self.createRelease_configuration.repository)
+ 
+        tfcps_CodeUnit_BuildCodeUnits:TFCPS_CodeUnit_BuildCodeUnits=TFCPS_CodeUnit_BuildCodeUnits(self.createRelease_configuration.repository,self.sc.log.loglevel,"Productive",self.createRelease_configuration.additional_arguments_file,False,False)
+        try:
+            tfcps_CodeUnit_BuildCodeUnits.build_codeunits()
+        except Exception:
+            self.sc.git_undo_all_changes(self.createRelease_configuration.repository)
+            raise
+
+        eov_enabled=False
+        if eov_enabled:        
+            self.sc.log.log("Remove outdated versions...")
+            self.__remove_outdated_version()
+
+        self.sc.log.log("Release artifacts...")
+        for codeunit in self.tFCPS_Tools_General.get_codeunits(self.createRelease_configuration.repository):
+            self.sc.git_checkout(self.createRelease_configuration.repository, self.createRelease_configuration.source_branch, True,True)
+            if self.createRelease_configuration.artifacts_target_folder is not None:
+                #export artifacts to local target folder
+                self.sc.log.log(f"Export artifacts of codeunit {codeunit} to target-folder...")
+                source_folder:str=GeneralUtilities.resolve_relative_path(f"./{codeunit}/Other/Artifacts",self.createRelease_configuration.repository)
+                target_folder:str=GeneralUtilities.resolve_relative_path(f"./{product_name}/{product_version}/{codeunit}",self.createRelease_configuration.artifacts_target_folder)
+                GeneralUtilities.ensure_directory_exists(target_folder)
+                codeunit_version:str=self.tFCPS_Tools_General.get_version_of_codeunit(os.path.join(self.createRelease_configuration.repository,codeunit,f"{codeunit}.codeunit.xml"))
+                target_file:str=os.path.join(target_folder,f"{codeunit}.v{codeunit_version}.Artifacts.zip")
+                self.sc.run_program("tar",f"-cf {target_file} -C {source_folder} .")
+
+            #push artifacts
+            push_script:str=os.path.join( self.createRelease_configuration.build_repo,"Scripts","CreateRelease",f"PushArtifacts.{codeunit}.py")
+            if os.path.isfile(push_script):
+                self.sc.log.log(f"Push artifacts of codeunit {codeunit}...")
+                self.sc.run_program("python3",os.path.basename(push_script),os.path.dirname(push_script))
+            else:
+                self.sc.log.log(f"Codeunit {codeunit} does not have artifacts to push. (Scriptfile \"{push_script}\" does not exist.)",LogLevel.Debug)
+
+            # Generate reference
+            self.sc.log.log(f"Release artifacts of codeunit {codeunit}...")
+            reference_folder:str=os.path.join(self.createRelease_configuration.reference_repo,"ReferenceContent")
+            repository:str=self.createRelease_configuration.repository
+            project_version:str=self.tFCPS_Tools_General.get_version_of_project(repository)
+            projectname:str=self.createRelease_configuration.product_name
+            public_repository_url:str=self.createRelease_configuration.common_remote_url
+            main_branch_name:str=self.createRelease_configuration.source_branch
+            codeunit_version=self.tFCPS_Tools_General.get_version_of_codeunit(os.path.join(repository,codeunit,f"{codeunit}.codeunit.xml"))
+            self.__export_codeunit_reference_content_to_reference_repository(f"v{project_version}", False, reference_folder, repository, codeunit, projectname, codeunit_version, public_repository_url, f"v{project_version}")
+            self.__export_codeunit_reference_content_to_reference_repository("Latest", True, reference_folder, repository, codeunit, projectname, codeunit_version, public_repository_url, main_branch_name)
+            self.__generate_entire_reference(projectname, project_version, reference_folder)
+            
+        self.sc.log.log("Finishing merging to stable...")
+        self.sc.git_commit(self.createRelease_configuration.reference_repo,f"Added reference for v{project_version}")
+        
+        self.sc.git_merge(self.createRelease_configuration.repository, self.createRelease_configuration.source_branch,self.createRelease_configuration.target_branch, True,True,None,True,True)
+        
+        self.sc.assert_no_uncommitted_changes(self.createRelease_configuration.repository)
+        self.sc.assert_no_uncommitted_changes(self.createRelease_configuration.reference_repo)
+        self.sc.assert_no_uncommitted_changes(self.createRelease_configuration.build_repo)
+
+        self.sc.git_push_with_retry(self.createRelease_configuration.repository,self.createRelease_configuration.common_remote_name,self.createRelease_configuration.target_branch,self.createRelease_configuration.target_branch)
+        self.sc.git_push_with_retry(self.createRelease_configuration.build_repo,self.createRelease_configuration.build_repo_remote_name,self.createRelease_configuration.build_repo_main_branch_name,self.createRelease_configuration.build_repo_main_branch_name)
+        self.sc.git_push_with_retry(self.createRelease_configuration.reference_repo,self.createRelease_configuration.reference_remote_name,self.createRelease_configuration.reference_repo_main_branch_name,self.createRelease_configuration.reference_repo_main_branch_name)
+
+    def __remove_outdated_version(self):
+        now = GeneralUtilities.get_now()
+        for unsupported_version in self.tFCPS_Tools_General.get_unsupported_versions(self.createRelease_configuration.repository, now):
+            unsupported_reference_folder = f"{self.createRelease_configuration.reference_repo}/ReferenceContent/v{unsupported_version[0]}"
+            GeneralUtilities.ensure_directory_does_not_exist(unsupported_reference_folder)
+
+        
+    @GeneralUtilities.check_arguments
+    def __generate_entire_reference(self, projectname: str, project_version: str, reference_folder: str) -> None:
+        all_available_version_identifier_folders_of_reference: list[str] = list(folder for folder in GeneralUtilities.get_direct_folders_of_folder(reference_folder))
+        all_available_version_identifier_folders_of_reference = sorted(all_available_version_identifier_folders_of_reference, key=cmp_to_key(TFCPS_Tools_General.sort_reference_folder))
+        reference_versions_html_lines = []
+        reference_versions_html_lines.append('    <hr/>')
+        for all_available_version_identifier_folder_of_reference in all_available_version_identifier_folders_of_reference:
+            version_identifier_of_project = os.path.basename(all_available_version_identifier_folder_of_reference)
+            if version_identifier_of_project == "Latest":
+                latest_version_hint = f" (v{project_version})"
+            else:
+                latest_version_hint = GeneralUtilities.empty_string
+            reference_versions_html_lines.append(f'    <h2>{version_identifier_of_project}{latest_version_hint}</h2>')
+            reference_versions_html_lines.append("    Contained codeunits:<br/>")
+            reference_versions_html_lines.append("    <ul>")
+            for codeunit_reference_folder in list(folder for folder in GeneralUtilities.get_direct_folders_of_folder(all_available_version_identifier_folder_of_reference)):
+                reference_versions_html_lines.append(f'      <li><a href="./{version_identifier_of_project}/{os.path.basename(codeunit_reference_folder)}/index.html">' +
+                                                     f'{os.path.basename(codeunit_reference_folder)} {version_identifier_of_project}</a></li>')
+            reference_versions_html_lines.append("    </ul>")
+            reference_versions_html_lines.append('    <hr/>')
+            if version_identifier_of_project == "Latest":
+                latest_version_hint = "    <h2>History</h2>"
+
+        design_file = None
+        design = "ModestDark"
+        if design == "ModestDark":
+            design_file = GeneralUtilities.get_modest_dark_url()
+        # TODO make designs from customizable sources be available by a customizable name and outsource this to a class-property because this is duplicated code.
+        if design_file is None:
+            design_html = GeneralUtilities.empty_string
+        else:
+            design_html = f'<link type="text/css" rel="stylesheet" href="{design_file}" />'
+
+        reference_versions_links_file_content = "    \n".join(reference_versions_html_lines)
+        title = f"{projectname}-reference"
+        reference_index_file = os.path.join(reference_folder, "index.html")
+        reference_index_file_content = f"""<!DOCTYPE html>
+<html lang="en">
+
+  <head>
+    <meta charset="UTF-8">
+    <title>{title}</title>
+    {design_html}
+  </head>
+
+  <body>
+    <h1>{title}</h1>
+{reference_versions_links_file_content}
+  </body>
+
+</html>
+"""  # see https://getbootstrap.com/docs/5.1/getting-started/introduction/
+        GeneralUtilities.write_text_to_file(reference_index_file, reference_index_file_content)
+
+
+    @GeneralUtilities.check_arguments
+    def __export_codeunit_reference_content_to_reference_repository(self, project_version_identifier: str, replace_existing_content: bool, target_folder_for_reference_repository: str, repository: str, codeunitname: str, projectname: str, codeunit_version: str, public_repository_url: str, branch: str) -> None:
+        codeunit_folder = os.path.join(repository, codeunitname)
+        codeunit_file = os.path.join(codeunit_folder, f"{codeunitname}.codeunit.xml")
+        codeunit_has_testcases = self.tFCPS_Tools_General.codeunit_has_testable_sourcecode(codeunit_file)
+        target_folder = os.path.join(target_folder_for_reference_repository, project_version_identifier, codeunitname)
+        if os.path.isdir(target_folder) and not replace_existing_content:
+            raise ValueError(f"Folder '{target_folder}' already exists.")
+        GeneralUtilities.ensure_directory_does_not_exist(target_folder)
+        GeneralUtilities.ensure_directory_exists(target_folder)
+        codeunit_version_identifier = "Latest" if project_version_identifier == "Latest" else "v"+codeunit_version
+        page_title = f"{codeunitname} {codeunit_version_identifier} codeunit-reference"
+        diff_report = f"{repository}/{codeunitname}/Other/Artifacts/DiffReport/DiffReport.html"
+        diff_target_folder = os.path.join(target_folder, "DiffReport")
+        GeneralUtilities.ensure_directory_exists(diff_target_folder)
+        diff_target_file = os.path.join(diff_target_folder, "DiffReport.html")
+        title = (f'Reference of codeunit {codeunitname} {codeunit_version_identifier} (contained in project <a href="{public_repository_url}">{projectname}</a> {project_version_identifier})')
+        if public_repository_url is None:
+            repo_url_html = GeneralUtilities.empty_string
+        else:
+            repo_url_html = f'<a href="{public_repository_url}/tree/{branch}/{codeunitname}">Source-code</a>'
+        if codeunit_has_testcases:
+            coverage_report_link = '<a href="./TestCoverageReport/index.html">Test-coverage-report</a><br>'
+        else:
+            coverage_report_link = GeneralUtilities.empty_string
+        index_file_for_reference = os.path.join(target_folder, "index.html")
+
+        design_file = None
+        design = "ModestDark"
+        if design == "ModestDark":
+            design_file = GeneralUtilities.get_modest_dark_url()
+        # TODO make designs from customizable sources be available by a customizable name and outsource this to a class-property because this is duplicated code.
+        if design_file is None:
+            design_html = GeneralUtilities.empty_string
+        else:
+            design_html = f'<link type="text/css" rel="stylesheet" href="{design_file}" />'
+
+        index_file_content = f"""<!DOCTYPE html>
+<html lang="en">
+
+  <head>
+    <meta charset="UTF-8">
+    <title>{page_title}</title>
+    {design_html}
+  </head>
+
+  <body>
+    <h1>{title}</h1>
+    <hr/>
+    Available reference-content for {codeunitname}:<br>
+    {repo_url_html}<br>
+    <!--TODO add artefacts-link: <a href="./x">Artefacts</a><br>-->
+    <a href="./Reference/index.html">Reference</a><br>
+    <a href="./DiffReport/DiffReport.html">Diff-report</a><br>
+    {coverage_report_link}
+  </body>
+
+</html>
+"""
+
+        GeneralUtilities.ensure_file_exists(index_file_for_reference)
+        GeneralUtilities.write_text_to_file(index_file_for_reference, index_file_content)
+        other_folder_in_repository = os.path.join(repository, codeunitname, "Other")
+        source_generatedreference = os.path.join(other_folder_in_repository, "Artifacts", "Reference")
+        target_generatedreference = os.path.join(target_folder, "Reference")
+        shutil.copytree(source_generatedreference, target_generatedreference)
+
+        shutil.copyfile(diff_report, diff_target_file)
+
+        if codeunit_has_testcases:
+            source_testcoveragereport = os.path.join(other_folder_in_repository, "Artifacts", "TestCoverageReport")
+            if os.path.isdir(source_testcoveragereport):  # check, because it is not a mandatory artifact. if the artifact is not available, the user gets already a warning.
+                target_testcoveragereport = os.path.join(target_folder, "TestCoverageReport")
+                shutil.copytree(source_testcoveragereport, target_testcoveragereport)
+
+
+
+class TFCPS_MergeToStable_CLI:
+
+    @staticmethod
+    def get_with_overwritable_defaults(file:str,default_product_name:str=None,default_loglevel:LogLevel=None,default_source_branch:str=None,default_additionalargumentsfile:str=None,default_target_branch:str=None,default_reference_repo:str=None,common_remote_name:str=None,build_repo_main_branch_name:str=None,reference_repo_main_branch_name:str=None,reference_remote_name:str=None,build_repo_remote_name:str=None,artifacts_target_folder:str=None,common_remote_url:str=None)->TFCPS_MergeToMain:
+        parser = argparse.ArgumentParser()
+        verbosity_values = ", ".join(f"{lvl.value}={lvl.name}" for lvl in LogLevel)
+        parser.add_argument('-n', '--productname', required=False,default=None)
+        parser.add_argument('-a', '--additionalargumentsfile', required=False, default=None)
+        parser.add_argument('-s', '--sourcebranch', required=False, default="main")
+        parser.add_argument('-t', '--targetbranch', required=False, default="stable")
+        parser.add_argument( '--referencerepo', required=False, default=None)
+        parser.add_argument( '--commonremotename', required=False, default=None)
+        parser.add_argument( '--buildrepomainbranchname', required=False, default="main")
+        parser.add_argument( '--referencerepomainbranchname', required=False, default="main")
+        parser.add_argument( '--referenceremotename', required=False, default=None)
+        parser.add_argument( '--buildreporemotename', required=False, default=None)
+        parser.add_argument( '--artifactstargetfolder', required=False, default=None)
+        parser.add_argument( '--commonremoteurl', required=False, default=None)
+        parser.add_argument('-v', '--verbosity', required=False, default=3, help=f"Sets the loglevel. Possible values: {verbosity_values}")
+        args=parser.parse_args()
+
+        sc:ScriptCollectionCore=ScriptCollectionCore()
+
+        build_repo=GeneralUtilities.resolve_relative_path("../../..",file)
+        sc.assert_is_git_repository(build_repo)
+
+        if args.productname is not None: 
+            default_product_name=args.productname
+        if default_product_name is None:
+            default_product_name=os.path.basename(build_repo)[:-len("Build")]
+        GeneralUtilities.assert_not_null(default_product_name,"productname is not set")
+
+        if args.verbosity is not None:
+            default_loglevel=LogLevel(int( args.verbosity))
+        GeneralUtilities.assert_not_null(default_loglevel,"verbosity is not set")
+
+        if args.additionalargumentsfile is not None:
+            default_additionalargumentsfile=args.additionalargumentsfile
+
+        if args.sourcebranch is not None:
+            default_source_branch=args.sourcebranch
+        GeneralUtilities.assert_not_null(default_source_branch,"sourcebranch is not set")
+
+        if args.targetbranch is not None:
+            default_target_branch=args.targetbranch
+        GeneralUtilities.assert_not_null(default_target_branch,"targetbranch is not set")
+
+        if args.referencerepo is not None:
+            default_reference_repo=args.referencerepo
+        if default_reference_repo is None:
+            default_reference_repo=os.path.join(build_repo,"Submodules",f"{default_product_name}Reference")
+        GeneralUtilities.assert_not_null(default_reference_repo,"referencerepo is not set")
+        
+        if args.commonremotename is not None:
+            common_remote_name=args.commonremotename
+        GeneralUtilities.assert_not_null(common_remote_name,"commonremotename is not set")
+
+        if args.buildrepomainbranchname is not None:
+            build_repo_main_branch_name=args.buildrepomainbranchname
+        GeneralUtilities.assert_not_null(build_repo_main_branch_name,"buildrepomainbranchname is not set")
+
+        if args.referencerepomainbranchname is not None:
+            reference_repo_main_branch_name=args.referencerepomainbranchname
+        GeneralUtilities.assert_not_null(reference_repo_main_branch_name,"referencerepomainbranchname is not set")
+
+        if args.referenceremotename is not None:
+            reference_remote_name=args.referenceremotename
+        GeneralUtilities.assert_not_null(reference_remote_name,"referenceremotename is not set")
+
+        if args.buildreporemotename is not None:
+            build_repo_remote_name=args.buildreporemotename
+        GeneralUtilities.assert_not_null(build_repo_remote_name,"buildreporemotename is not set")
+
+        if args.artifactstargetfolder is not None:
+            artifacts_target_folder=args.artifactstargetfolder
+
+        if args.commonremoteurl is not None:
+            common_remote_url=args.commonremoteurl
+        GeneralUtilities.assert_not_null(common_remote_url,"commonremoteurl is not set")
+
+        repository=os.path.join(build_repo,"Submodules",default_product_name)
+        config:MergeToStableConfiguration=MergeToStableConfiguration(default_loglevel,default_source_branch,default_target_branch,repository,build_repo,default_reference_repo,common_remote_name,build_repo_main_branch_name,reference_repo_main_branch_name,reference_remote_name,build_repo_remote_name,artifacts_target_folder,default_product_name,common_remote_url,default_additionalargumentsfile)
+        tFCPS_MergeToMain:TFCPS_MergeToStable=TFCPS_MergeToStable(config)
+        return tFCPS_MergeToMain

ScriptCollection/TFCPS/TFCPS_Tools_Dependencies.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+
+class Dependency:
+    name:str
+    current_version:str
+    latest_patch_version_for_current_minor_version:str
+    latest_minor_version_for_current_major_version:str
+    latest_version:str
+    date_of_latest_version:datetime
+
+class TFCPS_Tools_Dependencies:
+    
+    def get_dependencies(self)->list[Dependency]:
+        result:list[Dependency]=[]
+        #TODO
+        return result