gvm.xml._GmpCommandFactory.modify_target_command() - Code Metrics - Inspection of "Api cleanup: Move last modify_*() xml commands to..." - greenbone/python-gvm - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#35)

by Juan José
created 2018-11-08 15:30 UTC
gvm.xml._GmpCommandFactory.modify_target_command() D

↳ Parent: gvm.xml
Complexity

Conditions
Size

Total Lines	49
Code Lines	36
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	12
eloc	36
nop	3
dl	0
loc	49
rs	4.8
c	0
b	0
f	0
How to fix Complexity

# -*- coding: utf-8 -*-
# Copyright (C) 2018 Greenbone Networks GmbH
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import defusedxml.lxml as secET

from lxml import etree

class XmlCommandElement:

    def __init__(self, element):
        self._element = element

    def add_element(self, name, text=None, attrs=None):
        node = etree.SubElement(self._element, name, attrib=attrs)
        node.text = text
        return XmlCommandElement(node)

    def set_attribute(self, name, value):
        self._element.set(name, value)

    def set_attributes(self, attrs):
        """Set several attributes at once.

        Arguments:
            attrs (dict): Attributes to be set on the element
        """
        for key, value in attrs.items():
            self._element.set(key, value)

    def append_xml_str(self, xml_text):
        """Append a xml element in string format."""
        node = secET.fromstring(xml_text)
        self._element.append(node)

    def to_string(self):
        return etree.tostring(self._element).decode('utf-8')

    def __str__(self):
        return self.to_string()


class XmlCommand(XmlCommandElement):

    def __init__(self, name):
        super().__init__(etree.Element(name))


