Refatoring import / export functions signatures

Author: okorach

cli/config.py

@@ -149,9 +149,34 @@ def __export_config(endpoint: platform.Platform, what: list[str], **kwargs) -> N
         if len(non_existing_projects) > 0:
             utilities.exit_fatal(f"Project key(s) '{','.join(non_existing_projects)}' do(es) not exist", errcodes.NO_SUCH_KEY)
 
+    calls = {
+        options.WHAT_SETTINGS: [__JSON_KEY_SETTINGS, platform.export],
+        options.WHAT_RULES: [__JSON_KEY_RULES, rules.export],
+        options.WHAT_PROFILES: [__JSON_KEY_PROFILES, qualityprofiles.export],
+        options.WHAT_GATES: [__JSON_KEY_GATES, qualitygates.export],
+        options.WHAT_PROJECTS: [__JSON_KEY_PROJECTS, projects.export],
+        options.WHAT_APPS: [__JSON_KEY_APPS, applications.export],
+        options.WHAT_PORTFOLIOS: [__JSON_KEY_PORTFOLIOS, portfolios.export],
+        options.WHAT_USERS: [__JSON_KEY_USERS, users.export],
+        options.WHAT_GROUPS: [__JSON_KEY_GROUPS, groups.export],
+    }
+
     log.info("Exporting configuration from %s", kwargs[options.URL])
     key_list = kwargs[options.KEYS]
     sq_settings = {__JSON_KEY_PLATFORM: endpoint.basics()}
+    for what_item, call_data in calls.items():
+        if what_item in what:
+            ndx, func = call_data
+            try:
+                sq_settings[ndx] = func(endpoint, export_settings=export_settings, key_list=key_list)
+            except exceptions.UnsupportedOperation as e:
+                log.warning(e.message)
+    sq_settings = utilities.remove_empties(sq_settings)
+    if not kwargs["dontInlineLists"]:
+        sq_settings = utilities.inline_lists(sq_settings, exceptions=("conditions",))
+    __write_export(sq_settings, kwargs[options.REPORT_FILE], kwargs[options.FORMAT])
+    log.info("Exporting configuration from %s completed", kwargs["url"])
+
     if options.WHAT_SETTINGS in what:
         sq_settings[__JSON_KEY_SETTINGS] = endpoint.export(export_settings=export_settings)
     if options.WHAT_RULES in what or options.WHAT_PROFILES in what:
@@ -177,12 +202,6 @@ def __export_config(endpoint: platform.Platform, what: list[str], **kwargs) -> N
     if options.WHAT_GROUPS in what:
         sq_settings[__JSON_KEY_GROUPS] = groups.export(endpoint, export_settings=export_settings)
 
-    sq_settings = utilities.remove_empties(sq_settings)
-    if not kwargs["dontInlineLists"]:
-        sq_settings = utilities.inline_lists(sq_settings, exceptions=("conditions",))
-    __write_export(sq_settings, kwargs[options.REPORT_FILE], kwargs[options.FORMAT])
-    log.info("Exporting configuration from %s completed", kwargs["url"])
-
 
 def __read_input_file(file: str) -> dict[str, any]:
     try:
