Coverage report

  %line %branch
org.apache.turbine.services.security.TurbineSecurity
14% 
100% 

 1  
 package org.apache.turbine.services.security;
 2  
 
 3  
 /*
 4  
  * Copyright 2001-2005 The Apache Software Foundation.
 5  
  *
 6  
  * Licensed under the Apache License, Version 2.0 (the "License")
 7  
  * you may not use this file except in compliance with the License.
 8  
  * You may obtain a copy of the License at
 9  
  *
 10  
  *     http://www.apache.org/licenses/LICENSE-2.0
 11  
  *
 12  
  * Unless required by applicable law or agreed to in writing, software
 13  
  * distributed under the License is distributed on an "AS IS" BASIS,
 14  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15  
  * See the License for the specific language governing permissions and
 16  
  * limitations under the License.
 17  
  */
 18  
 
 19  
 import java.util.List;
 20  
 
 21  
 import org.apache.torque.util.Criteria;
 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 264148 2005-08-29 14:21:04Z henning $
 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  1328
         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  16
         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  18
         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  286
         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  222
         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  298
         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  174
         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  20
         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  38
         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  0
         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  
      * Retrieve a set of users that meet the specified criteria.
 284  
      *
 285  
      * As the keys for the criteria, you should use the constants that
 286  
      * are defined in {@link User} interface, plus the names
 287  
      * of the custom attributes you added to your user representation
 288  
      * in the data storage. Use verbatim names of the attributes -
 289  
      * without table name prefix in case of DB implementation.
 290  
      *
 291  
      * @param criteria The criteria of selection.
 292  
      * @return a List of users meeting the criteria.
 293  
      * @throws DataBackendException if there is a problem accessing the
 294  
      *         storage.
 295  
      */
 296  
     public static User[] getUsers(Criteria criteria)
 297  
             throws DataBackendException
 298  
     {
 299  0
         return getService().getUsers(criteria);
 300  
     }
 301  
 
 302  
     /**
 303  
      * Retrieve a set of users that meet the specified criteria.
 304  
      *
 305  
      * As the keys for the criteria, you should use the constants that
 306  
      * are defined in {@link User} interface, plus the names
 307  
      * of the custom attributes you added to your user representation
 308  
      * in the data storage. Use verbatim names of the attributes -
 309  
      * without table name prefix in case of DB implementation.
 310  
      *
 311  
      * @param criteria The criteria of selection.
 312  
      * @return a List of users meeting the criteria.
 313  
      * @throws DataBackendException if there is a problem accessing the
 314  
      *         storage.
 315  
      */
 316  
     public static List getUserList(Criteria criteria)
 317  
             throws DataBackendException
 318  
     {
 319  0
         return getService().getUserList(criteria);
 320  
     }
 321  
 
 322  
     /**
 323  
      * Constructs an User object to represent an anonymous user of the
 324  
      * application.
 325  
      *
 326  
      * @return An anonymous Turbine User.
 327  
      * @throws UnknownEntityException if the anonymous User object couldn't be
 328  
      *         constructed.
 329  
      */
 330  
     public static User getAnonymousUser()
 331  
             throws UnknownEntityException
 332  
     {
 333  0
         return getService().getAnonymousUser();
 334  
     }
 335  
 
 336  
     /**
 337  
      * Checks whether a passed user object matches the anonymous user pattern
 338  
      * according to the configured service
 339  
      *
 340  
      * @param user A user object
 341  
      * @return True if this is an anonymous user
 342  
      */
 343  
     public static boolean isAnonymousUser(User user)
 344  
     {
 345  0
         return getService().isAnonymousUser(user);
 346  
     }
 347  
 
 348  
     /**
 349  
      * Saves User's data in the permanent storage. The user account is required
 350  
      * to exist in the storage.
 351  
      *
 352  
      * @param user The User object to save.
 353  
      * @throws UnknownEntityException if the user's account does not
 354  
      *         exist in the database.
 355  
      * @throws DataBackendException if there is a problem accessing the
 356  
      *         storage.
 357  
      */
 358  
     public static void saveUser(User user)
 359  
             throws UnknownEntityException, DataBackendException
 360  
     {
 361  0
         getService().saveUser(user);
 362  0
     }
 363  
 
 364  
     /**
 365  
      * Saves User data when the session is unbound. The user account is required
 366  
      * to exist in the storage.
 367  
      *
 368  
      * LastLogin, AccessCounter, persistent pull tools, and any data stored
 369  
      * in the permData hashtable that is not mapped to a column will be saved.
 370  
      *
 371  
      * @exception UnknownEntityException if the user's account does not
 372  
      *            exist in the database.
 373  
      * @exception DataBackendException if there is a problem accessing the
 374  
      *            storage.
 375  
      */
 376  
     public static void saveOnSessionUnbind(User user)
 377  
             throws UnknownEntityException, DataBackendException
 378  
     {
 379  0
         getService().saveOnSessionUnbind(user);
 380  0
     }
 381  
 
 382  
     /**
 383  
      * Change the password for an User.
 384  
      *
 385  
      * @param user an User to change password for.
 386  
      * @param oldPassword the current password supplied by the user.
 387  
      * @param newPassword the current password requested by the user.
 388  
      * @throws PasswordMismatchException if the supplied password was
 389  
      *         incorrect.
 390  
      * @throws UnknownEntityException if the user's record does not
 391  
      *         exist in the database.
 392  
      * @throws DataBackendException if there is a problem accessing the
 393  
      *         storage.
 394  
      */
 395  
     public static void changePassword(User user, String oldPassword,
 396  
                                       String newPassword)
 397  
             throws PasswordMismatchException, UnknownEntityException,
 398  
             DataBackendException
 399  
     {
 400  0
         getService().changePassword(user, oldPassword, newPassword);
 401  0
     }
 402  
 
 403  
     /**
 404  
      * Forcibly sets new password for an User.
 405  
      *
 406  
      * This is supposed by the administrator to change the forgotten or
 407  
      * compromised passwords. Certain implementatations of this feature
 408  
      * would require administrative level access to the authenticating
 409  
      * server / program.
 410  
      *
 411  
      * @param user an User to change password for.
 412  
      * @param password the new password.
 413  
      * @throws UnknownEntityException if the user's record does not
 414  
      *         exist in the database.
 415  
      * @throws DataBackendException if there is a problem accessing the
 416  
      *         storage.
 417  
      */
 418  
     public static void forcePassword(User user, String password)
 419  
             throws UnknownEntityException, DataBackendException
 420  
     {
 421  0
         getService().forcePassword(user, password);
 422  0
     }
 423  
 
 424  
     /*-----------------------------------------------------------------------
 425  
       Creation of AccessControlLists
 426  
       -----------------------------------------------------------------------*/
 427  
 
 428  
     /**
 429  
      * Constructs an AccessControlList for a specific user.
 430  
      *
 431  
      * @param user the user for whom the AccessControlList are to be retrieved
 432  
      * @return The AccessControList object constructed from the user object.
 433  
      * @throws DataBackendException if there was an error accessing the data
 434  
      *         backend.
 435  
      * @throws UnknownEntityException if user account is not present.
 436  
      */
 437  
     public static AccessControlList getACL(User user)
 438  
             throws DataBackendException, UnknownEntityException
 439  
     {
 440  0
         return getService().getACL(user);
 441  
     }
 442  
 
 443  
     /*-----------------------------------------------------------------------
 444  
       Security management
 445  
       -----------------------------------------------------------------------*/
 446  
 
 447  
     /**
 448  
      * Grant an User a Role in a Group.
 449  
      *
 450  
      * @param user the user.
 451  
      * @param group the group.
 452  
      * @param role the role.
 453  
      * @throws DataBackendException if there was an error accessing the data
 454  
      *         backend.
 455  
      * @throws UnknownEntityException if user account, group or role is not
 456  
      *         present.
 457  
      */
 458  
     public static void grant(User user, Group group, Role role)
 459  
             throws DataBackendException, UnknownEntityException
 460  
     {
 461  0
         getService().grant(user, group, role);
 462  0
     }
 463  
 
 464  
     /**
 465  
      * Revoke a Role in a Group from an User.
 466  
      *
 467  
      * @param user the user.
 468  
      * @param group the group.
 469  
      * @param role the role.
 470  
      * @throws DataBackendException if there was an error accessing the data
 471  
      *         backend.
 472  
      * @throws UnknownEntityException if user account, group or role is not
 473  
      *         present.
 474  
      */
 475  
     public static void revoke(User user, Group group, Role role)
 476  
             throws DataBackendException, UnknownEntityException
 477  
     {
 478  0
         getService().revoke(user, group, role);
 479  0
     }
 480  
 
 481  
     /**
 482  
      * Revokes all roles from an User.
 483  
      *
 484  
      * This method is used when deleting an account.
 485  
      *
 486  
      * @param user the User.
 487  
      * @throws DataBackendException if there was an error accessing the data
 488  
      *         backend.
 489  
      * @throws UnknownEntityException if the account is not present.
 490  
      */
 491  
     public static void revokeAll(User user)
 492  
             throws DataBackendException, UnknownEntityException
 493  
     {
 494  0
         getService().revokeAll(user);
 495  0
     }
 496  
 
 497  
     /**
 498  
      * Grants a Role a Permission
 499  
      *
 500  
      * @param role the Role.
 501  
      * @param permission the Permission.
 502  
      * @throws DataBackendException if there was an error accessing the data
 503  
      *         backend.
 504  
      * @throws UnknownEntityException if role or permission is not present.
 505  
      */
 506  
     public static void grant(Role role, Permission permission)
 507  
             throws DataBackendException, UnknownEntityException
 508  
     {
 509  0
         getService().grant(role, permission);
 510  0
     }
 511  
 
 512  
     /**
 513  
      * Revokes a Permission from a Role.
 514  
      *
 515  
      * @param role the Role.
 516  
      * @param permission the Permission.
 517  
      * @throws DataBackendException if there was an error accessing the data
 518  
      *         backend.
 519  
      * @throws UnknownEntityException if role or permission is not present.
 520  
      */
 521  
     public static void revoke(Role role, Permission permission)
 522  
             throws DataBackendException, UnknownEntityException
 523  
     {
 524  0
         getService().revoke(role, permission);
 525  0
     }
 526  
 
 527  
     /**
 528  
      * Revokes all permissions from a Role.
 529  
      *
 530  
      * This method is user when deleting a Role.
 531  
      *
 532  
      * @param role the Role
 533  
      * @throws DataBackendException if there was an error accessing the data
 534  
      *         backend.
 535  
      * @throws  UnknownEntityException if the Role is not present.
 536  
      */
 537  
     public static void revokeAll(Role role)
 538  
             throws DataBackendException, UnknownEntityException
 539  
     {
 540  0
         getService().revokeAll(role);
 541  0
     }
 542  
 
 543  
     /*-----------------------------------------------------------------------
 544  
       Account management
 545  
       -----------------------------------------------------------------------*/
 546  
 
 547  
     /**
 548  
      * Creates new user account with specified attributes.
 549  
      *
 550  
      * <strong>TODO</strong> throw more specific exception<br>
 551  
      *
 552  
      * @param user the object describing account to be created.
 553  
      * @param password password for the new user
 554  
      * @throws DataBackendException if there was an error accessing the data
 555  
      *         backend.
 556  
      * @throws EntityExistsException if the user account already exists.
 557  
      */
 558  
     public static void addUser(User user, String password)
 559  
             throws DataBackendException, EntityExistsException
 560  
     {
 561  0
         getService().addUser(user, password);
 562  0
     }
 563  
 
 564  
     /**
 565  
      * Removes an user account from the system.
 566  
      *
 567  
      * <strong>TODO</strong> throw more specific exception<br>
 568  
      *
 569  
      * @param user the object describing the account to be removed.
 570  
      * @throws DataBackendException if there was an error accessing the data
 571  
      *         backend.
 572  
      * @throws UnknownEntityException if the user account is not present.
 573  
      */
 574  
     public static void removeUser(User user)
 575  
             throws DataBackendException, UnknownEntityException
 576  
     {
 577  0
         getService().removeUser(user);
 578  0
     }
 579  
 
 580  
     /*-----------------------------------------------------------------------
 581  
       Group/Role/Permission management
 582  
       -----------------------------------------------------------------------*/
 583  
     /**
 584  
      * Provides a reference to the Group object that represents the
 585  
      * <a name="global">global group</a>.
 586  
      *
 587  
      * @return a Group object that represents the global group.
 588  
      */
 589  
     public static Group getGlobalGroup()
 590  
     {
 591  4
         return getService().getGlobalGroup();
 592  
     }
 593  
 
 594  
     /**
 595  
      * Creates a new Group in the system. This is a convenience
 596  
      * method.
 597  
      *
 598  
      * @param name The name of the new Group.
 599  
      * @return An object representing the new Group.
 600  
      * @throws TurbineSecurityException if the Group could not be created.
 601  
      */
 602  
     public static Group createGroup(String name)
 603  
             throws TurbineSecurityException
 604  
     {
 605  0
         return getService().addGroup(getGroupInstance(name));
 606  
     }
 607  
 
 608  
     /**
 609  
      * Creates a new Permission in the system. This is a convenience
 610  
      * method.
 611  
      *
 612  
      * @param name The name of the new Permission.
 613  
      * @return An object representing the new Permission.
 614  
      * @throws TurbineSecurityException if the Permission could not be created.
 615  
      */
 616  
     public static Permission createPermission(String name)
 617  
             throws TurbineSecurityException
 618  
     {
 619  0
         return getService().addPermission(getPermissionInstance(name));
 620  
     }
 621  
 
 622  
     /**
 623  
      * Creates a new Role in the system. This is a convenience
 624  
      * method.
 625  
      *
 626  
      * @param name The name of the Role.
 627  
      *
 628  
      * @return An object representing the new Role.
 629  
      *
 630  
      * @throws TurbineSecurityException if the Role could not be created.
 631  
      */
 632  
     public static Role createRole(String name)
 633  
         throws TurbineSecurityException
 634  
     {
 635  0
         return getService().addRole(getRoleInstance(name));
 636  
     }
 637  
 
 638  
     /**
 639  
      * Retrieve a Group object with specified name.
 640  
      *
 641  
      * @param groupName The name of the Group to be retrieved.
 642  
      * @return an object representing the Group with specified name.
 643  
      * @throws DataBackendException if there was an error accessing the data
 644  
      *         backend.
 645  
      * @throws UnknownEntityException if the Group is not present.
 646  
      * @deprecated Use <a href="#getGroupByName">getGroupByName</a> instead.
 647  
      */
 648  
     public static Group getGroup(String groupName)
 649  
             throws DataBackendException, UnknownEntityException
 650  
     {
 651  0
         return getService().getGroup(groupName);
 652  
     }
 653  
 
 654  
     /**
 655  
      * Retrieve a Group object with specified name.
 656  
      *
 657  
      * @param groupName The name of the Group to be retrieved.
 658  
      * @return an object representing the Group with specified name.
 659  
      * @throws DataBackendException if there was an error accessing the data
 660  
      *         backend.
 661  
      * @throws UnknownEntityException if the Group is not present.
 662  
      */
 663  
     public static Group getGroupByName(String groupName)
 664  
             throws DataBackendException, UnknownEntityException
 665  
     {
 666  40
         return getService().getGroupByName(groupName);
 667  
     }
 668  
 
 669  
     /**
 670  
      * Retrieve a Group object with specified Id.
 671  
      *
 672  
      * @param name the name of the Group.
 673  
      *
 674  
      * @return an object representing the Group with specified name.
 675  
      *
 676  
      * @exception UnknownEntityException if the permission does not
 677  
      *            exist in the database.
 678  
      * @exception DataBackendException if there is a problem accessing the
 679  
      *            storage.
 680  
      */
 681  
     public static Group getGroupById(int groupId)
 682  
             throws DataBackendException,
 683  
                    UnknownEntityException
 684  
     {
 685  0
         return getService().getGroupById(groupId);
 686  
     }
 687  
 
 688  
     /**
 689  
      * Construct a blank Group object.
 690  
      *
 691  
      * This method calls getGroupClass, and then creates a new object using
 692  
      * the default constructor.
 693  
      *
 694  
      * @param groupName The name of the Group
 695  
      *
 696  
      * @return an object implementing Group interface.
 697  
      *
 698  
      * @throws UnknownEntityException if the object could not be instantiated.
 699  
      */
 700  
     public static Group getGroupInstance(String groupName)
 701  
             throws UnknownEntityException
 702  
     {
 703  0
         return getService().getGroupInstance(groupName);
 704  
     }
 705  
 
 706  
     /**
 707  
      * Retrieves a named Group. If the Group does not exist, it creates
 708  
      * a new Group based on the Services Group implementation. It is ok
 709  
      * to pass in null or "" here and then use Group.setName() at a later
 710  
      * point.
 711  
      *
 712  
      * @param groupName The name of the Group to be retrieved.
 713  
      * @return an object representing the Group with specified name.
 714  
      * @throws DataBackendException if there was an error accessing the data
 715  
      *         backend.
 716  
      * @deprecated Use getGroupInstance(String name) instead.
 717  
      */
 718  
     public static Group getNewGroup(String groupName)
 719  
             throws DataBackendException
 720  
     {
 721  0
         return getService().getNewGroup(groupName);
 722  
     }
 723  
 
 724  
     /**
 725  
      * Construct a blank Role object.
 726  
      *
 727  
      * This method calls getRoleClass, and then creates a new object using
 728  
      * the default constructor.
 729  
      *
 730  
      * @param roleName The name of the role.
 731  
      *
 732  
      * @return an object implementing Role interface.
 733  
      *
 734  
      * @throws UnknownEntityException if the object could not be instantiated.
 735  
      */
 736  
     public static Role getRoleInstance(String roleName)
 737  
             throws UnknownEntityException
 738  
     {
 739  0
         return getService().getRoleInstance(roleName);
 740  
     }
 741  
 
 742  
     /**
 743  
      * Retrieves a named Role. If the Role does not exist, it creates a new Role
 744  
      * based on the Services Role implementation.
 745  
      * It is ok to pass in null or "" here and then use Role.setName() at
 746  
      * a later point.
 747  
      *
 748  
      * @param roleName The name of the Role to be retrieved.
 749  
      * @return an object representing the Role with specified name.
 750  
      * @throws TurbineSecurityException if the Role could not be retrieved
 751  
      * @deprecated Use getRoleInstance(String name) instead.
 752  
      */
 753  
     public static Role getNewRole(String roleName)
 754  
             throws TurbineSecurityException
 755  
     {
 756  0
         return getService().getNewRole(roleName);
 757  
     }
 758  
 
 759  
     /**
 760  
      * Construct a blank Permission object.
 761  
      *
 762  
      * This method calls getPermissionClass, and then creates a new object using
 763  
      * the default constructor.
 764  
      *
 765  
      * @param permName The name of the permission.
 766  
      *
 767  
      * @return an object implementing Permission interface.
 768  
      * @throws UnknownEntityException if the object could not be instantiated.
 769  
      */
 770  
     public static Permission getPermissionInstance(String permName)
 771  
             throws UnknownEntityException
 772  
     {
 773  0
         return getService().getPermissionInstance(permName);
 774  
     }
 775  
 
 776  
     /**
 777  
      * Retrieves a named Permission. If the Permission does not exist, it
 778  
      * creates a new Permission based on the Services Permission implementation.
 779  
      * It is ok to pass in null or "" here and then use Permission.setName() at
 780  
      * a later point.
 781  
      *
 782  
      * @param permissionName The name of the Permission to be retrieved.
 783  
      * @return an object representing the Permission with specified name.
 784  
      * @throws DataBackendException if there was an error accessing the data
 785  
      *         backend.
 786  
      * @deprecated Use getPermissionInstance(String name) instead.
 787  
      */
 788  
     public static Permission getNewPermission(String permissionName)
 789  
             throws DataBackendException
 790  
     {
 791  0
         return getService().getNewPermission(permissionName);
 792  
     }
 793  
 
 794  
     /**
 795  
      * Retrieve a Role object with specified name.
 796  
      *
 797  
      * @param roleName The name of the Role to be retrieved.
 798  
      * @return an object representing the Role with specified name.
 799  
      * @throws DataBackendException if there was an error accessing the data
 800  
      *         backend.
 801  
      * @throws UnknownEntityException if the Role is not present.
 802  
      * @deprecated Use <a href="#getRoleByName">getRoleByName</a> instead.
 803  
      */
 804  
     public static Role getRole(String roleName)
 805  
             throws DataBackendException, UnknownEntityException
 806  
     {
 807  0
         return getService().getRole(roleName);
 808  
     }
 809  
 
 810  
     /**
 811  
      * Retrieve a Role object with specified name.
 812  
      *
 813  
      * @param roleName The name of the Role to be retrieved.
 814  
      * @return an object representing the Role with specified name.
 815  
      * @throws DataBackendException if there was an error accessing the data
 816  
      *         backend.
 817  
      * @throws UnknownEntityException if the Role is not present.
 818  
      */
 819  
     public static Role getRoleByName(String roleName)
 820  
             throws DataBackendException, UnknownEntityException
 821  
     {
 822  16
         return getService().getRoleByName(roleName);
 823  
     }
 824  
 
 825  
     /**
 826  
      * Retrieve a Role object with specified Id.
 827  
      *
 828  
      * @param name the name of the Role.
 829  
      *
 830  
      * @return an object representing the Role with specified name.
 831  
      *
 832  
      * @exception UnknownEntityException if the permission does not
 833  
      *            exist in the database.
 834  
      * @exception DataBackendException if there is a problem accessing the
 835  
      *            storage.
 836  
      */
 837  
     public static Role getRoleById(int roleId)
 838  
             throws DataBackendException,
 839  
                    UnknownEntityException
 840  
     {
 841  0
         return getService().getRoleById(roleId);
 842  
     }
 843  
 
 844  
     /**
 845  
      * Retrieve a Permission object with specified name.
 846  
      *
 847  
      * @param permissionName The name of the Permission to be retrieved.
 848  
      * @return an object representing the Permission with specified name.
 849  
      * @throws DataBackendException if there was an error accessing the data
 850  
      *         backend.
 851  
      * @throws UnknownEntityException if the Permission is not present.
 852  
      * @deprecated Use <a href="#getPermissionByName">getPermissionByName</a> instead.
 853  
      */
 854  
     public static Permission getPermission(String permissionName)
 855  
             throws DataBackendException, UnknownEntityException
 856  
     {
 857  0
         return getService().getPermission(permissionName);
 858  
     }
 859  
 
 860  
     /**
 861  
      * Retrieve a Permission object with specified name.
 862  
      *
 863  
      * @param permissionName The name of the Permission to be retrieved.
 864  
      * @return an object representing the Permission with specified name.
 865  
      * @throws DataBackendException if there was an error accessing the data
 866  
      *         backend.
 867  
      * @throws UnknownEntityException if the Permission is not present.
 868  
      */
 869  
     public static Permission getPermissionByName(String permissionName)
 870  
             throws DataBackendException, UnknownEntityException
 871  
     {
 872  24
         return getService().getPermissionByName(permissionName);
 873  
     }
 874  
 
 875  
     /**
 876  
      * Retrieve a Permission object with specified Id.
 877  
      *
 878  
      * @param name the name of the Permission.
 879  
      *
 880  
      * @return an object representing the Permission with specified name.
 881  
      *
 882  
      * @exception UnknownEntityException if the permission does not
 883  
      *            exist in the database.
 884  
      * @exception DataBackendException if there is a problem accessing the
 885  
      *            storage.
 886  
      */
 887  
     public static Permission getPermissionById(int permissionId)
 888  
             throws DataBackendException,
 889  
                    UnknownEntityException
 890  
     {
 891  0
         return getService().getPermissionById(permissionId);
 892  
     }
 893  
 
 894  
     /**
 895  
      * Retrieve a set of Groups that meet the specified Criteria.
 896  
      *
 897  
      * @param criteria A Criteria of Group selection.
 898  
      * @return a set of Groups that meet the specified Criteria.
 899  
      * @throws DataBackendException if there was an error accessing the data
 900  
      *         backend.
 901  
      */
 902  
     public static GroupSet getGroups(Criteria criteria)
 903  
             throws DataBackendException
 904  
     {
 905  0
         return getService().getGroups(criteria);
 906  
     }
 907  
 
 908  
     /**
 909  
      * Retrieve a set of Roles that meet the specified Criteria.
 910  
      *
 911  
      * @param criteria a Criteria of Roles selection.
 912  
      * @return a set of Roles that meet the specified Criteria.
 913  
      * @throws DataBackendException if there was an error accessing the data
 914  
      *         backend.
 915  
      */
 916  
     public static RoleSet getRoles(Criteria criteria)
 917  
             throws DataBackendException
 918  
     {
 919  0
         return getService().getRoles(criteria);
 920  
     }
 921  
 
 922  
     /**
 923  
      * Retrieve a set of Permissions that meet the specified Criteria.
 924  
      *
 925  
      * @param criteria a Criteria of Permissions selection.
 926  
      * @return a set of Permissions that meet the specified Criteria.
 927  
      * @throws DataBackendException if there was an error accessing the data
 928  
      *         backend.
 929  
      */
 930  
     public static PermissionSet getPermissions(Criteria criteria)
 931  
             throws DataBackendException
 932  
     {
 933  0
         return getService().getPermissions(criteria);
 934  
     }
 935  
 
 936  
     /**
 937  
      * Retrieves all groups defined in the system.
 938  
      *
 939  
      * @return the names of all groups defined in the system.
 940  
      * @throws DataBackendException if there was an error accessing the data
 941  
      *         backend.
 942  
      */
 943  
     public static GroupSet getAllGroups()
 944  
             throws DataBackendException
 945  
     {
 946  0
         return getService().getAllGroups();
 947  
     }
 948  
 
 949  
     /**
 950  
      * Retrieves all roles defined in the system.
 951  
      *
 952  
      * @return the names of all roles defined in the system.
 953  
      * @throws DataBackendException if there was an error accessing the data
 954  
      *         backend.
 955  
      */
 956  
     public static RoleSet getAllRoles()
 957  
             throws DataBackendException
 958  
     {
 959  0
         return getService().getAllRoles();
 960  
     }
 961  
 
 962  
     /**
 963  
      * Retrieves all permissions defined in the system.
 964  
      *
 965  
      * @return the names of all roles defined in the system.
 966  
      * @throws DataBackendException if there was an error accessing the data
 967  
      *         backend.
 968  
      */
 969  
     public static PermissionSet getAllPermissions()
 970  
             throws DataBackendException
 971  
     {
 972  0
         return getService().getAllPermissions();
 973  
     }
 974  
 
 975  
     /**
 976  
      * Retrieves all permissions associated with a role.
 977  
      *
 978  
      * @param role the role name, for which the permissions are to be retrieved.
 979  
      * @return the Permissions for the specified role
 980  
      * @throws DataBackendException if there was an error accessing the data
 981  
      *         backend.
 982  
      * @throws UnknownEntityException if the role is not present.
 983  
      */
 984  
     public static PermissionSet getPermissions(Role role)
 985  
             throws DataBackendException, UnknownEntityException
 986  
     {
 987  0
         return getService().getPermissions(role);
 988  
     }
 989  
 
 990  
     /**
 991  
      * Stores Group's attributes. The Groups is required to exist in the system.
 992  
      *
 993  
      * @param group The Group to be stored.
 994  
      * @throws DataBackendException if there was an error accessing the data
 995  
      *         backend.
 996  
      * @throws UnknownEntityException if the group does not exist.
 997  
      */
 998  
     public static void saveGroup(Group group)
 999  
             throws DataBackendException, UnknownEntityException
 1000  
     {
 1001  0
         getService().saveGroup(group);
 1002  0
     }
 1003  
 
 1004  
     /**
 1005  
      * Stores Role's attributes. The Roles is required to exist in the system.
 1006  
      *
 1007  
      * @param role The Role to be stored.
 1008  
      * @throws DataBackendException if there was an error accessing the data
 1009  
      *         backend.
 1010  
      * @throws UnknownEntityException if the role does not exist.
 1011  
      */
 1012  
     public static void saveRole(Role role)
 1013  
             throws DataBackendException, UnknownEntityException
 1014  
     {
 1015  0
         getService().saveRole(role);
 1016  0
     }
 1017  
 
 1018  
     /**
 1019  
      * Stores Permission's attributes. The Permissions is required to exist in
 1020  
      * the system.
 1021  
      *
 1022  
      * @param permission The Permission to be stored.
 1023  
      * @throws DataBackendException if there was an error accessing the data
 1024  
      *         backend.
 1025  
      * @throws UnknownEntityException if the permission does not exist.
 1026  
      */
 1027  
     public static void savePermission(Permission permission)
 1028  
             throws DataBackendException, UnknownEntityException
 1029  
     {
 1030  0
         getService().savePermission(permission);
 1031  0
     }
 1032  
 
 1033  
     /**
 1034  
      * Creates a new group with specified attributes.
 1035  
      *
 1036  
      * @param group the object describing the group to be created.
 1037  
      * @throws DataBackendException if there was an error accessing the data
 1038  
      *         backend.
 1039  
      * @throws EntityExistsException if the group already exists.
 1040  
      */
 1041  
     public static void addGroup(Group group)
 1042  
             throws DataBackendException, EntityExistsException
 1043  
     {
 1044  0
         getService().addGroup(group);
 1045  0
     }
 1046  
 
 1047  
     /**
 1048  
      * Creates a new role with specified attributes.
 1049  
      *
 1050  
      * @param role the objects describing the role to be created.
 1051  
      * @throws DataBackendException if there was an error accessing the data
 1052  
      *         backend.
 1053  
      * @throws EntityExistsException if the role already exists.
 1054  
      */
 1055  
     public static void addRole(Role role)
 1056  
             throws DataBackendException, EntityExistsException
 1057  
     {
 1058  0
         getService().addRole(role);
 1059  0
     }
 1060  
 
 1061  
     /**
 1062  
      * Creates a new permission with specified attributes.
 1063  
      *
 1064  
      * @param permission the objects describing the permission to be created.
 1065  
      * @throws DataBackendException if there was an error accessing the data
 1066  
      *         backend.
 1067  
      * @throws EntityExistsException if the permission already exists.
 1068  
      */
 1069  
     public static void addPermission(Permission permission)
 1070  
             throws DataBackendException, EntityExistsException
 1071  
     {
 1072  0
         getService().addPermission(permission);
 1073  0
     }
 1074  
 
 1075  
     /**
 1076  
      * Removes a Group from the system.
 1077  
      *
 1078  
      * @param group the object describing group to be removed.
 1079  
      * @throws DataBackendException if there was an error accessing the data
 1080  
      *         backend.
 1081  
      * @throws UnknownEntityException if the group does not exist.
 1082  
      */
 1083  
     public static void removeGroup(Group group)
 1084  
             throws DataBackendException, UnknownEntityException
 1085  
     {
 1086  0
         getService().removeGroup(group);
 1087  0
     }
 1088  
 
 1089  
     /**
 1090  
      * Removes a Role from the system.
 1091  
      *
 1092  
      * @param role The object describing the role to be removed.
 1093  
      * @throws DataBackendException if there was an error accessing the data backend.
 1094  
      * @throws UnknownEntityException if the role does not exist.
 1095  
      */
 1096  
     public static void removeRole(Role role)
 1097  
             throws DataBackendException, UnknownEntityException
 1098  
     {
 1099  0
         getService().removeRole(role);
 1100  0
     }
 1101  
 
 1102  
     /**
 1103  
      * Removes a Permission from the system.
 1104  
      *
 1105  
      * @param permission The object describing the permission to be removed.
 1106  
      * @throws DataBackendException if there was an error accessing the data
 1107  
      *         backend.
 1108  
      * @throws UnknownEntityException if the permission does not exist.
 1109  
      */
 1110  
     public static void removePermission(Permission permission)
 1111  
             throws DataBackendException, UnknownEntityException
 1112  
     {
 1113  0
         getService().removePermission(permission);
 1114  0
     }
 1115  
 
 1116  
     /**
 1117  
      * Renames an existing Group.
 1118  
      *
 1119  
      * @param group The object describing the group to be renamed.
 1120  
      * @param name the new name for the group.
 1121  
      * @throws DataBackendException if there was an error accessing the data
 1122  
      *         backend.
 1123  
      * @throws UnknownEntityException if the group does not exist.
 1124  
      */
 1125  
     public static void renameGroup(Group group, String name)
 1126  
             throws DataBackendException, UnknownEntityException
 1127  
     {
 1128  0
         getService().renameGroup(group, name);
 1129  0
     }
 1130  
 
 1131  
     /**
 1132  
      * Renames an existing Role.
 1133  
      *
 1134  
      * @param role The object describing the role to be renamed.
 1135  
      * @param name the new name for the role.
 1136  
      * @throws DataBackendException if there was an error accessing the data
 1137  
      *         backend.
 1138  
      * @throws UnknownEntityException if the role does not exist.
 1139  
      */
 1140  
     public static void renameRole(Role role, String name)
 1141  
             throws DataBackendException, UnknownEntityException
 1142  
     {
 1143  0
         getService().renameRole(role, name);
 1144  0
     }
 1145  
 
 1146  
     /**
 1147  
      * Renames an existing Permission.
 1148  
      *
 1149  
      * @param permission The object describing the permission to be renamed.
 1150  
      * @param name the new name for the permission.
 1151  
      * @throws DataBackendException if there was an error accessing the data
 1152  
      *         backend.
 1153  
      * @throws UnknownEntityException if the permission does not exist.
 1154  
      */
 1155  
     public static void renamePermission(Permission permission, String name)
 1156  
             throws DataBackendException, UnknownEntityException
 1157  
     {
 1158  0
         getService().renamePermission(permission, name);
 1159  0
     }
 1160  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.