ospd.vtfilter

Complexity

Total Complexity

16

Size/Duplication

Total Lines	113
Duplicated Lines	78.76 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	VtsFilter.parse_filters()	22	22	5
A	VtsFilter.format_filter_value()	6	6	1
A	VtsFilter.__init__()	11	11	1
B	VtsFilter.get_filtered_vts_list()	31	31	7
A	VtsFilter.format_vt_creation_time()	5	5	1
A	VtsFilter.format_vt_modification_time()	5	5	1

# Copyright (C) 2014-2018 Greenbone Networks GmbH
#
# SPDX-License-Identifier: GPL-2.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 2
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

""" Vulnerability Test Filter class.
"""
import re
import operator

class VtsFilter(object):

This code seems to be duplicated in your project.

    """ Helper class to filter Vulnerability Tests """

    def __init__(self):
        """ Initialize filter operator and allowed filters. """
        self.filter_operator = {
            '<': operator.lt,
            '>': operator.gt,
            '=': operator.eq,
        }

        self.allowed_filter = {
            'creation_time': self.format_vt_creation_time,
            'modification_time': self.format_vt_modification_time,
        }

    def parse_filters(self, vt_filter):
        """ Parse a string containing one or more filters
        and return a list of filters

        Arguments:
            vt_filter (string): String containing filters separated with
                semicolon.
        Return:
            List with filters. Each filters is a list with 3 elements
            e.g. [arg, operator, value]
        """

        filter_list = vt_filter.split(';')
        filters = list()
        for single_filter in filter_list:
           filters.append(re.split('(\W)', single_filter, 1))

        for _element, _oper, _val in filters:
            if _element not in self.allowed_filter or _oper not in self.filter_operator:
                filters.remove([_element, _oper, _val])

        return filters

    def format_vt_creation_time(self, value):
        """ In case the given creationdatetime value must be formated,
        this function must be implemented by the wrapper
        """
        return value

    def format_vt_modification_time(self, value):
        """ In case the given modification datetime value must be formated,
        this function must be implemented by the wrapper
        """
        return value

    def format_filter_value(self, element, value):
        """ Calls the specific function to format value,
        depending on the given element.
        """
        format_func = self.allowed_filter.get(element)
        return format_func(value)

    def get_filtered_vts_list(self, vts, vt_filter):
        """ Gets a collection of vulnerability test from the vts dictionary,
        which match the filter.

        Arguments:
            vt_filter (string): Filter to apply to the vts collection.

        Returns:
            Dictionary with filtered vulnerability tests.
        """
        if not vt_filter:
            raise RequiredArgument('vt_filter: A valid filter is required.')

The variable RequiredArgument does not seem to be defined.

        filters = self.parse_filters(vt_filter)
        if not filters:
            return None

        _vts_aux = vts.copy()
        for _element, _oper, _filter_val in filters:
            for vt_id in _vts_aux.copy():
                if not _vts_aux[vt_id].get(_element):
                    _vts_aux.pop(vt_id)
                    continue
                _elem_val = _vts_aux[vt_id].get(_element)
                _val = self.format_filter_value(_element, _elem_val)
                if self.filter_operator[_oper](_val, _filter_val):
                    continue
                else:
                    _vts_aux.pop(vt_id)

        return _vts_aux