Java tutorial
/** * Copyright (C) 2005-2008 Jive Software. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.jivesoftware.openfire.plugin; import java.io.File; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.Hashtable; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.TreeMap; import org.dom4j.DocumentHelper; import org.dom4j.Element; import org.dom4j.QName; import org.jivesoftware.openfire.XMPPServer; import org.jivesoftware.openfire.container.Plugin; import org.jivesoftware.openfire.container.PluginManager; import org.jivesoftware.openfire.disco.IQDiscoInfoHandler; import org.jivesoftware.openfire.disco.IQDiscoItemsHandler; import org.jivesoftware.openfire.group.Group; import org.jivesoftware.openfire.group.GroupManager; import org.jivesoftware.openfire.user.User; import org.jivesoftware.openfire.user.UserManager; import org.jivesoftware.util.JiveGlobals; import org.jivesoftware.util.LocaleUtils; import org.jivesoftware.util.PropertyEventDispatcher; import org.jivesoftware.util.PropertyEventListener; import org.jivesoftware.util.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.xmpp.component.Component; import org.xmpp.component.ComponentException; import org.xmpp.component.ComponentManager; import org.xmpp.component.ComponentManagerFactory; import org.xmpp.forms.DataForm; import org.xmpp.forms.FormField; import org.xmpp.packet.IQ; import org.xmpp.packet.IQ.Type; import org.xmpp.packet.JID; import org.xmpp.packet.Packet; import org.xmpp.packet.PacketError; import org.xmpp.packet.PacketError.Condition; import org.xmpp.resultsetmanagement.ResultSet; import org.xmpp.resultsetmanagement.ResultSetImpl; /** * Provides support for Jabber Search (<a href="http://www.xmpp.org/extensions/xep-0055.html">XEP-0055</a>). * <p> * * The basic functionality is to query an information repository regarding the possible search fields, to send a search query, and to * receive search results. This implementation was primarily designed to use <a href="http://www.xmpp.org/extensions/xep-0004.html">Data * Forms</a>, but also supports non-dataform searches. * <p/> * * @author <a href="mailto:ryan@version2software.com">Ryan Graham</a> */ public class SearchPlugin implements Component, Plugin, PropertyEventListener { private static final Logger Log = LoggerFactory.getLogger(SearchPlugin.class); public static final String NAMESPACE_JABBER_IQ_SEARCH = "jabber:iq:search"; public static final String SERVICENAME = "plugin.search.serviceName"; public static final String SERVICEENABLED = "plugin.search.serviceEnabled"; public static final String EXCLUDEDFIELDS = "plugin.search.excludedFields"; public static final String GROUPONLY = "plugin.search.groupOnly"; private UserManager userManager; private ComponentManager componentManager; private PluginManager pluginManager; private String serviceName; private boolean serviceEnabled; private Collection<String> excludedFields; private boolean groupOnly; private static String serverName; private TreeMap<String, String> fieldLookup = new TreeMap<String, String>(new CaseInsensitiveComparator()); private Map<String, String> reverseFieldLookup = new HashMap<String, String>(); /** * A list of field names that are valid in jabber:iq:search */ public final static Collection<String> validSearchRequestFields = new ArrayList<String>(); static { validSearchRequestFields.add("first"); validSearchRequestFields.add("last"); validSearchRequestFields.add("nick"); validSearchRequestFields.add("email"); validSearchRequestFields.add("x"); // extended info // result set management (XEP-0059) validSearchRequestFields.add("set"); } public SearchPlugin() { serviceName = JiveGlobals.getProperty(SERVICENAME, "search"); serviceEnabled = JiveGlobals.getBooleanProperty(SERVICEENABLED, true); excludedFields = StringUtils.stringToCollection(JiveGlobals.getProperty(EXCLUDEDFIELDS, "")); groupOnly = JiveGlobals.getBooleanProperty(GROUPONLY); serverName = XMPPServer.getInstance().getServerInfo().getXMPPDomain(); userManager = UserManager.getInstance(); // Some clients, such as Miranda, are hard-coded to search specific fields, // so we map those fields to the fields that Openfire actually supports. fieldLookup.put("jid", "Username"); fieldLookup.put("username", "Username"); fieldLookup.put("first", "Name"); fieldLookup.put("last", "Name"); fieldLookup.put("nick", "Name"); fieldLookup.put("name", "Name"); fieldLookup.put("email", "Email"); } /* * (non-Javadoc) * * @see org.xmpp.component.Component#getName() */ public String getName() { return pluginManager.getName(this); } /* * (non-Javadoc) * * @see org.xmpp.component.Component#getDescription() */ public String getDescription() { return pluginManager.getDescription(this); } /* * (non-Javadoc) * * @see org.jivesoftware.openfire.container.Plugin#initializePlugin(org.jivesoftware.openfire.container.PluginManager, java.io.File) */ public void initializePlugin(PluginManager manager, File pluginDirectory) { pluginManager = manager; componentManager = ComponentManagerFactory.getComponentManager(); try { componentManager.addComponent(serviceName, this); } catch (ComponentException e) { Log.error(e.getMessage(), e); } PropertyEventDispatcher.addListener(this); } /* * (non-Javadoc) * * @see org.xmpp.component.Component#initialize(org.xmpp.packet.JID, org.xmpp.component.ComponentManager) */ public void initialize(JID jid, ComponentManager componentManager) { } /* * (non-Javadoc) * * @see org.xmpp.component.Component#start() */ public void start() { } /* * (non-Javadoc) * * @see org.jivesoftware.openfire.container.Plugin#destroyPlugin() */ public void destroyPlugin() { PropertyEventDispatcher.removeListener(this); pluginManager = null; try { componentManager.removeComponent(serviceName); componentManager = null; } catch (Exception e) { if (componentManager != null) { Log.error(e.getMessage(), e); } } serviceName = null; userManager = null; excludedFields = null; serverName = null; fieldLookup = null; reverseFieldLookup = null; } /* * (non-Javadoc) * * @see org.xmpp.component.Component#shutdown() */ public void shutdown() { } /* * (non-Javadoc) * * @see org.xmpp.component.Component#processPacket(org.xmpp.packet.Packet) */ public void processPacket(Packet p) { if (!(p instanceof IQ)) { return; } final IQ packet = (IQ) p; if (packet.getType().equals(IQ.Type.error) || packet.getType().equals(IQ.Type.result)) { return; } // Packet p is an IQ stanza of type GET or SET. Therefor, it _must_ be // replied to. final IQ replyPacket = handleIQRequest(packet); try { componentManager.sendPacket(this, replyPacket); } catch (ComponentException e) { Log.error(e.getMessage(), e); } } /** * Handles IQ requests. This method throws an IllegalArgumentException if an IQ stanza is supplied that is not a request (if the stanza * is not of type 'get' or 'set'). This method will either throw an Exception, or return a non-null IQ stanza of type 'error' or * 'result', as XMPP Core specifies that <strong>all</strong> IQ request stanza's (type 'get' or 'set') MUST be replied to. * * @param iq * The IQ stanza that forms the request. * @return The response to the request. */ private IQ handleIQRequest(IQ iq) { final IQ replyPacket; // 'final' to ensure that it is set. if (iq == null) { throw new IllegalArgumentException("Argument 'iq' cannot be null."); } final IQ.Type type = iq.getType(); if (type != IQ.Type.get && type != IQ.Type.set) { throw new IllegalArgumentException("Argument 'iq' must be of type 'get' or 'set'"); } final Element childElement = iq.getChildElement(); if (childElement == null) { replyPacket = IQ.createResultIQ(iq); replyPacket.setError(new PacketError(Condition.bad_request, org.xmpp.packet.PacketError.Type.modify, "IQ stanzas of type 'get' and 'set' MUST contain one and only one child element (RFC 3920 section 9.2.3).")); return replyPacket; } final String namespace = childElement.getNamespaceURI(); if (namespace == null) { replyPacket = IQ.createResultIQ(iq); replyPacket.setError(Condition.feature_not_implemented); return replyPacket; } if (namespace.equals(NAMESPACE_JABBER_IQ_SEARCH)) { replyPacket = handleSearchRequest(iq); } else if (namespace.equals(IQDiscoInfoHandler.NAMESPACE_DISCO_INFO)) { replyPacket = handleDiscoInfo(iq); } else if (namespace.equals(IQDiscoItemsHandler.NAMESPACE_DISCO_ITEMS)) { replyPacket = IQ.createResultIQ(iq); replyPacket.setChildElement("query", IQDiscoItemsHandler.NAMESPACE_DISCO_ITEMS); } else { // don't known what to do with this. replyPacket = IQ.createResultIQ(iq); replyPacket.setError(Condition.feature_not_implemented); } return replyPacket; } /** * Creates a response specific to the search plugin to Disco#Info requests. * * @param iq * The IQ stanza that contains the request. * @return An IQ stanza, formulated as an answer to the received request. */ private static IQ handleDiscoInfo(IQ iq) { if (iq == null) { throw new IllegalArgumentException("Argument 'iq' cannot be null."); } if (!iq.getChildElement().getNamespaceURI().equals(IQDiscoInfoHandler.NAMESPACE_DISCO_INFO) || iq.getType() != Type.get) { throw new IllegalArgumentException("This is not a valid disco#info request."); } final IQ replyPacket = IQ.createResultIQ(iq); final Element responseElement = replyPacket.setChildElement("query", IQDiscoInfoHandler.NAMESPACE_DISCO_INFO); responseElement.addElement("identity").addAttribute("category", "directory").addAttribute("type", "user") .addAttribute("name", "User Search"); responseElement.addElement("feature").addAttribute("var", NAMESPACE_JABBER_IQ_SEARCH); responseElement.addElement("feature").addAttribute("var", IQDiscoInfoHandler.NAMESPACE_DISCO_INFO); responseElement.addElement("feature").addAttribute("var", ResultSet.NAMESPACE_RESULT_SET_MANAGEMENT); return replyPacket; } private IQ handleSearchRequest(IQ packet) { if (!serviceEnabled) { return replyDisabled(packet); } switch (packet.getType()) { case get: return processGetPacket(packet); case set: return processSetPacket(packet); default: // we can safely ignore 'error' and 'result' typed iq stanzas. return null; } } /** * Constructs a IQ result stanza, based on the request stanza that is provided as an argument. The stanza tells the recipient that this * service is currently unavailable. * * @param packet * The request IQ stanza to which a result will be returned. * @return A result stanza, telling the user that this service is unavailable. */ private static IQ replyDisabled(IQ packet) { IQ replyPacket = IQ.createResultIQ(packet); Element reply = replyPacket.setChildElement("query", NAMESPACE_JABBER_IQ_SEARCH); final DataForm unavailableForm = new DataForm(DataForm.Type.cancel); unavailableForm.setTitle(LocaleUtils.getLocalizedString("advance.user.search.title", "search")); unavailableForm.addInstruction(LocaleUtils.getLocalizedString("search.service_unavailable", "search")); reply.add(unavailableForm.getElement()); return replyPacket; } /** * Processes an IQ stanza of type 'get', which in the context of 'Jabber Search' is a request for available search fields. * * @param packet * An IQ stanza of type 'get' * @return A result IQ stanza that contains the possbile search fields. */ private IQ processGetPacket(IQ packet) { if (!packet.getType().equals(IQ.Type.get)) { throw new IllegalArgumentException("This method only accepts 'get' typed IQ stanzas as an argument."); } IQ replyPacket = IQ.createResultIQ(packet); Element queryResult = DocumentHelper.createElement(QName.get("query", NAMESPACE_JABBER_IQ_SEARCH)); String instructions = LocaleUtils.getLocalizedString("advance.user.search.details", "search"); // non-data form queryResult.addElement("instructions").addText(instructions); queryResult.addElement("first"); queryResult.addElement("last"); queryResult.addElement("nick"); queryResult.addElement("email"); DataForm searchForm = new DataForm(DataForm.Type.form); searchForm.setTitle(LocaleUtils.getLocalizedString("advance.user.search.title", "search")); searchForm.addInstruction(instructions); searchForm.addField("FORM_TYPE", null, FormField.Type.hidden).addValue(NAMESPACE_JABBER_IQ_SEARCH); searchForm.addField("search", LocaleUtils.getLocalizedString("advance.user.search.search", "search"), FormField.Type.text_single).setRequired(true); for (String searchField : getFilteredSearchFields()) { final FormField field = searchForm.addField(); field.setVariable(searchField); field.setType(FormField.Type.boolean_type); field.addValue("1"); field.setLabel( LocaleUtils.getLocalizedString("advance.user.search." + searchField.toLowerCase(), "search")); field.setRequired(false); } queryResult.add(searchForm.getElement()); replyPacket.setChildElement(queryResult); return replyPacket; } /** * Processes an IQ stanza of type 'set', which in the context of 'Jabber Search' is a search request. * * @param packet * An IQ stanza of type 'get' * @return A result IQ stanza that contains the possbile search fields. */ private IQ processSetPacket(IQ packet) { if (!packet.getType().equals(IQ.Type.set)) { throw new IllegalArgumentException("This method only accepts 'set' typed IQ stanzas as an argument."); } JID fromJID = packet.getFrom(); final IQ resultIQ; // check if the request complies to the XEP-0055 standards if (!isValidSearchRequest(packet)) { resultIQ = IQ.createResultIQ(packet); resultIQ.setError(Condition.bad_request); return resultIQ; } final Element incomingForm = packet.getChildElement(); final boolean isDataFormQuery = (incomingForm.element(QName.get("x", "jabber:x:data")) != null); final Element rsmElement = incomingForm .element(QName.get("set", ResultSet.NAMESPACE_RESULT_SET_MANAGEMENT)); if (rsmElement != null) { final Element maxElement = rsmElement.element("max"); final Element startIndexElement = rsmElement.element("index"); int startIndex = 0; if (startIndexElement != null) { startIndex = Integer.parseInt(startIndexElement.getTextTrim()); } int max = -1; if (maxElement != null) { max = Integer.parseInt(maxElement.getTextTrim()); } final Set<User> searchResults = performSearch(incomingForm, startIndex, max); if (groupOnly) { Collection<Group> groups = GroupManager.getInstance().getGroups(fromJID); Set<User> allSearchResults = new HashSet<User>(searchResults); searchResults.clear(); for (User user : allSearchResults) { for (Group group : groups) { if (group.isUser(user.getUID())) { searchResults.add(user); } } } } // apply RSM final List<User> rsmResults; final ResultSet<User> rs = new ResultSetImpl<User>(searchResults); try { rsmResults = rs.applyRSMDirectives(rsmElement); } catch (NullPointerException e) { final IQ itemNotFound = IQ.createResultIQ(packet); itemNotFound.setError(Condition.item_not_found); return itemNotFound; } if (isDataFormQuery) { resultIQ = replyDataFormResult(rsmResults, packet); } else { resultIQ = replyNonDataFormResult(rsmResults, packet); } // add the additional 'set' element. final Element set = rs.generateSetElementFromResults(rsmResults); resultIQ.getChildElement().add(set); } else { final Set<User> searchResults = performSearch(incomingForm); if (groupOnly) { Collection<Group> groups = GroupManager.getInstance().getGroups(fromJID); Set<User> allSearchResults = new HashSet<User>(searchResults); searchResults.clear(); for (User user : allSearchResults) { for (Group group : groups) { if (group.isUser(user.getUID())) { searchResults.add(user); } } } } // don't apply RSM if (isDataFormQuery) { resultIQ = replyDataFormResult(searchResults, packet); } else { resultIQ = replyNonDataFormResult(searchResults, packet); } } return resultIQ; } public Set<User> filterGroupSearchResults(JID jid, Set<User> searchResults) { if (groupOnly) { Collection<Group> groups = GroupManager.getInstance().getGroups(jid); Set<User> allSearchResults = new HashSet<User>(searchResults); searchResults.clear(); for (User user : allSearchResults) { for (Group group : groups) { if (group.isUser(user.getUID())) { searchResults.add(user); } } } } return searchResults; } /** * This method checks if the search request that was received is a valid JABBER:IQ:SEARCH request. In other words, it checks if the * search request is spec compliant (XEP-0055). It does this by checking: * <ul> * <li>if the IQ stanza is of type 'set';</li> * <li>if a child element identified by the jabber:iq:search namespace is supplied;</li> * <li>if the stanza child element is has valid children itself.</li> * </ul> * * @param iq * The IQ object that should include a jabber:iq:search request. * @return ''true'' if the supplied IQ stanza is a spec compliant search request, ''false'' otherwise. */ @SuppressWarnings("unchecked") public static boolean isValidSearchRequest(IQ iq) { if (iq == null) { throw new IllegalArgumentException("Argument 'iq' cannot be null."); } if (iq.getType() != IQ.Type.set) { return false; } final Element childElement = iq.getChildElement(); if (childElement == null) { return false; } if (!childElement.getNamespaceURI().equals(NAMESPACE_JABBER_IQ_SEARCH)) { return false; } if (!childElement.getName().equals("query")) { return false; } final List<Element> fields = childElement.elements(); if (fields.size() == 0) { return false; } for (Element element : fields) { final String name = element.getName(); if (!validSearchRequestFields.contains(name)) { return false; } // TODO: check dataform validity. // if (name.equals("x") && !isValidDataForm(element)) // { // return false; // } if (name.equals("set") && !ResultSet.isValidRSMRequest(element)) { return false; } } return true; } private Set<User> performSearch(Element incomingForm, int startIndex, int max) { Set<User> users = new HashSet<User>(); Hashtable<String, String> searchList = extractSearchQuery(incomingForm); for (Entry<String, String> entry : searchList.entrySet()) { String field = entry.getKey(); String query = entry.getValue(); Collection<User> foundUsers = new ArrayList<User>(); if (userManager != null && query.length() > 0 && !query.equals(NAMESPACE_JABBER_IQ_SEARCH)) { if (max >= 0) { foundUsers.addAll(userManager.findUsers(new HashSet<String>(Arrays.asList(field)), query, startIndex, max)); } else { foundUsers.addAll(userManager.findUsers(new HashSet<String>(Arrays.asList(field)), query)); } } // occasionally a null User is returned so filter them out for (User user : foundUsers) { if (user != null) { users.add(user); } } } return users; } /** * Performs a search based on form data, and returns the search results. * * @param incomingForm * The form containing the search data * @return A set of users that matches the search criteria. */ private Set<User> performSearch(Element incomingForm) { return performSearch(incomingForm, -1, -1); } /** * This utilty method extracts the search query from the request. A query is defined as a set of key->value pairs, where the key denotes * a search field, and the value contains the value that was filled out by the user for that field. * * The query can be specified in one of two ways. The first way is a query is formed is by filling out any of the the standard search * fields. The other search method makes use of extended data forms. Search queries that are supplied to this * {@link #extractSearchQuery(Element)} that make use of this last method get forwarded to {@link #extractExtendedSearchQuery(Element)}. * * @param incomingForm * The form from which to extract the query * @return The search query for a particular user search request. */ @SuppressWarnings("unchecked") private Hashtable<String, String> extractSearchQuery(Element incomingForm) { if (incomingForm.element(QName.get("x", "jabber:x:data")) != null) { // forward the request. return extractExtendedSearchQuery(incomingForm); } final Hashtable<String, String> searchList = new Hashtable<String, String>(); // since not all clients request which fields are available for // searching attempt to match submitted fields with available search // fields Iterator<Element> iter = incomingForm.elementIterator(); while (iter.hasNext()) { Element element = iter.next(); String name = element.getName(); if (fieldLookup.containsKey(name)) { // make best effort to map the fields submitted by // the client to those that Openfire can search reverseFieldLookup.put(fieldLookup.get(name), name); searchList.put(fieldLookup.get(name), element.getText()); } } return searchList; } /** * Extracts a search query from a data form that makes use of data forms to specify the search request. This 'extended' way of * constructing a search request is documented in XEP-0055, chapter 3. * * @param incomingForm * The form from which to extract the query * @return The search query for a particular user search request. * @see #extractSearchQuery(Element) */ @SuppressWarnings("unchecked") private Hashtable<String, String> extractExtendedSearchQuery(Element incomingForm) { final Element dataform = incomingForm.element(QName.get("x", "jabber:x:data")); Hashtable<String, String> searchList = new Hashtable<String, String>(); List<String> searchFields = new ArrayList<String>(); String search = ""; Iterator<Element> fields = dataform.elementIterator("field"); while (fields.hasNext()) { Element searchField = fields.next(); String field = searchField.attributeValue("var"); String value = ""; if (searchField.element("value") != null) { value = searchField.element("value").getTextTrim(); } if (field.equals("search")) { search = value; } else if (value.equals("1")) { searchFields.add(field); } } for (String field : searchFields) { searchList.put(field, search); } return searchList; } /** * Constructs a query that is returned as an IQ packet that contains the search results. * * @param users * set of users that will be used to construct the search results * @param packet * the IQ packet sent by the client * @return the iq packet that contains the search results */ private IQ replyDataFormResult(Collection<User> users, IQ packet) { final DataForm searchResults = new DataForm(DataForm.Type.result); searchResults.addField("FORM_TYPE", null, FormField.Type.hidden); searchResults.addReportedField("jid", "JID", FormField.Type.jid_single); for (final String fieldName : getFilteredSearchFields()) { searchResults.addReportedField(fieldName, LocaleUtils.getLocalizedString("advance.user.search." + fieldName.toLowerCase(), "search"), FormField.Type.text_single); } for (final User user : users) { final String username = JID.unescapeNode(user.getUsername()); final Map<String, Object> item = new HashMap<String, Object>(); item.put("jid", username + "@" + serverName); item.put(LocaleUtils.getLocalizedString("advance.user.search.username", "search"), username); item.put(LocaleUtils.getLocalizedString("advance.user.search.name", "search"), (user.isNameVisible() ? removeNull(user.getName()) : "")); item.put(LocaleUtils.getLocalizedString("advance.user.search.email", "search"), (user.isEmailVisible() ? removeNull(user.getEmail()) : "")); searchResults.addItemFields(item); } IQ replyPacket = IQ.createResultIQ(packet); Element reply = replyPacket.setChildElement("query", NAMESPACE_JABBER_IQ_SEARCH); reply.add(searchResults.getElement()); return replyPacket; } /** * Constructs a query that is returned as an IQ packet that contains the search results. * * @param users * set of users that will be used to construct the search results * @param packet * the IQ packet sent by the client * @return the iq packet that contains the search results */ private IQ replyNonDataFormResult(Collection<User> users, IQ packet) { IQ replyPacket = IQ.createResultIQ(packet); Element replyQuery = replyPacket.setChildElement("query", NAMESPACE_JABBER_IQ_SEARCH); for (User user : users) { Element item = replyQuery.addElement("item"); String username = JID.unescapeNode(user.getUsername()); item.addAttribute("jid", username + "@" + serverName); // return to the client the same fields that were submitted for (String field : reverseFieldLookup.keySet()) { if ("Username".equals(field)) { Element element = item.addElement(reverseFieldLookup.get(field)); element.addText(username); } if ("Name".equals(field)) { Element element = item.addElement(reverseFieldLookup.get(field)); element.addText(user.isNameVisible() ? removeNull(user.getName()) : ""); } if ("Email".equals(field)) { Element element = item.addElement(reverseFieldLookup.get(field)); element.addText(user.isEmailVisible() ? removeNull(user.getEmail()) : ""); } } } return replyPacket; } /** * Returns the service name of this component, which is "search" by default. * * @return the service name of this component. */ public String getServiceName() { return serviceName; } /** * Sets the service name of this component, which is "search" by default. If the name is different than the existing name the plugin * will remove itself from the ComponentManager and then add itself back using the new name. * * @param name * the service name of this component. */ public void setServiceName(String name) { changeServiceName(name); JiveGlobals.setProperty(SERVICENAME, name); } /** * Checks if the search service is enabled. * * @return true if search service is enabled. */ public boolean getServiceEnabled() { return serviceEnabled; } /** * Enables or disables the search service. When disabled, when a client tries to do a search they will receive an XForm informing that * the service is unavailable. * * @param enabled * true if group permission checking should be disabled. */ public void setServiceEnabled(boolean enabled) { serviceEnabled = enabled; JiveGlobals.setProperty(SERVICEENABLED, enabled ? "true" : "false"); } /** * Returns the collection of searchable field names that does not include the fields listed in the EXCLUDEDFIELDS property list. * * @return collection of searchable field names. */ public Collection<String> getFilteredSearchFields() { Collection<String> searchFields; // See if the installed provider supports searching. If not, workaround // by providing our own searching. try { searchFields = new ArrayList<String>(userManager.getSearchFields()); } catch (UnsupportedOperationException uoe) { // Use a SearchPluginUserManager instead. searchFields = getSearchPluginUserManagerSearchFields(); } searchFields.removeAll(excludedFields); return searchFields; } /** * Restricts which fields can be searched on and shown to clients. This can be used in the case of preventing users email addresses from * being revealed as part of the search results. * * @param excludedFields * fields that can not be searched on or shown to the client */ public void setExcludedFields(Collection<String> excludedFields) { this.excludedFields = excludedFields; JiveGlobals.setProperty(EXCLUDEDFIELDS, StringUtils.collectionToString(excludedFields)); } /** * Checks if the search service is restricted to groups. * * @return true if restricted to groups. */ public boolean isGroupOnly() { return groupOnly; } /** * Sets the search service scope. * * @param groupOnly * true if group only. */ public void setGroupOnly(boolean groupOnly) { this.groupOnly = groupOnly; JiveGlobals.setProperty(GROUPONLY, groupOnly ? "true" : "false"); } /* * (non-Javadoc) * * @see org.jivesoftware.util.PropertyEventListener#propertySet(java.lang.String, java.util.Map) */ public void propertySet(String property, Map<String, Object> params) { if (property.equals(SERVICEENABLED)) { this.serviceEnabled = Boolean.parseBoolean((String) params.get("value")); } else if (property.equals(SERVICENAME)) { changeServiceName((String) params.get("value")); } else if (property.equals(EXCLUDEDFIELDS)) { excludedFields = StringUtils .stringToCollection(JiveGlobals.getProperty(EXCLUDEDFIELDS, (String) params.get("value"))); } else if (property.equals(GROUPONLY)) { this.groupOnly = Boolean.parseBoolean((String) params.get("value")); } } /* * (non-Javadoc) * * @see org.jivesoftware.util.PropertyEventListener#propertyDeleted(java.lang.String, java.util.Map) */ public void propertyDeleted(String property, Map<String, Object> params) { if (property.equals(SERVICEENABLED)) { this.serviceEnabled = true; } else if (property.equals(SERVICENAME)) { changeServiceName("search"); } else if (property.equals(EXCLUDEDFIELDS)) { excludedFields = new ArrayList<String>(); } else if (property.equals(GROUPONLY)) { this.groupOnly = false; } } /* * (non-Javadoc) * * @see org.jivesoftware.util.PropertyEventListener#xmlPropertySet(java.lang.String, java.util.Map) */ public void xmlPropertySet(String property, Map<String, Object> params) { // not used } /* * (non-Javadoc) * * @see org.jivesoftware.util.PropertyEventListener#xmlPropertyDeleted(java.lang.String, java.util.Map) */ public void xmlPropertyDeleted(String property, Map<String, Object> params) { // not used } private void changeServiceName(String serviceName) { if (serviceName == null) { throw new NullPointerException("Service name cannot be null"); } if (this.serviceName.equals(serviceName)) { return; } // Re-register the service. try { componentManager.removeComponent(this.serviceName); } catch (Exception e) { Log.error(e.getMessage(), e); } try { componentManager.addComponent(serviceName, this); } catch (Exception e) { Log.error(e.getMessage(), e); } this.serviceName = serviceName; } /** * Comparator that compares String objects, ignoring capitalization. */ private class CaseInsensitiveComparator implements Comparator<String> { public int compare(String s1, String s2) { return s1.compareToIgnoreCase(s2); } } /** * Returns the trimmed argument, or an empty String object of null was supplied as an argument. * * @param s * The String to be trimmed. * @return String object that does not start or end with whitespace characters. */ private String removeNull(String s) { if (s == null) { return ""; } return s.trim(); } /** * Returns the collection of field names that can be used to search for a user. Typical fields are username, name, and email. These * values can be used to contruct a data form. * * @return the collection of field names that can be used to search. */ public Collection<String> getSearchPluginUserManagerSearchFields() { return Arrays.asList("Username", "Name", "Email"); } }