vulnerabilityutil.java

来自「opennms得相关源码 请大家看看」· Java 代码 · 共 467 行 · 第 1/2 页

        return (VulnerabilityFactory.ResolutionType) resTypes.get(resTypeString.toLowerCase());
    }

    public static String getResolutionTypeString(VulnerabilityFactory.ResolutionType resType) {
        if (resType == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return (String) resTypes.get(resType);
    }

    public static Filter getFilter(String filterString) {
        if (filterString == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        Filter filter = null;

        StringTokenizer tokens = new StringTokenizer(filterString, "=");
        String type = tokens.nextToken();
        String value = tokens.nextToken();

        if (type.equals(SeverityFilter.TYPE)) {
            filter = new SeverityFilter(Integer.parseInt(value));
        } else if (type.equals(NodeFilter.TYPE)) {
            filter = new NodeFilter(Integer.parseInt(value));
        } else if (type.equals(NodeNameLikeFilter.TYPE)) {
            filter = new NodeNameLikeFilter(value);
        } else if (type.equals(InterfaceFilter.TYPE)) {
            filter = new InterfaceFilter(value);
        } else if (type.equals(NegativeSeverityFilter.TYPE)) {
            filter = new NegativeSeverityFilter(Integer.parseInt(value));
        } else if (type.equals(NegativeNodeFilter.TYPE)) {
            filter = new NegativeNodeFilter(Integer.parseInt(value));
        } else if (type.equals(NegativeInterfaceFilter.TYPE)) {
            filter = new NegativeInterfaceFilter(value);
        } else if (type.equals(IPLikeFilter.TYPE)) {
            filter = new IPLikeFilter(value);
        } else if (type.equals(ProtocolFilter.TYPE)) {
            filter = new ProtocolFilter(value);
        } else if (type.equals(NegativeProtocolFilter.TYPE)) {
            filter = new NegativeProtocolFilter(value);
        } else if (type.equals(PortFilter.TYPE)) {
            filter = new PortFilter(Integer.parseInt(value));
        } else if (type.equals(NegativePortFilter.TYPE)) {
            filter = new NegativePortFilter(Integer.parseInt(value));
        } else if (type.equals(CreationDateBeforeFilter.TYPE)) {
            filter = new CreationDateBeforeFilter(Long.parseLong(value));
        } else if (type.equals(CreationDateAfterFilter.TYPE)) {
            filter = new CreationDateAfterFilter(Long.parseLong(value));
        } else if (type.equals(ResolvedDateBeforeFilter.TYPE)) {
            filter = new ResolvedDateBeforeFilter(Long.parseLong(value));
        } else if (type.equals(ResolvedDateAfterFilter.TYPE)) {
            filter = new ResolvedDateAfterFilter(Long.parseLong(value));
        }

        /*
         * else if( type.equals( ServiceFilter.TYPE )) { filter = new
         * ServiceFilter( Integer.parseInt( value )); } else if( type.equals(
         * NegativeServiceFilter.TYPE )) { filter = new NegativeServiceFilter(
         * Integer.parseInt( value )); } else if( type.equals(
         * LogMessageSubstringFilter.TYPE )) { filter = new
         * LogMessageSubstringFilter( value ); } else if( type.equals(
         * LogMessageMatchesAnyFilter.TYPE )) { filter = new
         * LogMessageMatchesAnyFilter(value); }
         */

        return (filter);
    }

    public static String getFilterString(Filter filter) {
        if (filter == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return (filter.getDescription());
    }

    protected static final String[] LINK_IGNORES = new String[] { "sortby", "restype", "limit", "multiple", "filter" };

    public static String makeLink(HttpServletRequest request, VulnerabilityFactory.SortStyle sortStyle, VulnerabilityFactory.ResolutionType resType, ArrayList filters, int limit) {
        if (request == null || sortStyle == null || resType == null || filters == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        if (limit < 1) {
            throw new IllegalArgumentException("Cannot take a zero or negative limit value.");
        }

        HashMap additions = new HashMap();
        additions.put("sortby", VulnerabilityUtil.getSortStyleString(sortStyle));
        additions.put("restype", VulnerabilityUtil.getResolutionTypeString(resType));
        additions.put("limit", Integer.toString(limit));

        if (filters != null) {
            String[] filterStrings = new String[filters.size()];

            for (int i = 0; i < filters.size(); i++) {
                filterStrings[i] = VulnerabilityUtil.getFilterString((Filter) filters.get(i));
            }

            additions.put("filter", filterStrings);
        }

        return FILTER_SERVLET_URL_BASE + "?" + Util.makeQueryString(request, additions, LINK_IGNORES, Util.IgnoreType.REQUEST_ONLY);
    }

    public static String makeLink(HttpServletRequest request, VulnerabilityQueryParms parms) {
        if (request == null || parms == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return makeLink(request, parms.sortStyle, parms.resType, parms.filters, parms.limit);
    }

    public static String makeLink(HttpServletRequest request, VulnerabilityQueryParms parms, VulnerabilityFactory.SortStyle sortStyle) {
        if (request == null || parms == null || sortStyle == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return makeLink(request, sortStyle, parms.resType, parms.filters, parms.limit);
    }

    public static String makeLink(HttpServletRequest request, VulnerabilityQueryParms parms, VulnerabilityFactory.ResolutionType resType) {
        if (request == null || parms == null || resType == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return makeLink(request, parms.sortStyle, resType, parms.filters, parms.limit);
    }

    public static String makeLink(HttpServletRequest request, VulnerabilityQueryParms parms, ArrayList filters) {
        if (request == null || parms == null || filters == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return makeLink(request, parms.sortStyle, parms.resType, filters, parms.limit);
    }

    public static String makeLink(HttpServletRequest request, VulnerabilityQueryParms parms, Filter filter, boolean add) {
        if (request == null || parms == null || filter == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        ArrayList newList = new ArrayList(parms.filters);

        if (add) {
            newList.add(filter);
        } else {
            newList.remove(filter);
        }

        return makeLink(request, parms.sortStyle, parms.resType, newList, parms.limit);
    }

    public static String makeHiddenTags(HttpServletRequest request, VulnerabilityFactory.SortStyle sortStyle, VulnerabilityFactory.ResolutionType resType, ArrayList filters, int limit) {
        if (request == null || sortStyle == null || resType == null || filters == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        if (limit < 1) {
            throw new IllegalArgumentException("Cannot take a zero or negative limit value.");
        }

        HashMap additions = new HashMap();
        additions.put("sortby", VulnerabilityUtil.getSortStyleString(sortStyle));
        additions.put("restype", VulnerabilityUtil.getResolutionTypeString(resType));
        additions.put("limit", Integer.toString(limit));

        if (filters != null) {
            String[] filterStrings = new String[filters.size()];

            for (int i = 0; i < filters.size(); i++) {
                filterStrings[i] = VulnerabilityUtil.getFilterString((Filter) filters.get(i));
            }

            additions.put("filter", filterStrings);
        }

        return Util.makeHiddenTags(request, additions, LINK_IGNORES, Util.IgnoreType.REQUEST_ONLY);
    }

    public static String makeHiddenTags(HttpServletRequest request, VulnerabilityQueryParms parms) {
        if (request == null || parms == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return makeHiddenTags(request, parms.sortStyle, parms.resType, parms.filters, parms.limit);
    }

    public static String makeHiddenTags(HttpServletRequest request, VulnerabilityQueryParms parms, VulnerabilityFactory.SortStyle sortStyle) {
        if (request == null || parms == null || sortStyle == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return makeHiddenTags(request, sortStyle, parms.resType, parms.filters, parms.limit);
    }

    public static String makeHiddenTags(HttpServletRequest request, VulnerabilityQueryParms parms, VulnerabilityFactory.ResolutionType resType) {
        if (request == null || parms == null || resType == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return makeHiddenTags(request, parms.sortStyle, resType, parms.filters, parms.limit);
    }

    public static String makeHiddenTags(HttpServletRequest request, VulnerabilityQueryParms parms, ArrayList filters) {
        if (request == null || parms == null || filters == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        return makeHiddenTags(request, parms.sortStyle, parms.resType, filters, parms.limit);
    }

    public static String makeHiddenTags(HttpServletRequest request, VulnerabilityQueryParms parms, Filter filter, boolean add) {
        if (request == null || parms == null || filter == null) {
            throw new IllegalArgumentException("Cannot take null parameters.");
        }

        ArrayList newList = new ArrayList(parms.filters);

        if (add) {
            newList.add(filter);
        } else {
            newList.remove(filter);
        }

        return makeHiddenTags(request, parms.sortStyle, parms.resType, newList, parms.limit);
    }

}