com.smash.revolance.ui.comparator.page.PageMatchMaker.java Source code

Introduction

Here is the source code for com.smash.revolance.ui.comparator.page.PageMatchMaker.java

Source

package com.smash.revolance.ui.comparator.page;

/*
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * ui-monitoring-comparator
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Copyright (C) 2012 - 2014 RevoLance
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * 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/gpl-3.0.html>.
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

import com.smash.revolance.ui.comparator.NoMatchFound;
import com.smash.revolance.ui.model.element.api.ElementBean;
import com.smash.revolance.ui.model.page.api.PageBean;
import org.apache.commons.lang3.ArrayUtils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * User: wsmash
 * Date: 09/06/13
 * Time: 11:07
 */
public class PageMatchMaker implements IPageMatchMaker {
    public PageMatch getBestMatch(final Collection<PageMatch> matches)
            throws IllegalArgumentException, NoMatchFound {
        if (matches == null) {
            throw new IllegalArgumentException("Null collection of matches cannot be parsed.");
        }

        PageMatch bestMatch = new PageMatch();
        for (PageMatch match : matches) {
            if (match.getRate() > bestMatch.getRate()) {
                bestMatch = match;
            }
        }

        if (bestMatch.getMatch() == null) {
            throw new NoMatchFound("Unable to find a match.");
        } else {
            return bestMatch;
        }
    }

    @Override
    public Collection<PageMatch> findMatch(final Collection<PageBean> pages, final PageBean page,
            PageSearchMethod... methods) throws NoMatchFound, IllegalArgumentException {
        if (pages == null) {
            throw new IllegalArgumentException("Null collection of pages to be parsed");
        }
        if (page == null) {
            throw new IllegalArgumentException("Null page cannot be matched.");
        }

        Collection<PageBean> localPages = new ArrayList<PageBean>();
        localPages.addAll(pages);
        if (localPages.contains(page)) {
            pages.remove(page);
        }

        List<PageMatch> matches = getPageMatches(page, localPages, methods);

        if (matches.isEmpty()) {
            throw new NoMatchFound("Unable to find a single match.");
        } else {
            return matches;
        }
    }

    private List<PageMatch> getPageMatches(PageBean page, Collection<PageBean> localPages,
            PageSearchMethod... methods) {
        List<PageMatch> results = new ArrayList<PageMatch>();
        PageBean match = null;

        if (ArrayUtils.contains(methods, PageSearchMethod.URL)) {
            if ((match = findPageByUrl(localPages, page.getUrl())) != null) {
                PageMatch pageMatch = new PageMatch(page);
                pageMatch.setMatch(match, 1);
                results.add(pageMatch);
            }
        }

        if (ArrayUtils.contains(methods, PageSearchMethod.TITLE)) {
            match = null;
            if ((match = findPageByTitle(localPages, page.getTitle())) != null) {
                PageMatch pageMatch = new PageMatch(page);
                pageMatch.setMatch(match, 1);
                results.add(pageMatch);
            }
        }

        if (ArrayUtils.contains(methods, PageSearchMethod.CONTENT)) {
            match = null;
            if ((match = findPageByContentValue(localPages, getContentValue(page.getContent()))) != null) {
                PageMatch pageMatch = new PageMatch(page);
                pageMatch.setMatch(match, 1);
                results.add(pageMatch);
            }
        }

        if (ArrayUtils.contains(methods, PageSearchMethod.LOOK)) {
            match = null;
            if ((match = findPageByLook(localPages, page.getCaption())) != null) {
                PageMatch pageMatch = new PageMatch(page);
                pageMatch.setMatch(match, 1);
                results.add(pageMatch);
            }
        }

        return results;
    }

    public static List<String> getContentValue(Collection<ElementBean> content) {
        List<String> contentValues = new ArrayList<String>();

        for (ElementBean element : content) {
            String contentValue = element.getContent();
            if (contentValue != null && !contentValue.isEmpty()) {
                contentValues.add(contentValue);
            }
        }

        return contentValues;
    }

    public static PageBean findPageByLook(Collection<PageBean> pages, String caption) {
        for (PageBean page : pages) {
            if (page.getCaption().contentEquals(caption)) {
                return page;
            }
        }
        return null;
    }

    public static PageBean findPageByTitle(Collection<PageBean> pages, String title) {
        for (PageBean page : pages) {
            if (page.getTitle().contentEquals(title)) {
                return page;
            }
        }
        return null;
    }

    public static PageBean findPageByUrl(Collection<PageBean> pages, String url) {
        for (PageBean page : pages) {
            if (page.getUrl().toLowerCase().contentEquals(url.toLowerCase())) {
                return page;
            }
        }
        return null;
    }

    public static PageBean findPageByContentValue(Collection<PageBean> pages, List<String> contentValues) {
        for (PageBean page : pages) {
            List<String> pageContentValues = getContentValue(page.getContent());
            for (String value : contentValues) {
                if (pageContentValues.contains(value)) {
                    pageContentValues.remove(value);
                }

                if (pageContentValues.isEmpty()) {
                    break;
                }
            }

            if (pageContentValues.isEmpty()) {
                return page;
            }
        }
        return null;
    }
}