##### Coverage Report - org.apache.turbine.services.security.TurbineSecurity

Classes in this File | Line Coverage | Branch Coverage | Complexity
TurbineSecurity |
5% | 5/88
N/A | N/A
| 1.0;1

1 |  |
     package org.apache.turbine.services.security;
2 |  |
3 |  |
     /*
4 |  |
      * Licensed to the Apache Software Foundation (ASF) under one
5 |  |
      * or more contributor license agreements.  See the NOTICE file
6 |  |
      * distributed with this work for additional information
7 |  |
      * regarding copyright ownership.  The ASF licenses this file
8 |  |
      * to you under the Apache License, Version 2.0 (the
9 |  |
      * "License"); you may not use this file except in compliance
10 |  |
      * with the License.  You may obtain a copy of the License at
11 |  |
      *
12 |  |
      *   http://www.apache.org/licenses/LICENSE-2.0
13 |  |
      *
14 |  |
      * Unless required by applicable law or agreed to in writing,
15 |  |
      * software distributed under the License is distributed on an
16 |  |
      * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17 |  |
      * KIND, either express or implied.  See the License for the
18 |  |
      * specific language governing permissions and limitations
19 |  |
      * under the License.
20 |  |
      */
21 |  |
22 |  |
23 |  |
     import org.apache.turbine.om.security.Group;
24 |  |
     import org.apache.turbine.om.security.Permission;
25 |  |
     import org.apache.turbine.om.security.Role;
26 |  |
     import org.apache.turbine.om.security.User;
27 |  |
     import org.apache.turbine.services.TurbineServices;
28 |  |
     import org.apache.turbine.util.security.AccessControlList;
29 |  |
     import org.apache.turbine.util.security.DataBackendException;
30 |  |
     import org.apache.turbine.util.security.EntityExistsException;
31 |  |
     import org.apache.turbine.util.security.GroupSet;
32 |  |
     import org.apache.turbine.util.security.PasswordMismatchException;
33 |  |
     import org.apache.turbine.util.security.PermissionSet;
34 |  |
     import org.apache.turbine.util.security.RoleSet;
35 |  |
     import org.apache.turbine.util.security.TurbineSecurityException;
36 |  |
     import org.apache.turbine.util.security.UnknownEntityException;
37 |  |
38 |  |
     /**
39 |  |
      * This is a Facade class for SecurityService.
40 |  |
      *
41 |  |
      * This class provides static methods that call related methods of the
42 |  |
      * implementation of SecurityService used by the System, according to
43 |  |
      * the settings in TurbineResources.
44 |  |
      * <br>
45 |  |
      *
46 |  |
      * <a name="global">
47 |  |
      * <p> Certain Roles that the Users may have in the system may are not related
48 |  |
      * to any specific resource nor entity. They are assigned within a special group
49 |  |
      * named 'global' that can be referenced in the code as
50 |  |
      * {@link org.apache.turbine.om.security.Group#GLOBAL_GROUP_NAME}.
51 |  |
      *
52 |  |
      * @author <a href="mailto:Rafal.Krzewski@e-point.pl">Rafal Krzewski</a>
53 |  |
      * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
54 |  |
      * @version $Id: TurbineSecurity.java 1096130 2011-04-23 10:37:19Z ludwig $
55 |  |
      */
56 | 0 |
     public abstract class TurbineSecurity
