GroupProvider.java 10.4 KB
Newer Older
1
/**
2
 * Copyright (C) 2004-2008 Jive Software. All rights reserved.
3
 *
4 5 6 7 8 9 10 11 12 13 14
 * 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.
15 16
 */

17
package org.jivesoftware.openfire.group;
18 19

import java.util.Collection;
20 21
import java.util.Map;

22
import org.jivesoftware.util.PersistableMap;
23
import org.xmpp.packet.JID;
24 25 26 27

/**
 * Provider interface for groups. Users that wish to integrate with
 * their own group system must implement this class and then register
28
 * the implementation with Openfire in the <tt>openfire.xml</tt>
29 30 31 32 33 34 35 36 37
 * file. An entry in that file would look like the following:
 *
 * <pre>
 *   &lt;provider&gt;
 *     &lt;group&gt;
 *       &lt;className&gt;com.foo.auth.CustomGroupProvider&lt;/className&gt;
 *     &lt;/group&gt;
 *   &lt;/provider&gt;</pre>
 *
38
 * @see AbstractGroupProvider
39
 * 
40 41 42 43 44
 * @author Matt Tucker
 */
public interface GroupProvider {

    /**
45 46
     * Creates a group with the given name (optional operation).
     * <p>
47 48
     * The provider is responsible for setting the creation date and
     * modification date to the current date/time.
49
     * </p>
50 51 52 53 54 55 56 57
     *
     * @param name name of the group.
     * @return the newly created group.
     * @throws GroupAlreadyExistsException if a group with the same name already
     *      exists.
     * @throws UnsupportedOperationException if the provider does not
     *      support the operation.
     */
58
    Group createGroup(String name) throws GroupAlreadyExistsException;
59 60 61 62 63 64 65 66

    /**
     * Deletes the group (optional operation).
     *
     * @param name the name of the group to delete.
     * @throws UnsupportedOperationException if the provider does not
     *      support the operation.
     */
67
    void deleteGroup(String name);
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

    /**
     * Returns a group based on it's name.
     *
     * @param name the name of the group.
     * @return the group with the given name.
     * @throws GroupNotFoundException If no group with that ID could be found
     */
    Group getGroup(String name) throws GroupNotFoundException;

    /**
     * Sets the name of a group to a new name.
     *
     * @param oldName the current name of the group.
     * @param newName the desired new name of the group.
     * @throws GroupAlreadyExistsException if a group with the same name already
     *      exists.
     * @throws UnsupportedOperationException if the provider does not
     *      support the operation.
     */
88
    void setName(String oldName, String newName) throws GroupAlreadyExistsException;
89 90 91 92 93 94 95 96

    /**
     * Updates the group's description.
     *
     * @param name the group name.
     * @param description the group description.
     * @throws GroupNotFoundException if no existing group could be found to update.
     */
97
    void setDescription(String name, String description) throws GroupNotFoundException;
98 99 100 101 102 103 104 105 106

    /**
     * Returns the number of groups in the system.
     *
     * @return the number of groups in the system.
     */
    int getGroupCount();

    /**
107
     * Returns the Collection of all group names in the system.
108 109 110
     *
     * @return the Collection of all groups.
     */
111
    Collection<String> getGroupNames();
112

113 114 115 116 117 118 119 120
    /**
     * Returns true if this GroupProvider allows group sharing. Shared groups
     * enable roster sharing.
     *
     * @return true if the group provider supports group sharing.
     */
    boolean isSharingSupported();

121 122 123 124 125
    /**
     * Returns an unmodifiable Collection of all shared groups in the system.
     *
     * @return unmodifiable Collection of all shared groups in the system.
     */
126 127 128 129 130
    Collection<String> getSharedGroupNames();
    
    /**
     * Returns an unmodifiable Collection of all shared groups in the system for a given user.
     * 
131
     * @param user The bare JID for the user (node@domain)
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
     * @return unmodifiable Collection of all shared groups in the system for a given user.
     */
    Collection<String> getSharedGroupNames(JID user);
    
    /**
     * Returns an unmodifiable Collection of all public shared groups in the system.
     *
     * @return unmodifiable Collection of all public shared groups in the system.
     */
    Collection<String> getPublicSharedGroupNames();
    
    /**
     * Returns an unmodifiable Collection of groups that are visible
     * to the members of the given group.
     * 
     * @param userGroup The given group
     * @return unmodifiable Collection of group names that are visible
     * to the given group.
     */
    Collection<String> getVisibleGroupNames(String userGroup);
    
153 154 155 156 157
    /**
     * Returns the Collection of all groups in the system.
     *
     * @param startIndex start index in results.
     * @param numResults number of results to return.
158 159
     * @return the Collection of all group names given the
     *      <tt>startIndex</tt> and <tt>numResults</tt>.
160
     */
161
    Collection<String> getGroupNames(int startIndex, int numResults);
162 163