class _GmpCommandFactory:


    """Factory to create gmp - Greenbone Management Protocol - commands
    """

    def delete_agent_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete agent on gvmd"""
        cmd = XmlCommand('delete_agent')
        for key, value in kwargs.items():
            cmd.set_attribute(key, value)

        return cmd.to_string()

    def delete_alert_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete alert on gvmd"""
        cmd = XmlCommand('delete_alert')
        for key, value in kwargs.items():
            cmd.set_attribute(key, value)

        return cmd.to_string()

    def delete_asset_command(self, asset_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete asset on gvmd"""
        cmd = XmlCommand('delete_asset')
        cmd.set_attribute('asset_id', asset_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_config_command(self, config_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete config on gvmd"""
        cmd = XmlCommand('delete_config')
        cmd.set_attribute('config_id', config_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_credential_command(self, credential_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete credential on gvmd"""
        cmd = XmlCommand('delete_credential')
        cmd.set_attribute('credential_id', credential_id)
        cmd.set_attribute('ultimate', ultimate)
        return cmd.to_string()

    def delete_filter_command(self, filter_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete filter on gvmd"""
        cmd = XmlCommand('delete_filter')
        cmd.set_attribute('filter_id', filter_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_group_command(self, group_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete group on gvmd"""
        cmd = XmlCommand('delete_group')
        cmd.set_attribute('group_id', group_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_note_command(self, note_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete note on gvmd"""
        cmd = XmlCommand('delete_note')
        cmd.set_attribute('note_id', note_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_override_command(self, override_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete override on gvmd"""
        cmd = XmlCommand('delete_override')
        cmd.set_attribute('override_id', override_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_permission_command(self, permission_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete permission on gvmd"""
        cmd = XmlCommand('delete_permission')
        cmd.set_attribute('permission_id', permission_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_port_list_command(self, port_list_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete port on gvmd"""
        cmd = XmlCommand('delete_port_list')
        cmd.set_attribute('port_list_id', port_list_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_port_range_command(self, port_range_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete port on gvmd"""
        cmd = XmlCommand('delete_port_range')
        cmd.set_attribute('port_range_id', port_range_id)

        return cmd.to_string()

    def delete_report_command(self, report_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete report on gvmd"""
        cmd = XmlCommand('delete_report')
        cmd.set_attribute('report_id', report_id)

        return cmd.to_string()

    def delete_report_format_command(self, report_format_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete report on gvmd"""
        cmd = XmlCommand('delete_report_format')
        cmd.set_attribute('report_format_id', report_format_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_role_command(self, role_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete role on gvmd"""
        cmd = XmlCommand('delete_role')
        cmd.set_attribute('role_id', role_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_scanner_command(self, scanner_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete scanner on gvmd"""
        cmd = XmlCommand('delete_scanner')
        cmd.set_attribute('scanner_id', scanner_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_schedule_command(self, schedule_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete schedule on gvmd"""
        # if self.ask_yes_or_no('Are you sure to delete this schedule? '):
        cmd = XmlCommand('delete_schedule')
        cmd.set_attribute('schedule_id', schedule_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_tag_command(self, tag_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete tag on gvmd"""
        cmd = XmlCommand('delete_tag')
        cmd.set_attribute('tag_id', tag_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_target_command(self, target_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete target on gvmd"""
        cmd = XmlCommand('delete_target')
        cmd.set_attribute('target_id', target_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_task_command(self, task_id, ultimate=0):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete task on gvmd"""
        cmd = XmlCommand('delete_task')
        cmd.set_attribute('task_id', task_id)
        cmd.set_attribute('ultimate', ultimate)

        return cmd.to_string()

    def delete_user_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for delete user on gvmd"""
        cmd = XmlCommand('delete_user')

        user_id = kwargs.get('user_id', '')
        if user_id:
            cmd.set_attribute('user_id', user_id)

        name = kwargs.get('name', '')
        if name:
            cmd.set_attribute('name', name)

        inheritor_id = kwargs.get('inheritor_id', '')
        if inheritor_id:
            cmd.set_attribute('inheritor_id', inheritor_id)

        inheritor_name = kwargs.get('inheritor_name', '')
        if inheritor_name:
            cmd.set_attribute('inheritor_name', inheritor_name)

        return cmd.to_string()

    def get_assets_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get assets on gvmd."""
        cmd = XmlCommand('get_assets')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_credentials_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get credentials on gvmd."""
        cmd = XmlCommand('get_credentials')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_configs_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get configs on gvmd."""
        cmd = XmlCommand('get_configs')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_feeds_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get feeds on gvmd."""
        cmd = XmlCommand('get_feeds')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_filters_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get filters on gvmd."""
        cmd = XmlCommand('get_filters')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_groups_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get groups on gvmd."""
        cmd = XmlCommand('get_groups')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_info_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get info on gvmd."""
        cmd = XmlCommand('get_info')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_notes_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get notes on gvmd."""
        cmd = XmlCommand('get_notes')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_nvts_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get nvts on gvmd."""
        cmd = XmlCommand('get_nvts')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_nvt_families_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get nvt on gvmd."""
        cmd = XmlCommand('get_nvt_families')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_overrides_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get overrides on gvmd."""
        cmd = XmlCommand('get_overrides')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_permissions_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get permissions on gvmd."""
        cmd = XmlCommand('get_permissions')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_port_lists_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get port on gvmd."""
        cmd = XmlCommand('get_port_lists')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_preferences_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get preferences on gvmd."""
        cmd = XmlCommand('get_preferences')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_reports_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get reports on gvmd."""
        cmd = XmlCommand('get_reports')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_report_formats_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get report on gvmd."""
        cmd = XmlCommand('get_report_formats')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_results_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get results on gvmd."""
        cmd = XmlCommand('get_results')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_roles_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get roles on gvmd."""
        cmd = XmlCommand('get_roles')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_scanners_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get scanners on gvmd."""
        cmd = XmlCommand('get_scanners')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_schedules_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get schedules on gvmd."""
        cmd = XmlCommand('get_schedules')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_settings_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get settings on gvmd."""
        cmd = XmlCommand('get_settings')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_system_reports_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get system on gvmd."""
        cmd = XmlCommand('get_system')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_tags_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get tags on gvmd."""
        cmd = XmlCommand('get_tags')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_targets_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get targets on gvmd."""
        cmd = XmlCommand('get_targets')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_tasks_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get tasks on gvmd."""
        cmd = XmlCommand('get_tasks')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def get_users_command(self, kwargs):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for get users on gvmd."""
        cmd = XmlCommand('get_users')
        cmd.set_attributes(kwargs)
        return cmd.to_string()

    def move_task_command(self, task_id, slave_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for move task on gvmd."""
        cmd = XmlCommand('move_task')
        cmd.set_attribute('task_id', task_id)
        cmd.set_attribute('slave_id', slave_id)
        return cmd.to_string()

    def restore_command(self, entity_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for restore on gvmd."""
        cmd = XmlCommand('restore')
        cmd.set_attribute('id', entity_id)
        return cmd.to_string()

    def resume_task_command(self, task_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for resume task on gvmd."""
        cmd = XmlCommand('resume_task')
        cmd.set_attribute('task_id', task_id)
        return cmd.to_string()

    def start_task_command(self, task_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for start task on gvmd."""
        cmd = XmlCommand('start_task')
        cmd.set_attribute('task_id', task_id)
        return cmd.to_string()

    def stop_task_command(self, task_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for stop task on gvmd."""
        cmd = XmlCommand('stop_task')
        cmd.set_attribute('task_id', task_id)
        return cmd.to_string()

    def test_alert_command(self, alert_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for test alert on gvmd."""
        cmd = XmlCommand('test_alert')
        cmd.set_attribute('alert_id', alert_id)
        return cmd.to_string()

    def verify_agent_command(self, agent_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for verify agent on gvmd."""
        cmd = XmlCommand('verify_agent')
        cmd.set_attribute('agent_id', agent_id)
        return cmd.to_string()

    def verify_report_format_command(self, report_format_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for verify report format on gvmd."""
        cmd = XmlCommand('verify_report_format')
        cmd.set_attribute('report_format_id', report_format_id)
        return cmd.to_string()

    def verify_scanner_command(self, scanner_id):
class Foo:
    def some_method(self, x, y):
        return x + y;
        """Generates xml string for verify scanner on gvmd."""
        cmd = XmlCommand('verify_scanner')
        cmd.set_attribute('scanner_id', scanner_id)
        return cmd.to_string()


def pretty_print(xml):
    """Prints beautiful XML-Code

    This function gets an object of list<lxml.etree._Element>
    or directly a lxml element.
    Print it with good readable format.

    Arguments:
        xml: List<lxml.etree.Element> or directly a lxml element
    """
    if isinstance(xml, list):
        for item in xml:
            if etree.iselement(item):
                print(etree.tostring(item, pretty_print=True).decode('utf-8'))
            else:
                print(item)
    elif etree.iselement(xml):
        print(etree.tostring(xml, pretty_print=True).decode('utf-8'))

1			# -- coding: utf-8 --
2			# Copyright (C) 2018 Greenbone Networks GmbH
3			#
4			# SPDX-License-Identifier: GPL-3.0-or-later
5			#
6			# This program is free software: you can redistribute it and/or modify
7			# it under the terms of the GNU General Public License as published by
8			# the Free Software Foundation, either version 3 of the License, or
9			# (at your option) any later version.
10			#
11			# This program is distributed in the hope that it will be useful,
12			# but WITHOUT ANY WARRANTY; without even the implied warranty of
13			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			# GNU General Public License for more details.
15			#
16			# You should have received a copy of the GNU General Public License
17			# along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19			import defusedxml.lxml as secET
20
21			from lxml import etree
22
23			class XmlCommandElement:
24
25			def __init__(self, element):
26			self._element = element
27
28			def add_element(self, name, text=None, attrs=None):
29			node = etree.SubElement(self._element, name, attrib=attrs)
30			node.text = text
31			return XmlCommandElement(node)
32
33			def set_attribute(self, name, value):
34			self._element.set(name, value)
35
36			def set_attributes(self, attrs):
37			"""Set several attributes at once.
38
39			Arguments:
40			attrs (dict): Attributes to be set on the element
greenbone / python-gvm

Pull Request — master (#35)

gvm.xml._GmpCommandFactory.modify_target_command() D

Complexity

Size

Duplication

Importance

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like