57 |  |
     {
58 |  |
         /**
59 |  |
          * Retrieves an implementation of SecurityService, base on the settings in
60 |  |
          * TurbineResources.
61 |  |
          *
62 |  |
          * @return an implementation of SecurityService.
63 |  |
          */
64 |  |
         public static SecurityService getService()
65 |  |
         {
66 | 32 |
             return (SecurityService) TurbineServices.getInstance().
67 |  |
                     getService(SecurityService.SERVICE_NAME);
68 |  |
         }
69 |  |
70 |  |
         /*-----------------------------------------------------------------------
71 |  |
           Management of User objects
72 |  |
           -----------------------------------------------------------------------*/
73 |  |
74 |  |
         /**
75 |  |
          * This method provides client-side encryption of passwords.
76 |  |
          *
77 |  |
          * This is an utility method that is used by other classes to maintain
78 |  |
          * a consistent approach to encrypting password. The behavior of the
79 |  |
          * method can be configured in service's properties.
80 |  |
          *
81 |  |
          * @param password the password to process
82 |  |
          * @return processed password
83 |  |
          */
84 |  |
         public static String encryptPassword(String password)
85 |  |
         {
86 | 0 |
             return getService().encryptPassword(password);
87 |  |
         }
88 |  |
89 |  |
         /**
90 |  |
          * This method provides client-side encryption of passwords.
91 |  |
          *
92 |  |
          * This is an utility method that is used by other classes to maintain
93 |  |
          * a consistent approach to encrypting password. The behavior of the
94 |  |
          * method can be configured in service's properties.
95 |  |
          *
96 |  |
          * @param password the password to process
97 |  |
          * @param salt the supplied salt to encrypt the password
98 |  |
          * @return processed password
99 |  |
          */
100 |  |
         public static String encryptPassword(String password, String salt)
101 |  |
         {
102 | 0 |
             return getService().encryptPassword(password, salt);
103 |  |
         }
104 |  |
105 |  |
         /**
106 |  |
          * Checks if a supplied password matches the encrypted password
107 |  |
          *
108 |  |
          * @param checkpw      The clear text password supplied by the user
109 |  |
          * @param encpw        The current, encrypted password
110 |  |
          *
111 |  |
          * @return true if the password matches, else false
112 |  |
          *
113 |  |
          */
114 |  |
115 |  |
         public static boolean checkPassword(String checkpw, String encpw)
116 |  |
         {
117 | 0 |
             return getService().checkPassword(checkpw, encpw);
118 |  |
         }
119 |  |
120 |  |
         /*-----------------------------------------------------------------------
121 |  |
           Getting Object Classes
122 |  |
           -----------------------------------------------------------------------*/
123 |  |
124 |  |
         /**
125 |  |
          * Returns the Class object for the implementation of User interface
126 |  |
          * used by the system.
127 |  |
          *
128 |  |
          * @return the implementation of User interface used by the system.
129 |  |
          * @throws UnknownEntityException if the system's implementation of User
130 |  |
          *         interface could not be determined.
131 |  |
          */
132 |  |
         public static Class getUserClass()
133 |  |
                 throws UnknownEntityException
134 |  |
         {
135 | 0 |
             return getService().getUserClass();
136 |  |
         }
137 |  |
138 |  |
         /**
139 |  |
          * Returns the Class object for the implementation of Group interface
140 |  |
          * used by the system.
141 |  |
          *
142 |  |
          * @return the implementation of Group interface used by the system.
143 |  |
          * @throws UnknownEntityException if the system's implementation of Group
144 |  |
          *         interface could not be determined.
145 |  |
          */
146 |  |
         public static Class getGroupClass()
147 |  |
             throws UnknownEntityException
148 |  |
         {
149 | 0 |
             return getService().getGroupClass();
150 |  |
         }
151 |  |
152 |  |
         /**
153 |  |
          * Returns the Class object for the implementation of Permission interface
154 |  |
          * used by the system.
155 |  |
          *
156 |  |
          * @return the implementation of Permission interface used by the system.
157 |  |
          * @throws UnknownEntityException if the system's implementation of Permission
158 |  |
          *         interface could not be determined.
159 |  |
          */
160 |  |
         public static Class getPermissionClass()
161 |  |
             throws UnknownEntityException
162 |  |
         {
163 | 0 |
             return getService().getPermissionClass();
164 |  |
         }
165 |  |
166 |  |
         /**
167 |  |
          * Returns the Class object for the implementation of Role interface
168 |  |
          * used by the system.
169 |  |
          *
170 |  |
          * @return the implementation of Role interface used by the system.
171 |  |
          * @throws UnknownEntityException if the system's implementation of Role
172 |  |
          *         interface could not be determined.
173 |  |
          */
174 |  |
         public static Class getRoleClass()
175 |  |
             throws UnknownEntityException
176 |  |
         {
177 | 0 |
             return getService().getRoleClass();
178 |  |
         }
179 |  |
180 |  |
         /**
181 |  |
          * Construct a blank User object.
182 |  |
          *
183 |  |
          * This method calls getUserClass, and then creates a new object using
184 |  |
          * the default constructor.
185 |  |
          *
186 |  |
          * @return an object implementing User interface.
187 |  |
          * @throws UnknownEntityException if the object could not be instantiated.
188 |  |
          */
189 |  |
         public static User getUserInstance()
190 |  |
                 throws UnknownEntityException
191 |  |
         {
192 | 0 |
             return getService().getUserInstance();
193 |  |
         }
194 |  |
195 |  |
         /**
196 |  |
          * Returns the configured UserManager.
197 |  |
          *
198 |  |
          * @return An UserManager object
199 |  |
          */
200 |  |
         public static UserManager getUserManager()
201 |  |
         {
202 | 0 |
             return getService().getUserManager();
203 |  |
         }
204 |  |
205 |  |
         /**
206 |  |
          * Configure a new user Manager.
207 |  |
          *
208 |  |
          * @param userManager An UserManager object
209 |  |
          */
210 |  |
         public void setUserManager(UserManager userManager)
211 |  |
         {
212 | 0 |
             getService().setUserManager(userManager);
213 | 0 |
         }
214 |  |
215 |  |
         /**
216 |  |
          * Check whether a specified user's account exists.
217 |  |
          *
218 |  |
          * The login name is used for looking up the account.
219 |  |
          *
220 |  |
          * @param user The user to be checked.
221 |  |
          * @return true if the specified account exists
222 |  |
          * @throws DataBackendException if there was an error accessing the data
223 |  |
          *         backend.
224 |  |
          */
225 |  |
         public static boolean accountExists(User user)
226 |  |
                 throws DataBackendException
227 |  |
         {
228 | 0 |
             return getService().accountExists(user);
229 |  |
         }
230 |  |
231 |  |
         /**
232 |  |
          * Check whether a specified user's account exists.
233 |  |
          *
234 |  |
          * The login name is used for looking up the account.
235 |  |
          *
236 |  |
          * @param userName The name of the user to be checked.
237 |  |
          * @return true if the specified account exists
238 |  |
          * @throws DataBackendException if there was an error accessing the data
239 |  |
          *         backend.
240 |  |
          */
241 |  |
         public static boolean accountExists(String userName)
242 |  |
                 throws DataBackendException
243 |  |
         {
244 | 0 |
             return getService().accountExists(userName);
245 |  |
         }
246 |  |
247 |  |
         /**
248 |  |
          * Authenticates an user, and constructs an User object to represent
249 |  |
          * him/her.
250 |  |
          *
251 |  |
          * @param username The user name.
252 |  |
          * @param password The user password.
253 |  |
          * @return An authenticated Turbine User.
254 |  |
          * @throws DataBackendException if there was an error accessing the data
255 |  |
          *         backend.
256 |  |
          * @throws UnknownEntityException if user account is not present.
257 |  |
          * @throws PasswordMismatchException if the supplied password was incorrect.
258 |  |
          */
259 |  |
         public static User getAuthenticatedUser(String username, String password)
260 |  |
                 throws DataBackendException, UnknownEntityException,
261 |  |
                 PasswordMismatchException
262 |  |
         {
263 | 2 |
             return getService().getAuthenticatedUser(username, password);
264 |  |
         }
265 |  |
266 |  |
         /**
267 |  |
          * Constructs an User object to represent a registered user of the
268 |  |
          * application.
269 |  |
          *
270 |  |
          * @param username The user name.
271 |  |
          * @return A Turbine User.
272 |  |
          * @throws DataBackendException if there was an error accessing the data
273 |  |
          *         backend.
274 |  |
          * @throws UnknownEntityException if user account is not present.
275 |  |
          */
276 |  |
         public static User getUser(String username)
277 |  |
                 throws DataBackendException, UnknownEntityException
278 |  |
         {
279 | 0 |
             return getService().getUser(username);
280 |  |
         }
281 |  |
282 |  |
         /**
283 |  |
          * Constructs an User object to represent an anonymous user of the
284 |  |
          * application.
285 |  |
          *
286 |  |
          * @return An anonymous Turbine User.
287 |  |
          * @throws UnknownEntityException if the anonymous User object couldn't be
288 |  |
          *         constructed.
289 |  |
          */
290 |  |
         public static User getAnonymousUser()
291 |  |
                 throws UnknownEntityException
292 |  |
         {
293 | 4 |
             return getService().getAnonymousUser();
294 |  |
         }
295 |  |
296 |  |
         /**
297 |  |
          * Checks whether a passed user object matches the anonymous user pattern
298 |  |
          * according to the configured service
299 |  |
          *
300 |  |
          * @param user A user object
301 |  |
          * @return True if this is an anonymous user
302 |  |
          */
303 |  |
         public static boolean isAnonymousUser(User user)
304 |  |
         {
305 | 20 |
             return getService().isAnonymousUser(user);
306 |  |
         }
307 |  |
308 |  |
         /**
309 |  |
          * Saves User's data in the permanent storage. The user account is required
310 |  |
          * to exist in the storage.
311 |  |
          *
312 |  |
          * @param user The User object to save.
313 |  |
          * @throws UnknownEntityException if the user's account does not
314 |  |
          *         exist in the database.
315 |  |
          * @throws DataBackendException if there is a problem accessing the
316 |  |
          *         storage.
317 |  |
          */
318 |  |
         public static void saveUser(User user)
319 |  |
                 throws UnknownEntityException, DataBackendException
320 |  |
         {
321 | 0 |
             getService().saveUser(user);
322 | 0 |
         }
323 |  |
324 |  |
         /**
325 |  |
          * Saves User data when the session is unbound. The user account is required
326 |  |
          * to exist in the storage.
327 |  |
          *
328 |  |
          * LastLogin, AccessCounter, persistent pull tools, and any data stored
329 |  |
          * in the permData hashtable that is not mapped to a column will be saved.
330 |  |
          *
331 |  |
          * @exception UnknownEntityException if the user's account does not
332 |  |
          *            exist in the database.
333 |  |
          * @exception DataBackendException if there is a problem accessing the
334 |  |
          *            storage.
335 |  |
          */
336 |  |
         public static void saveOnSessionUnbind(User user)
337 |  |
                 throws UnknownEntityException, DataBackendException
338 |  |
         {
339 | 0 |
             getService().saveOnSessionUnbind(user);
340 | 0 |
         }
341 |  |
342 |  |
         /**
343 |  |
          * Change the password for an User.
344 |  |
          *
345 |  |
          * @param user an User to change password for.
346 |  |
          * @param oldPassword the current password supplied by the user.
347 |  |
          * @param newPassword the current password requested by the user.
348 |  |
          * @throws PasswordMismatchException if the supplied password was
349 |  |
          *         incorrect.
350 |  |
          * @throws UnknownEntityException if the user's record does not
351 |  |
          *         exist in the database.
352 |  |
          * @throws DataBackendException if there is a problem accessing the
353 |  |
          *         storage.
354 |  |
          */
355 |  |
         public static void changePassword(User user, String oldPassword,
356 |  |
                                           String newPassword)
357 |  |
                 throws PasswordMismatchException, UnknownEntityException,
358 |  |
                 DataBackendException
359 |  |
         {
360 | 0 |
             getService().changePassword(user, oldPassword, newPassword);
361 | 0 |
         }
362 |  |
363 |  |
         /**
364 |  |
          * Forcibly sets new password for an User.
365 |  |
          *
366 |  |
          * This is supposed by the administrator to change the forgotten or
367 |  |
          * compromised passwords. Certain implementatations of this feature
368 |  |
          * would require administrative level access to the authenticating
369 |  |
          * server / program.
370 |  |
          *
371 |  |
          * @param user an User to change password for.
372 |  |
          * @param password the new password.
373 |  |
          * @throws UnknownEntityException if the user's record does not
374 |  |
          *         exist in the database.
375 |  |
          * @throws DataBackendException if there is a problem accessing the
376 |  |
          *         storage.
377 |  |
          */
378 |  |
         public static void forcePassword(User user, String password)
379 |  |
                 throws UnknownEntityException, DataBackendException
380 |  |
         {
381 | 0 |
             getService().forcePassword(user, password);
382 | 0 |
         }
383 |  |
384 |  |
         /*-----------------------------------------------------------------------
385 |  |
           Creation of AccessControlLists
386 |  |
           -----------------------------------------------------------------------*/
387 |  |
388 |  |
         /**
389 |  |
          * Constructs an AccessControlList for a specific user.
390 |  |
          *
391 |  |
          * @param user the user for whom the AccessControlList are to be retrieved
392 |  |
          * @return The AccessControList object constructed from the user object.
393 |  |
          * @throws DataBackendException if there was an error accessing the data
394 |  |
          *         backend.
395 |  |
          * @throws UnknownEntityException if user account is not present.
396 |  |
          */
397 |  |
         public static AccessControlList getACL(User user)
398 |  |
                 throws DataBackendException, UnknownEntityException
399 |  |
         {
400 | 2 |
             return getService().getACL(user);
401 |  |
         }
402 |  |
403 |  |
         /*-----------------------------------------------------------------------
404 |  |
           Security management
405 |  |
           -----------------------------------------------------------------------*/
406 |  |
407 |  |
         /**
408 |  |
          * Grant an User a Role in a Group.
409 |  |
          *
410 |  |
          * @param user the user.
411 |  |
          * @param group the group.
412 |  |
          * @param role the role.
413 |  |
          * @throws DataBackendException if there was an error accessing the data
414 |  |
          *         backend.
415 |  |
          * @throws UnknownEntityException if user account, group or role is not
416 |  |
          *         present.
417 |  |
          */
418 |  |
         public static void grant(User user, Group group, Role role)
419 |  |
                 throws DataBackendException, UnknownEntityException
420 |  |
         {
421 | 0 |
             getService().grant(user, group, role);
422 | 0 |
         }
423 |  |
424 |  |
         /**
425 |  |
          * Revoke a Role in a Group from an User.
426 |  |
          *
427 |  |
          * @param user the user.
428 |  |
          * @param group the group.
429 |  |
          * @param role the role.
430 |  |
          * @throws DataBackendException if there was an error accessing the data
431 |  |
          *         backend.
432 |  |
          * @throws UnknownEntityException if user account, group or role is not
433 |  |
          *         present.
434 |  |
          */
435 |  |
         public static void revoke(User user, Group group, Role role)
436 |  |
                 throws DataBackendException, UnknownEntityException
437 |  |
         {
438 | 0 |
             getService().revoke(user, group, role);
439 | 0 |
         }
440 |  |
441 |  |
         /**
442 |  |
          * Revokes all roles from an User.
443 |  |
          *
444 |  |
          * This method is used when deleting an account.
445 |  |
          *
446 |  |
          * @param user the User.
447 |  |
          * @throws DataBackendException if there was an error accessing the data
448 |  |
          *         backend.
449 |  |
          * @throws UnknownEntityException if the account is not present.
450 |  |
          */
451 |  |
         public static void revokeAll(User user)
452 |  |
                 throws DataBackendException, UnknownEntityException
453 |  |
         {
454 | 0 |
             getService().revokeAll(user);
455 | 0 |
         }
456 |  |
457 |  |
         /**
458 |  |
          * Grants a Role a Permission
459 |  |
          *
460 |  |
          * @param role the Role.
461 |  |
          * @param permission the Permission.
462 |  |
          * @throws DataBackendException if there was an error accessing the data
463 |  |
          *         backend.
464 |  |
          * @throws UnknownEntityException if role or permission is not present.
465 |  |
          */
466 |  |
         public static void grant(Role role, Permission permission)
467 |  |
                 throws DataBackendException, UnknownEntityException
468 |  |
         {
469 | 0 |
             getService().grant(role, permission);
470 | 0 |
         }
471 |  |
472 |  |
         /**
473 |  |
          * Revokes a Permission from a Role.
474 |  |
          *
475 |  |
          * @param role the Role.
476 |  |
          * @param permission the Permission.
477 |  |
          * @throws DataBackendException if there was an error accessing the data
478 |  |
          *         backend.
479 |  |
          * @throws UnknownEntityException if role or permission is not present.
480 |  |
          */
481 |  |
         public static void revoke(Role role, Permission permission)
482 |  |
                 throws DataBackendException, UnknownEntityException
483 |  |
         {
484 | 0 |
             getService().revoke(role, permission);
485 | 0 |
         }
486 |  |
487 |  |
         /**
488 |  |
          * Revokes all permissions from a Role.
489 |  |
          *
490 |  |
          * This method is user when deleting a Role.
491 |  |
          *
492 |  |
          * @param role the Role
493 |  |
          * @throws DataBackendException if there was an error accessing the data
494 |  |
          *         backend.
495 |  |
          * @throws  UnknownEntityException if the Role is not present.
496 |  |
          */
497 |  |
         public static void revokeAll(Role role)
498 |  |
                 throws DataBackendException, UnknownEntityException
499 |  |
         {
500 | 0 |
             getService().revokeAll(role);
501 | 0 |
         }
502 |  |
503 |  |
         /*-----------------------------------------------------------------------
504 |  |
           Account management
505 |  |
           -----------------------------------------------------------------------*/
506 |  |
507 |  |
         /**
508 |  |
          * Creates new user account with specified attributes.
509 |  |
          *
510 |  |
          * <strong>TODO</strong> throw more specific exception<br>
511 |  |
          *
512 |  |
          * @param user the object describing account to be created.
513 |  |
          * @param password password for the new user
514 |  |
          * @throws DataBackendException if there was an error accessing the data
515 |  |
          *         backend.
516 |  |
          * @throws EntityExistsException if the user account already exists.
517 |  |
          */
518 |  |
         public static void addUser(User user, String password)
519 |  |
                 throws DataBackendException, EntityExistsException
520 |  |
         {
521 | 0 |
             getService().addUser(user, password);
522 | 0 |
         }
523 |  |
524 |  |
         /**
525 |  |
          * Removes an user account from the system.
526 |  |
          *
527 |  |
          * <strong>TODO</strong> throw more specific exception<br>
528 |  |
          *
529 |  |
          * @param user the object describing the account to be removed.
530 |  |
          * @throws DataBackendException if there was an error accessing the data
531 |  |
          *         backend.
532 |  |
          * @throws UnknownEntityException if the user account is not present.
533 |  |
          */
534 |  |
         public static void removeUser(User user)
535 |  |
                 throws DataBackendException, UnknownEntityException
536 |  |
         {
537 | 0 |
             getService().removeUser(user);
538 | 0 |
         }
539 |  |
540 |  |
         /*-----------------------------------------------------------------------
541 |  |
           Group/Role/Permission management
542 |  |
           -----------------------------------------------------------------------*/
543 |  |
         /**
544 |  |
          * Provides a reference to the Group object that represents the
545 |  |
          * <a name="global">global group</a>.
546 |  |
          *
547 |  |
          * @return a Group object that represents the global group.
548 |  |
          */
549 |  |
         public static Group getGlobalGroup()
550 |  |
         {
551 | 0 |
             return getService().getGlobalGroup();
552 |  |
         }
553 |  |
554 |  |
         /**
555 |  |
          * Creates a new Group in the system. This is a convenience
556 |  |
          * method.
557 |  |
          *
558 |  |
          * @param name The name of the new Group.
559 |  |
          * @return An object representing the new Group.
560 |  |
          * @throws TurbineSecurityException if the Group could not be created.
561 |  |
          */
562 |  |
         public static Group createGroup(String name)
563 |  |
                 throws TurbineSecurityException
564 |  |
         {
565 | 0 |
             return getService().addGroup(getGroupInstance(name));
566 |  |
         }
567 |  |
568 |  |
         /**
569 |  |
          * Creates a new Permission in the system. This is a convenience
570 |  |
          * method.
571 |  |
          *
572 |  |
          * @param name The name of the new Permission.
573 |  |
          * @return An object representing the new Permission.
574 |  |
          * @throws TurbineSecurityException if the Permission could not be created.
575 |  |
          */
576 |  |
         public static Permission createPermission(String name)
577 |  |
                 throws TurbineSecurityException
578 |  |
         {
579 | 0 |
             return getService().addPermission(getPermissionInstance(name));
580 |  |
         }
581 |  |
582 |  |
         /**
583 |  |
          * Creates a new Role in the system. This is a convenience
584 |  |
          * method.
585 |  |
          *
586 |  |
          * @param name The name of the Role.
587 |  |
          *
588 |  |
          * @return An object representing the new Role.
589 |  |
          *
590 |  |
          * @throws TurbineSecurityException if the Role could not be created.
591 |  |
          */
592 |  |
         public static Role createRole(String name)
593 |  |
             throws TurbineSecurityException
594 |  |
         {
595 | 0 |
             return getService().addRole(getRoleInstance(name));
596 |  |
         }
597 |  |
598 |  |
         /**
599 |  |
          * Retrieve a Group object with specified name.
600 |  |
          *
601 |  |
          * @param groupName The name of the Group to be retrieved.
602 |  |
          * @return an object representing the Group with specified name.
603 |  |
          * @throws DataBackendException if there was an error accessing the data
604 |  |
          *         backend.
605 |  |
          * @throws UnknownEntityException if the Group is not present.
606 |  |
          */
607 |  |
         public static Group getGroupByName(String groupName)
608 |  |
                 throws DataBackendException, UnknownEntityException
609 |  |
         {
610 | 0 |
             return getService().getGroupByName(groupName);
611 |  |
         }
612 |  |
613 |  |
         /**
614 |  |
          * Retrieve a Group object with specified Id.
615 |  |
          *
616 |  |
          * @param name the name of the Group.
617 |  |
          *
618 |  |
          * @return an object representing the Group with specified name.
619 |  |
          *
620 |  |
          * @exception UnknownEntityException if the permission does not
621 |  |
          *            exist in the database.
622 |  |
          * @exception DataBackendException if there is a problem accessing the
623 |  |
          *            storage.
624 |  |
          */
625 |  |
         public static Group getGroupById(int groupId)
626 |  |
                 throws DataBackendException,
627 |  |
                        UnknownEntityException
628 |  |
         {
629 | 0 |
             return getService().getGroupById(groupId);
630 |  |
         }
631 |  |
632 |  |
         /**
633 |  |
          * Construct a blank Group object.
634 |  |
          *
635 |  |
          * This method calls getGroupClass, and then creates a new object using
636 |  |
          * the default constructor.
637 |  |
          *
638 |  |
          * @param groupName The name of the Group
639 |  |
          *
640 |  |
          * @return an object implementing Group interface.
641 |  |
          *
642 |  |
          * @throws UnknownEntityException if the object could not be instantiated.
643 |  |
          */
644 |  |
         public static Group getGroupInstance(String groupName)
645 |  |
                 throws UnknownEntityException
646 |  |
         {
647 | 0 |
             return getService().getGroupInstance(groupName);
648 |  |
         }
649 |  |
650 |  |
         /**
651 |  |
          * Construct a blank Role object.
652 |  |
          *
653 |  |
          * This method calls getRoleClass, and then creates a new object using
654 |  |
          * the default constructor.
655 |  |
          *
656 |  |
          * @param roleName The name of the role.
657 |  |
          *
658 |  |
          * @return an object implementing Role interface.
659 |  |
          *
660 |  |
          * @throws UnknownEntityException if the object could not be instantiated.
661 |  |
          */
662 |  |
         public static Role getRoleInstance(String roleName)
663 |  |
                 throws UnknownEntityException
664 |  |
         {
665 | 0 |
             return getService().getRoleInstance(roleName);
666 |  |
         }
667 |  |
668 |  |
         /**
669 |  |
          * Construct a blank Permission object.
670 |  |
          *
671 |  |
          * This method calls getPermissionClass, and then creates a new object using
672 |  |
          * the default constructor.
673 |  |
          *
674 |  |
          * @param permName The name of the permission.
675 |  |
          *
676 |  |
          * @return an object implementing Permission interface.
677 |  |
          * @throws UnknownEntityException if the object could not be instantiated.
678 |  |
          */
679 |  |
         public static Permission getPermissionInstance(String permName)
680 |  |
                 throws UnknownEntityException
681 |  |
         {
682 | 0 |
             return getService().getPermissionInstance(permName);
683 |  |
         }
684 |  |
685 |  |
         /**
686 |  |
          * Retrieve a Role object with specified name.
687 |  |
          *
688 |  |
          * @param roleName The name of the Role to be retrieved.
689 |  |
          * @return an object representing the Role with specified name.
690 |  |
          * @throws DataBackendException if there was an error accessing the data
691 |  |
          *         backend.
692 |  |
          * @throws UnknownEntityException if the Role is not present.
693 |  |
          */
694 |  |
         public static Role getRoleByName(String roleName)
695 |  |
                 throws DataBackendException, UnknownEntityException
696 |  |
         {
697 | 0 |
             return getService().getRoleByName(roleName);
698 |  |
         }
699 |  |
700 |  |
         /**
701 |  |
          * Retrieve a Role object with specified Id.
702 |  |
          *
703 |  |
          * @param name the name of the Role.
704 |  |
          *
705 |  |
          * @return an object representing the Role with specified name.
706 |  |
          *
707 |  |
          * @exception UnknownEntityException if the permission does not
708 |  |
          *            exist in the database.
709 |  |
          * @exception DataBackendException if there is a problem accessing the
710 |  |
          *            storage.
711 |  |
          */
712 |  |
         public static Role getRoleById(int roleId)
713 |  |
                 throws DataBackendException,
714 |  |
                        UnknownEntityException
715 |  |
         {
716 | 0 |
             return getService().getRoleById(roleId);
717 |  |
         }
718 |  |
719 |  |
         /**
720 |  |
          * Retrieve a Permission object with specified name.
721 |  |
          *
722 |  |
          * @param permissionName The name of the Permission to be retrieved.
723 |  |
          * @return an object representing the Permission with specified name.
724 |  |
          * @throws DataBackendException if there was an error accessing the data
725 |  |
          *         backend.
726 |  |
          * @throws UnknownEntityException if the Permission is not present.
727 |  |
          */
728 |  |
         public static Permission getPermissionByName(String permissionName)
729 |  |
                 throws DataBackendException, UnknownEntityException
730 |  |
         {
731 | 0 |
             return getService().getPermissionByName(permissionName);
732 |  |
         }
733 |  |
734 |  |
         /**
735 |  |
          * Retrieve a Permission object with specified Id.
736 |  |
          *
737 |  |
          * @param name the name of the Permission.
738 |  |
          *
739 |  |
          * @return an object representing the Permission with specified name.
740 |  |
          *
741 |  |
          * @exception UnknownEntityException if the permission does not
742 |  |
          *            exist in the database.
743 |  |
          * @exception DataBackendException if there is a problem accessing the
744 |  |
          *            storage.
745 |  |
          */
746 |  |
         public static Permission getPermissionById(int permissionId)
747 |  |
                 throws DataBackendException,
748 |  |
                        UnknownEntityException
749 |  |
         {
750 | 0 |
             return getService().getPermissionById(permissionId);
751 |  |
         }
752 |  |
753 |  |
         /**
754 |  |
          * Retrieve a set of Groups that meet the specified Criteria.
755 |  |
          *
756 |  |
          * @param criteria A Criteria of Group selection.
757 |  |
          * @return a set of Groups that meet the specified Criteria.
758 |  |
          * @throws DataBackendException if there was an error accessing the data
759 |  |
          *         backend.
760 |  |
          */
761 |  |
         public static GroupSet getGroups(Object criteria)
762 |  |
                 throws DataBackendException
763 |  |
         {
764 | 0 |
             return getService().getGroups(criteria);
765 |  |
         }
766 |  |
767 |  |
         /**
768 |  |
          * Retrieve a set of Roles that meet the specified Criteria.
769 |  |
          *
770 |  |
          * @param criteria a Criteria of Roles selection.
771 |  |
          * @return a set of Roles that meet the specified Criteria.
772 |  |
          * @throws DataBackendException if there was an error accessing the data
773 |  |
          *         backend.
774 |  |
          */
775 |  |
         public static RoleSet getRoles(Object criteria)
776 |  |
                 throws DataBackendException
777 |  |
         {
778 | 0 |
             return getService().getRoles(criteria);
779 |  |
         }
780 |  |
781 |  |
         /**
782 |  |
          * Retrieve a set of Permissions that meet the specified Criteria.
783 |  |
          *
784 |  |
          * @param criteria a Criteria of Permissions selection.
785 |  |
          * @return a set of Permissions that meet the specified Criteria.
786 |  |
          * @throws DataBackendException if there was an error accessing the data
787 |  |
          *         backend.
788 |  |
          */
789 |  |
         public static PermissionSet getPermissions(Object criteria)
790 |  |
                 throws DataBackendException
791 |  |
         {
792 | 0 |
             return getService().getPermissions(criteria);
793 |  |
         }
794 |  |
795 |  |
         /**
796 |  |
          * Retrieves all groups defined in the system.
797 |  |
          *
798 |  |
          * @return the names of all groups defined in the system.
799 |  |
          * @throws DataBackendException if there was an error accessing the data
800 |  |
          *         backend.
801 |  |
          */
802 |  |
         public static GroupSet getAllGroups()
803 |  |
                 throws DataBackendException
804 |  |
         {
805 | 0 |
             return getService().getAllGroups();
806 |  |
         }
807 |  |
808 |  |
         /**
809 |  |
          * Retrieves all roles defined in the system.
810 |  |
          *
811 |  |
          * @return the names of all roles defined in the system.
812 |  |
          * @throws DataBackendException if there was an error accessing the data
813 |  |
          *         backend.
814 |  |
          */
815 |  |
         public static RoleSet getAllRoles()
816 |  |
                 throws DataBackendException
817 |  |
         {
818 | 0 |
             return getService().getAllRoles();
819 |  |
         }
820 |  |
821 |  |
         /**
822 |  |
          * Retrieves all permissions defined in the system.
823 |  |
          *
824 |  |
          * @return the names of all roles defined in the system.
825 |  |
          * @throws DataBackendException if there was an error accessing the data
826 |  |
          *         backend.
827 |  |
          */
828 |  |
         public static PermissionSet getAllPermissions()
829 |  |
                 throws DataBackendException
830 |  |
         {
831 | 0 |
             return getService().getAllPermissions();
832 |  |
         }
833 |  |
834 |  |
         /**
835 |  |
          * Retrieves all permissions associated with a role.
836 |  |
          *
837 |  |
          * @param role the role name, for which the permissions are to be retrieved.
838 |  |
          * @return the Permissions for the specified role
839 |  |
          * @throws DataBackendException if there was an error accessing the data
840 |  |
          *         backend.
841 |  |
          * @throws UnknownEntityException if the role is not present.
842 |  |
          */
843 |  |
         public static PermissionSet getPermissions(Role role)
844 |  |
                 throws DataBackendException, UnknownEntityException
845 |  |
         {
846 | 0 |
             return getService().getPermissions(role);
847 |  |
         }
848 |  |
849 |  |
         /**
850 |  |
          * Stores Group's attributes. The Groups is required to exist in the system.
851 |  |
          *
852 |  |
          * @param group The Group to be stored.
853 |  |
          * @throws DataBackendException if there was an error accessing the data
854 |  |
          *         backend.
855 |  |
          * @throws UnknownEntityException if the group does not exist.
856 |  |
          */
857 |  |
         public static void saveGroup(Group group)
858 |  |
                 throws DataBackendException, UnknownEntityException
859 |  |
         {
860 | 0 |
             getService().saveGroup(group);
861 | 0 |
         }
862 |  |
863 |  |
         /**
864 |  |
          * Stores Role's attributes. The Roles is required to exist in the system.
865 |  |
          *
866 |  |
          * @param role The Role to be stored.
867 |  |
          * @throws DataBackendException if there was an error accessing the data
868 |  |
          *         backend.
869 |  |
          * @throws UnknownEntityException if the role does not exist.
870 |  |
          */
871 |  |
         public static void saveRole(Role role)
872 |  |
                 throws DataBackendException, UnknownEntityException
873 |  |
         {
874 | 0 |
             getService().saveRole(role);
875 | 0 |
         }
876 |  |
877 |  |
         /**
878 |  |
          * Stores Permission's attributes. The Permissions is required to exist in
879 |  |
          * the system.
880 |  |
          *
881 |  |
          * @param permission The Permission to be stored.
882 |  |
          * @throws DataBackendException if there was an error accessing the data
883 |  |
          *         backend.
884 |  |
          * @throws UnknownEntityException if the permission does not exist.
885 |  |
          */
886 |  |
         public static void savePermission(Permission permission)
887 |  |
                 throws DataBackendException, UnknownEntityException
888 |  |
         {
889 | 0 |
             getService().savePermission(permission);
890 | 0 |
         }
891 |  |
892 |  |
         /**
893 |  |
          * Creates a new group with specified attributes.
894 |  |
          *
895 |  |
          * @param group the object describing the group to be created.
896 |  |
          * @throws DataBackendException if there was an error accessing the data
897 |  |
          *         backend.
898 |  |
          * @throws EntityExistsException if the group already exists.
899 |  |
          */
900 |  |
         public static void addGroup(Group group)
901 |  |
                 throws DataBackendException, EntityExistsException
902 |  |
         {
903 | 0 |
             getService().addGroup(group);
904 | 0 |
         }
905 |  |
906 |  |
         /**
907 |  |
          * Creates a new role with specified attributes.
908 |  |
          *
909 |  |
          * @param role the objects describing the role to be created.
910 |  |
          * @throws DataBackendException if there was an error accessing the data
911 |  |
          *         backend.
912 |  |
          * @throws EntityExistsException if the role already exists.
913 |  |
          */
914 |  |
         public static void addRole(Role role)
915 |  |
                 throws DataBackendException, EntityExistsException
916 |  |
         {
917 | 0 |
             getService().addRole(role);
918 | 0 |
         }
919 |  |
920 |  |
         /**
921 |  |
          * Creates a new permission with specified attributes.
922 |  |
          *
923 |  |
          * @param permission the objects describing the permission to be created.
924 |  |
          * @throws DataBackendException if there was an error accessing the data
925 |  |
          *         backend.
926 |  |
          * @throws EntityExistsException if the permission already exists.
927 |  |
          */
928 |  |
         public static void addPermission(Permission permission)
929 |  |
                 throws DataBackendException, EntityExistsException
930 |  |
         {
931 | 0 |
             getService().addPermission(permission);
932 | 0 |
         }
933 |  |
934 |  |
         /**
935 |  |
          * Removes a Group from the system.
936 |  |
          *
937 |  |
          * @param group the object describing group to be removed.
938 |  |
          * @throws DataBackendException if there was an error accessing the data
939 |  |
          *         backend.
940 |  |
          * @throws UnknownEntityException if the group does not exist.
941 |  |
          */
942 |  |
         public static void removeGroup(Group group)
943 |  |
                 throws DataBackendException, UnknownEntityException
944 |  |
         {
945 | 0 |
             getService().removeGroup(group);
946 | 0 |
         }
947 |  |
948 |  |
         /**
949 |  |
          * Removes a Role from the system.
950 |  |
          *
951 |  |
          * @param role The object describing the role to be removed.
952 |  |
          * @throws DataBackendException if there was an error accessing the data backend.
953 |  |
          * @throws UnknownEntityException if the role does not exist.
954 |  |
          */
955 |  |
         public static void removeRole(Role role)
956 |  |
                 throws DataBackendException, UnknownEntityException
957 |  |
         {
958 | 0 |
             getService().removeRole(role);
959 | 0 |
         }
960 |  |
961 |  |
         /**
962 |  |
          * Removes a Permission from the system.
963 |  |
          *
964 |  |
          * @param permission The object describing the permission to be removed.
965 |  |
          * @throws DataBackendException if there was an error accessing the data
966 |  |
          *         backend.
967 |  |
          * @throws UnknownEntityException if the permission does not exist.
968 |  |
          */
969 |  |
         public static void removePermission(Permission permission)
970 |  |
                 throws DataBackendException, UnknownEntityException
971 |  |
         {
972 | 0 |
             getService().removePermission(permission);
973 | 0 |
         }
974 |  |
975 |  |
         /**
976 |  |
          * Renames an existing Group.
977 |  |
          *
978 |  |
          * @param group The object describing the group to be renamed.
979 |  |
          * @param name the new name for the group.
980 |  |
          * @throws DataBackendException if there was an error accessing the data
981 |  |
          *         backend.
982 |  |
          * @throws UnknownEntityException if the group does not exist.
983 |  |
          */
984 |  |
         public static void renameGroup(Group group, String name)
985 |  |
                 throws DataBackendException, UnknownEntityException
986 |  |
         {
987 | 0 |
             getService().renameGroup(group, name);
988 | 0 |
         }
989 |  |
990 |  |
         /**
991 |  |
          * Renames an existing Role.
992 |  |
          *
993 |  |
          * @param role The object describing the role to be renamed.
994 |  |
          * @param name the new name for the role.
995 |  |
          * @throws DataBackendException if there was an error accessing the data
996 |  |
          *         backend.
997 |  |
          * @throws UnknownEntityException if the role does not exist.
998 |  |
          */
999 |  |
         public static void renameRole(Role role, String name)
1000 |  |
                 throws DataBackendException, UnknownEntityException
1001 |  |
         {
1002 | 0 |
             getService().renameRole(role, name);
1003 | 0 |
         }
1004 |  |
1005 |  |
         /**
1006 |  |
          * Renames an existing Permission.
1007 |  |
          *
1008 |  |
          * @param permission The object describing the permission to be renamed.
1009 |  |
          * @param name the new name for the permission.
1010 |  |
          * @throws DataBackendException if there was an error accessing the data
1011 |  |
          *         backend.
1012 |  |
          * @throws UnknownEntityException if the permission does not exist.
1013 |  |
          */
1014 |  |
         public static void renamePermission(Permission permission, String name)
1015 |  |
                 throws DataBackendException, UnknownEntityException
1016 |  |
         {
1017 | 0 |
             getService().renamePermission(permission, name);
1018 | 0 |
         }
1019 |  |
     }