Java tutorial
/** * Copyright (c) Codice Foundation * <p> * This is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser * General Public License as published by the Free Software Foundation, either version 3 of the * License, or any later version. * <p> * 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 * Lesser General Public License for more details. A copy of the GNU Lesser General Public License * is distributed along with this program and can be found at * <http://www.gnu.org/licenses/lgpl.html>. */ package ddf.catalog.pubsub.predicate; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.Map; import java.util.regex.Pattern; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.builder.ToStringBuilder; import org.apache.lucene.queryParser.ParseException; import org.apache.lucene.store.Directory; import org.osgi.service.event.Event; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ddf.catalog.pubsub.criteria.contextual.ContextualEvaluationCriteria; import ddf.catalog.pubsub.criteria.contextual.ContextualEvaluationCriteriaImpl; import ddf.catalog.pubsub.criteria.contextual.ContextualEvaluator; import ddf.catalog.pubsub.criteria.contextual.ContextualTokenizer; import ddf.catalog.pubsub.internal.PubSubConstants; public class ContextualPredicate implements Predicate { private static final Logger LOGGER = LoggerFactory.getLogger(ContextualPredicate.class); private String searchPhrase; private boolean fuzzy; private boolean caseSensitiveSearch; private Collection<String> textPaths; public ContextualPredicate(String searchPhrase, boolean fuzzy, boolean caseSensitiveSearch, Collection<String> textPaths) { this.fuzzy = fuzzy; this.caseSensitiveSearch = caseSensitiveSearch; if (textPaths != null && !textPaths.isEmpty()) { LOGGER.debug("text paths size: {}", textPaths.size()); this.textPaths = new ArrayList<String>(textPaths); } this.searchPhrase = normalizePhrase(searchPhrase, fuzzy); } public static boolean isContextual(String searchPhrase) { return !searchPhrase.isEmpty(); } /** * Normalizes a search phrase for a Lucene query * * @param inputPhrase the input phrase * @param isFuzzy true indicates the criteria is fuzzy * @return a search phrase aligned to Lucene syntax */ public static String normalizePhrase(String inputPhrase, boolean isFuzzy) { String phrase = ""; if (inputPhrase != null && !inputPhrase.equals("")) { phrase = inputPhrase.trim(); String parts[] = phrase.split("\""); LOGGER.debug("phrase = [{}] parts.length = {}", phrase, parts.length); // if multiple parts found, then exact (quoted) phrases are present if (parts.length > 1) { // Odd parts are in quotes, i.e., exact (quoted) phrases, so skip them // Even parts are individual words or operators for (int i = 0; i < parts.length; i++) { LOGGER.debug("parts[{}] = {}", i, parts[i]); if (i % 2 == 0) { if (!parts[i].isEmpty()) { parts[i] = normalizeBooleanOperators(parts[i]); parts[i] = escapeSpecialCharacters(parts[i]); if (isFuzzy && !isBooleanOperator(parts[i])) { parts[i] = parts[i] + "~"; parts[i] = parts[i].replace("~~", "~"); LOGGER.debug("Fuzzy Search adding a tilde: {}", parts[i]); } } else { LOGGER.debug("part[{}] was empty", i); } } else { parts[i] = escapeSpecialCharacters(parts[i]); } } StringBuilder phraseBuilder = new StringBuilder(""); for (int i = 0; i < parts.length; i++) { phraseBuilder.append(parts[i]); if (i < (parts.length - 1)) { phraseBuilder.append("\""); } } phrase = phraseBuilder.toString(); } else { LOGGER.debug("parts.length <= 1: phrase = {}", phrase); phrase = normalizeBooleanOperators(phrase); phrase = escapeSpecialCharacters(phrase); if (isFuzzy) { String[] words = phrase.trim().split("[ ]+"); for (int i = 0; i < words.length; i++) { String[] subParts = words[i].split("[\\(\\)]+"); for (String subPart : subParts) { if (!subPart.isEmpty() && !isBooleanOperator(subPart)) { String fuzzySubPart = subPart + "~"; phrase = phrase.replaceFirst(Pattern.quote(subPart), fuzzySubPart); LOGGER.debug("2. Fuzzy Search adding a tilde: {}", subPart); LOGGER.debug("phrase = {}", phrase); } } phrase = phrase.replace("~~", "~"); } LOGGER.debug("2. Fuzzy-fied phrase: {}", phrase); } } // Pass thru the last literal double quote if (inputPhrase.lastIndexOf("\"") == inputPhrase.length() - 1) { phrase = phrase + "\""; } } else { phrase = ""; } LOGGER.debug("Normalization complete. \nBefore: {}\nAfter: {}", inputPhrase, phrase); return phrase; } private static String escapeSpecialCharacters(String phrase) { StringBuilder sb = new StringBuilder(); char[] chars = phrase.trim().toCharArray(); for (int i = 0; i < chars.length; i++) { char currentChar = chars[i]; // * is escaped by the subscription when not a wildcard // if the character has already been manually escaped, don't double escape char nullChar = '\0'; char nextChar = nullChar; if (i + 1 < chars.length) { nextChar = chars[i + 1]; } if (currentChar == '\\' && nextChar != nullChar && ContextualTokenizer.SPECIAL_CHARACTERS_SET.contains(nextChar)) { // these two tokens constitute an escaped character, // so consume them together i = i + 1; sb.append(currentChar); sb.append(nextChar); } else if (currentChar != '*' && ContextualTokenizer.SPECIAL_CHARACTERS_SET.contains(currentChar)) { // handle unescaped special characters sb.append("\\"); sb.append(currentChar); } else { sb.append(currentChar); } } phrase = sb.toString(); return phrase; } /** * Normalize all Boolean operators in the phrase since Lucene grammar requires all boolean * operators to be uppercase. * * @param phrase the input phrase * @return the normalized phrase */ private static String normalizeBooleanOperators(String phrase) { phrase = phrase.replace(" not ", " NOT "); phrase = phrase.replace(" or ", " OR "); phrase = phrase.replace(" and ", " AND "); phrase = phrase.replace(" & ", "AND"); phrase = phrase.replace(" | ", "OR"); return phrase; } private static boolean isBooleanOperator(String input) { int index = StringUtils.indexOfAny(input.trim().toLowerCase(), new String[] { "not", "and", "or", "&", "|" }); return index == 0; } public boolean matches(Event properties) { String methodName = "matches"; LOGGER.debug("ENTERING: {}", methodName); LOGGER.debug("Headers: {}", properties); ContextualEvaluationCriteria cec = null; Map<String, Object> contextualMap = (Map<String, Object>) properties .getProperty(PubSubConstants.HEADER_CONTEXTUAL_KEY); if (contextualMap == null) { LOGGER.debug("No contextual metadata to search against."); return false; } String operation = (String) properties.getProperty(PubSubConstants.HEADER_OPERATION_KEY); LOGGER.debug("operation = {}", operation); String metadata = (String) contextualMap.get("METADATA"); LOGGER.debug("metadata = [{}]", metadata); // If deleting a catalog entry and the entry's metadata is only the word "deleted" (i.e., // the // source is deleting the catalog entry and did not send any metadata with the delete // event), then // cannot apply any contextual filtering - just send the event on to the subscriber if (operation.equals(PubSubConstants.DELETE) && metadata.equals(PubSubConstants.METADATA_DELETED)) { LOGGER.debug( "Detected a DELETE operation where metadata is just the word 'deleted', so send event on to subscriber"); return true; } // If predicate specified one or more text paths, then extract the entry's metadata from the // Event properties and // pass it and the text path(s) to the evaluation criteria (which will build a Lucene index // on the metadata using the // text paths) if (this.textPaths != null && !this.textPaths.isEmpty()) { LOGGER.debug("creating criteria with textPaths and metadata document"); try { cec = new ContextualEvaluationCriteriaImpl(searchPhrase, fuzzy, caseSensitiveSearch, this.textPaths.toArray(new String[this.textPaths.size()]), (String) contextualMap.get("METADATA")); } catch (IOException e) { LOGGER.error("IO exception during context evaluation", e); return false; } // This predicate has no text paths specified, so can use default Lucene search index, which // indexed the entry's entire metadata // per the default XPath expressions in ContextualEvaluator, from the event's properties // data } else { LOGGER.debug("using default Lucene search index for metadata"); cec = new ContextualEvaluationCriteriaImpl(searchPhrase, fuzzy, caseSensitiveSearch, (Directory) contextualMap.get("DEFAULT_INDEX")); } try { return ContextualEvaluator.evaluate(cec); } catch (IOException e) { LOGGER.error("IO Exception evaluating context criteria", e); } catch (ParseException e) { LOGGER.error("Parse Exception evaluating context criteria", e); } LOGGER.debug("EXITING: {}", methodName); return false; } public String getSearchPhrase() { return searchPhrase; } public boolean isFuzzy() { return fuzzy; } public boolean isCaseSensitive() { return caseSensitiveSearch; } public boolean hasTextPaths() { return textPaths != null && !textPaths.isEmpty(); } public Collection<String> getTextPaths() { return textPaths; } public String toString() { return ToStringBuilder.reflectionToString(this); } }