@@ -203,6 +222,7 @@ def __import_config(endpoint: platform.Platform, what: list[str], data: dict[str
         options.WHAT_USERS: users.import_config,
         options.WHAT_GATES: qualitygates.import_config,
         options.WHAT_RULES: rules.import_config,
+        options.WHAT_PROFILES: qualityprofiles.import_config,
         options.WHAT_SETTINGS: platform.import_config,
         options.WHAT_PROJECTS: projects.import_config,
         options.WHAT_APPS: applications.import_config,
@@ -216,7 +236,6 @@ def __import_config(endpoint: platform.Platform, what: list[str], data: dict[str
             except exceptions.UnsupportedOperation as e:
                 log.warning(e.message)
     log.info("Importing configuration to %s completed", kwargs[options.URL])
-    return None
 
 
 def main() -> None:

sonar/applications.py

@@ -498,11 +498,10 @@ def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, key_lis
     """Exports applications as JSON
 
     :param Platform endpoint: Reference to the Sonar platform
+    :param ConfigSetting export_settings: Options to use for export
     :param KeyList key_list: list of Application keys to export, defaults to all if None
-    :param full: Whether to export all attributes, including those that can't be set, defaults to False
-    :type full: bool
     :return: Dict of applications settings
-    :rtype: dict
+    :rtype: ObjectJsonRepr
     """
     if endpoint.is_sonarcloud():
         # log.info("Applications do not exist in SonarCloud, export skipped")

sonar/groups.py

@@ -256,15 +256,16 @@ def get_list(endpoint: pf.Platform) -> dict[str, Group]:
     return search(endpoint)
 
 
-def export(endpoint: pf.Platform, export_settings: types.ConfigSettings) -> types.ObjectJsonRepr:
-    """Exports all groups configuration as dict
-    Default groups (sonar-users) are not exported
-
-    :param endpoint: reference to the SonarQube platform
-    :type endpoint: pf.Platform
-    :return: list of groups
-    :rtype: dict{name: description}
+def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, key_list: types.KeyList = None) -> types.ObjectJsonRepr:
+    """Exports groups representation in JSON
+
+    :param Platform endpoint: reference to the SonarQube platform
+    :param ConfigSettings export_settings: Export parameters
+    :param KeyList key_list: List of project keys to export, defaults to None (all projects)
+    :return: list of groups settings
+    :rtype: ObjectJsonRepr
     """
+
     log.info("Exporting groups")
     g_list = {}
     for g_name, g_obj in sorted(search(endpoint=endpoint).items()):

sonar/platform.py

@@ -824,7 +824,7 @@ def import_config(endpoint: Platform, config_data: types.ObjectJsonRepr, key_lis
 
     :param Platform endpoint: reference to the SonarQube platform
     :param ObjectJsonRepr config_data: the configuration to import
-    :param KeyList key_list: List of project keys to be considered for the import, defaults to None (all projects)
+    :param KeyList key_list: Unused
     :return: Nothing
     """
     endpoint.import_config(config_data)
@@ -853,3 +853,15 @@ def convert_for_yaml(original_json: types.ObjectJsonRepr) -> types.ObjectJsonRep
     if "devopsIntegration" in original_json:
         original_json["devopsIntegration"] = util.dict_to_list(original_json["devopsIntegration"], "name")
     return original_json
+
+
+def export(endpoint: Platform, export_settings: types.ConfigSettings, key_list: types.KeyList = None) -> types.ObjectJsonRepr:
+    """Exports all or a list of projects configuration as dict
+
+    :param Platform endpoint: reference to the SonarQube platform
+    :param ConfigSettings export_settings: Export parameters
+    :param KeyList key_list: Unused
+    :return: Platform settings
+    :rtype: ObjectJsonRepr
+    """
+    return endpoint.export(export_settings)

sonar/portfolios.py

@@ -728,10 +728,10 @@ def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, key_lis
     """Exports portfolios as JSON
 
     :param Platform endpoint: Reference to the SonarQube platform
-    :param KeyList key_list: list of portfoliios keys to export as csv or list, defaults to all if None
     :param ConfigSetting export_settings: Options to use for export
-    :return: Dict of applications settings
-    :rtype: dict
+    :param KeyList key_list: list of portfoliios keys to export as csv or list, defaults to all if None
+    :return: Dict of portfolio settings
+    :rtype: ObjectJsonRepr
     """
     check_supported(endpoint)
 

sonar/projects.py

@@ -1368,8 +1368,8 @@ def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, key_lis
     :param Platform endpoint: reference to the SonarQube platform
     :param ConfigSettings export_settings: Export parameters
     :param KeyList key_list: List of project keys to export, defaults to None (all projects)
-    :return: list of projects
-    :rtype: dict{key: Project}
+    :return: list of projects settings
+    :rtype: ObjectJsonRepr
     """
     for qp in qualityprofiles.get_list(endpoint).values():
         qp.projects()

sonar/qualitygates.py

@@ -380,10 +380,14 @@ def get_list(endpoint: pf.Platform) -> dict[str, QualityGate]:
     return qg_list
 
 
-def export(endpoint: pf.Platform, export_settings: types.ConfigSettings) -> types.ObjectJsonRepr:
-    """
-    :return: The list of quality gates in their JSON representation
-    :rtype: dict
+def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, key_list: types.KeyList = None) -> types.ObjectJsonRepr:
+    """Exports quality gates as JSON
+
+    :param Platform endpoint: Reference to the Sonar platform
+    :param ConfigSetting export_settings: Options to use for export
+    :param KeyList key_list: Unused
+    :return: Quality gates representations as JSON
+    :rtype: ObjectJsonRepr
     """
     log.info("Exporting quality gates")
     return {k: qg.to_json(export_settings) for k, qg in sorted(get_list(endpoint).items())}

sonar/qualityprofiles.py

@@ -579,14 +579,14 @@ def hierarchize(qp_list: dict[str, str], endpoint: pf.Platform) -> types.ObjectJ
     return qp_list
 
 
-def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, in_hierarchy: bool = True) -> types.ObjectJsonRepr:
-    """Exports all quality profiles configuration as dict
+def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, key_list: types.KeyList = None) -> types.ObjectJsonRepr:
+    """Exports all or a list of quality profiles configuration as dict
 
     :param Platform endpoint: reference to the SonarQube platform
-    :param dict export_settings: Export settings
-    :param bool in_hierarchy: Whether quality profiles dict should be organized hierarchically (following inheritance)
-    :return: dict structure of all quality profiles
-    :rtype: dict
+    :param ConfigSettings export_settings: Export parameters
+    :param KeyList key_list: Unused
+    :return: Dict of quality profiles JSON representation
+    :rtype: ObjectJsonRepr
     """
     log.info("Exporting quality profiles")
     qp_list = {}
@@ -598,8 +598,7 @@ def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, in_hier
         if lang not in qp_list:
             qp_list[lang] = {}
         qp_list[lang][name] = json_data
-    if in_hierarchy:
-        qp_list = hierarchize(qp_list, endpoint)
+    qp_list = hierarchize(qp_list, endpoint)
     return dict(sorted(qp_list.items()))
 
 

sonar/rules.py

@@ -287,24 +287,19 @@ def export_needed(endpoint: platform.Platform, instantiated: bool = True, extend
     return utilities.remove_nones(rule_list)
 
 
-def export(
-    endpoint: platform.Platform, export_settings: types.ConfigSettings, instantiated: bool = True, extended: bool = True, standard: bool = False
-) -> types.ObjectJsonRepr:
+def export(endpoint: platform.Platform, export_settings: types.ConfigSettings, key_list: types.KeyList = None) -> types.ObjectJsonRepr:
     """Returns a dict of rules for export
-    :return: a dict of rule onbjects indexed with rule key
     :param Platform endpoint: The SonarQube Platform object to connect to
     :param ConfigSettings export_settings: parameters to export
-    :param bool instantiated: Include instantiated rules in the list
-    :param bool extended: Include extended rules in the list
-    :param bool standard: Include standard rules in the list
-    :param full standard: Include full rule information in the export
-    :rtype: dict{ruleKey: <ruleJson.}
+    :param KeyList key_list: Unused
+    :return: a dict of rules with their JSON representation
+    :rtype: ObjectJsonRepr
     """
     log.info("Exporting rules")
-    if standard:
-        return export_all(endpoint, export_settings["FULL_EXPORT"])
-    else:
-        return export_needed(endpoint, instantiated, extended, export_settings["FULL_EXPORT"])
+    # if standard:
+    return export_all(endpoint, export_settings["FULL_EXPORT"])
+    # else:
+    #    return export_needed(endpoint, instantiated, extended, export_settings["FULL_EXPORT"])
 
 
 def import_config(endpoint: platform.Platform, config_data: types.ObjectJsonRepr, key_list: types.KeyList = None) -> bool:

sonar/users.py

@@ -403,14 +403,14 @@ def search(endpoint: pf.Platform, params: types.ApiParams = None) -> dict[str, U
     return sqobject.search_objects(endpoint=endpoint, object_class=User, params=params)
 
 
-def export(endpoint: pf.Platform, export_settings: types.ConfigSettings) -> types.ObjectJsonRepr:
-    """Exports all users as dict
+def export(endpoint: pf.Platform, export_settings: types.ConfigSettings, key_list: types.KeyList = None) -> types.ObjectJsonRepr:
+    """Exports all users in JSON representation
 
     :param Platform endpoint: reference to the SonarQube platform
-    :param full: Whether to export all settings including those useless for re-import, defaults to False
-    :type full: bool, optional
-    :return: list of projects
-    :rtype: dict{key: Project}
+    :param ConfigSettings export_settings: Export parameters
+    :param KeyList key_list: Unused
+    :return: list of users JSON representation
+    :rtype: ObjectJsonRepr
     """
     log.info("Exporting users")
     u_list = {}