    /**
164
     * Returns the Collection of group names that an entity belongs to.
165 166
     *
     * @param user the JID of the entity.
167
     * @return the Collection of group names that the user belongs to.
168
     */
169
    Collection<String> getGroupNames(JID user);
170 171 172 173 174 175 176 177 178 179

    /**
     * Adds an entity to a group (optional operation).
     *
     * @param groupName the group to add the member to
     * @param user the JID of the entity to add
     * @param administrator True if the member is an administrator of the group
     * @throws UnsupportedOperationException if the provider does not
     *      support the operation.
     */
180
    void addMember(String groupName, JID user, boolean administrator);
181 182 183 184 185 186 187 188 189 190

    /**
     * Updates the privileges of an entity in a group.
     *
     * @param groupName the group where the change happened
     * @param user the JID of the entity with new privileges
     * @param administrator True if the member is an administrator of the group
     * @throws UnsupportedOperationException if the provider does not
     *      support the operation.
     */
191
    void updateMember(String groupName, JID user, boolean administrator);
192 193 194 195 196 197 198 199 200

    /**
     * Deletes an entity from a group (optional operation).
     *
     * @param groupName the group name.
     * @param user the JID of the entity to delete.
     * @throws UnsupportedOperationException if the provider does not
     *      support the operation.
     */
201
    void deleteMember(String groupName, JID user);
202 203 204 205 206 207 208

    /**
     * Returns true if this GroupProvider is read-only. When read-only,
     * groups can not be created, deleted, or modified.
     *
     * @return true if the user provider is read-only.
     */
209 210 211
    boolean isReadOnly();

    /**
212
     * Returns the group names that match a search. The search is over group names and
213 214 215 216 217 218 219 220 221 222
     * implicitly uses wildcard matching (although the exact search semantics are left
     * up to each provider implementation). For example, a search for "HR" should match
     * the groups "HR", "HR Department", and "The HR People".<p>
     *
     * Before searching or showing a search UI, use the {@link #isSearchSupported} method
     * to ensure that searching is supported.
     *
     * @param query the search string for group names.
     * @return all groups that match the search.
     */
223
    Collection<String> search(String query);
224 225

    /**
226
     * Returns the group names that match a search given a start index and desired number of results.
227 228 229 230 231 232 233 234
     * The search is over group names and implicitly uses wildcard matching (although the
     * exact search semantics are left up to each provider implementation). For example, a
     * search for "HR" should match the groups "HR", "HR Department", and "The HR People".<p>
     *
     * Before searching or showing a search UI, use the {@link #isSearchSupported} method
     * to ensure that searching is supported.
     *
     * @param query the search string for group names.
Matt Tucker's avatar
Matt Tucker committed
235 236
     * @param startIndex start index in results.
     * @param numResults number of results to return.
237 238
     * @return all groups that match the search.
     */
239
    Collection<String> search(String query, int startIndex, int numResults);
240

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
    /**
     * Returns the names of groups that have a property matching the given
     * key/value pair. This provides an simple extensible search mechanism
     * for providers with differing property sets and storage models.
     * 
     * The semantics of the key/value matching (wildcard support, scoping, etc.) 
     * are unspecified by the interface and may vary for each implementation.
     * 
     * Before searching or showing a search UI, use the {@link #isSearchSupported} method
     * to ensure that searching is supported.
     *
     * @param key The name of a group property (e.g. "sharedRoster.showInRoster")
     * @param value The value to match for the given property
     * @return unmodifiable Collection of group names that match the
     * 			given key/value pair.
     */
    Collection<String> search(String key, String value);
    
259 260 261 262 263 264
    /**
     * Returns true if group searching is supported by the provider.
     *
     * @return true if searching is supported.
     */
    boolean isSearchSupported();
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
    
    /**
     * Loads the group properties (if any) from the backend data store. If
     * the properties can be changed, the provider implementation must ensure
     * that updates to the resulting {@link Map} are persisted to the
     * backend data store. Otherwise if a mutator method is called, the
     * implementation should throw an {@link UnsupportedOperationException}.
     * 
     * If there are no corresponding properties for the given group, or if the
     * provider does not support group properties, this method should return
     * an empty Map rather than null.
     * 
     * @param group The target group
     * @return The properties for the given group
     */
280
    PersistableMap<String,String> loadProperties(Group group);
281
    
282
}