Fixed cognitive complexity issues reported by SonarQube.

web/pgadmin/browser/server_groups/servers/__init__.py

@@ -295,24 +295,25 @@ class ServerNode(PGChildNodeView):
             required_ssl_fields_server_mode = ['sslcert', 'sslkey']
 
             for field in ssl_fields:
-                if field not in data:
+                if field in data:
+                    continue
+                elif config.SERVER_MODE and \
+                        field in required_ssl_fields_server_mode:
                     # In Server mode,
                     # we will set dummy SSL certificate file path which will
                     # prevent using default SSL certificates from web servers
 
-                    if config.SERVER_MODE and \
+                    # Set file manager directory from preference
-                            field in required_ssl_fields_server_mode:
+                    import os
-                        # Set file manager directory from preference
+                    file_extn = '.key' if field.endswith('key') else '.crt'
-                        import os
+                    dummy_ssl_file = os.path.join(
-                        file_extn = '.key' if field.endswith('key') else '.crt'
+                        '<STORAGE_DIR>', '.postgresql',
-                        dummy_ssl_file = os.path.join(
+                        'postgresql' + file_extn
-                            '<STORAGE_DIR>', '.postgresql',
+                    )
-                            'postgresql' + file_extn
+                    data[field] = dummy_ssl_file
-                        )
-                        data[field] = dummy_ssl_file
                     # For Desktop mode, we will allow to default
-                    else:
+                else:
-                        data[field] = None
+                    data[field] = None
 
         return flag, data
 
@@ -534,28 +535,10 @@ class ServerNode(PGChildNodeView):
         conn = manager.connection()
         connected = conn.connected()
 
-        if connected:
+        self._server_modify_disallowed_when_connected(
-            for arg in (
+            connected, data, disp_lbl)
-                    'hostaddr', 'db', 'sslmode',
-                    'role', 'service'
-            ):
-                if arg in data:
-                    return forbidden(
-                        errmsg=gettext(
-                            "'{0}' is not allowed to modify, "
-                            "when server is connected."
-                        ).format(disp_lbl[arg])
-                    )
 
-        for arg in config_param_map:
+        idx = self._set_valid_attr_value(data, config_param_map, server)
-            if arg in data:
-                value = data[arg]
-                # sqlite3 do not have boolean type so we need to convert
-                # it manually to integer
-                if arg == 'sslcompression':
-                    value = 1 if value else 0
-                setattr(server, config_param_map[arg], value)
-                idx += 1
 
         if idx == 0:
             return make_json_response(
@@ -591,6 +574,37 @@ class ServerNode(PGChildNodeView):
             )
         )
 
+    def _set_valid_attr_value(self, data, config_param_map, server):
+
+        idx = 0
+        for arg in config_param_map:
+            if arg in data:
+                value = data[arg]
+                # sqlite3 do not have boolean type so we need to convert
+                # it manually to integer
+                if arg == 'sslcompression':
+                    value = 1 if value else 0
+                setattr(server, config_param_map[arg], value)
+                idx += 1
+
+        return idx
+
+    def _server_modify_disallowed_when_connected(
+            self, connected, data, disp_lbl):
+
+        if connected:
+            for arg in (
+                    'hostaddr', 'db', 'sslmode',
+                    'role', 'service'
+            ):
+                if arg in data:
+                    return forbidden(
+                        errmsg=gettext(
+                            "'{0}' is not allowed to modify, "
+                            "when server is connected."
+                        ).format(disp_lbl[arg])
+                    )
+
     @login_required
     def list(self, gid):
         """

web/pgadmin/browser/server_groups/servers/databases/event_triggers/__init__.py

@@ -623,34 +623,39 @@ class EventTriggerView(PGChildNodeView):
                 data=data, o_data=old_data
             )
         else:
-            required_args = {
+            sql = self._get_create_with_grant_sql(data)
-                'name': 'Name',
+        return sql
-                'eventowner': 'Owner',
+
-                'eventfunname': 'Trigger function',
+    def _get_create_with_grant_sql(self, data):
-                'enabled': 'Enabled status',
+
-                'eventname': 'Events'
+        required_args = {
-            }
+            'name': 'Name',
-            err = []
+            'eventowner': 'Owner',
-            for arg in required_args:
+            'eventfunname': 'Trigger function',
-                if arg not in data:
+            'enabled': 'Enabled status',
-                    err.append(required_args.get(arg, arg))
+            'eventname': 'Events'
-            if err:
+        }
-                return make_json_response(
+        err = []
-                    status=410,
+        for arg in required_args:
-                    success=0,
+            if arg not in data:
-                    errormsg=gettext(
+                err.append(required_args.get(arg, arg))
-                        "Could not find the required parameter ({})."
+        if err:
-                    ).format(arg)
+            return make_json_response(
-                )
+                status=410,
-            sql = render_template(
+                success=0,
-                "/".join([self.template_path, 'create.sql']),
+                errormsg=gettext(
-                data=data
+                    "Could not find the required parameter ({})."
-            )
+                ).format(arg)
-            sql += "\n"
-            sql += render_template(
-                "/".join([self.template_path, 'grant.sql']),
-                data=data
             )
+        sql = render_template(
+            "/".join([self.template_path, 'create.sql']),
+            data=data
+        )
+        sql += "\n"
+        sql += render_template(
+            "/".join([self.template_path, 'grant.sql']),
+            data=data
+        )
         return sql
 
     @check_precondition