Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (C) 2014 Philip Helger (www.helger.com) philip[at]helger[dot]com Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 
 package com.helger.appbasics.security.usergroup;
 
 import java.util.List;
 import java.util.Map;
 
 
 
This class manages the available user groups.

Author(s):
Philip Helger
 
 public class UserGroupManager extends AbstractSimpleDAO implements IUserGroupManagerIReloadableDAO
 {
   public static final boolean DEFAULT_CREATE_DEFAULTS = true;
 
   private static final Logger s_aLogger = LoggerFactory.getLogger (UserGroupManager.class);
   private static final ReadWriteLock s_aRWLock = new ReentrantReadWriteLock ();
 
   @GuardedBy ("s_aRWLock")
   private static boolean s_bCreateDefaults = ;
 
   private final IUserManager m_aUserMgr;
   private final IRoleManager m_aRoleMgr;
   @GuardedBy ("m_aRWLock")
   private final Map <StringUserGroupm_aUserGroups = new HashMap <StringUserGroup> ();
 
 
   public static boolean isCreateDefaults ()
   {
     .readLock ().lock ();
     try
     {
       return ;
     }
     finally
     {
       .readLock ().unlock ();
     }
   }
 
   public static void setCreateDefaults (final boolean bCreateDefaults)
   {
     .writeLock ().lock ();
     try
     {
        = bCreateDefaults;
     }
     finally
     {
      .writeLock ().unlock ();
    }
  }
  public UserGroupManager (@Nonnull @Nonempty final String sFilename,
                           @Nonnull final IUserManager aUserMgr,
                           @Nonnull final IRoleManager aRoleMgrthrows DAOException
  {
    super (sFilename);
     = ValueEnforcer.notNull (aUserMgr"UserManager");
     = ValueEnforcer.notNull (aRoleMgr"RoleManager");
    initialRead ();
  }
  public final IUserManager getUserManager ()
  {
    return ;
  }
  public final IRoleManager getRoleManager ()
  {
    return ;
  }
  public void reload () throws DAOException
  {
    .writeLock ().lock ();
    try
    {
      .clear ();
      initialRead ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
  }
  protected EChange onInit ()
  {
    if (!isCreateDefaults ())
      return .;
    // Administrators user group
                                                  .));
    // Users user group
    // Guests user group
    // no role for this user group
    return .;
  }
  protected EChange onRead (@Nonnull final IMicroDocument aDoc)
  {
    for (final IMicroElement eUserGroup : aDoc.getDocumentElement ().getAllChildElements ())
      _addUserGroup (MicroTypeConverter.convertToNative (eUserGroupUserGroup.class));
    return .;
  }
  {
    final IMicroDocument aDoc = new MicroDocument ();
    final IMicroElement eRoot = aDoc.appendElement ("usergroups");
    for (final UserGroup aUserGroup : ContainerHelper.getSortedByKey ().values ())
      eRoot.appendChild (MicroTypeConverter.convertToMicroElement (aUserGroup"usergroup"));
    return aDoc;
  }
  @ReturnsMutableObject (reason = "design")
  {
    return ;
  }
  private UserGroup _addUserGroup (@Nonnull final UserGroup aUserGroup)
  {
    final String sUserGroupID = aUserGroup.getID ();
    if (.containsKey (sUserGroupID))
      throw new IllegalArgumentException ("User group ID " + sUserGroupID + " is already in use!");
    .put (sUserGroupIDaUserGroup);
    return aUserGroup;
  }
  public IUserGroup createNewUserGroup (@Nonnull @Nonempty final String sName)
  {
    return createNewUserGroup (sName, (Map <StringString>) null);
  }
  public IUserGroup createNewUserGroup (@Nonnull @Nonempty final String sName,
                                        @Nullable final Map <String, ?> aCustomAttrs)
  {
    // Create user group
    final UserGroup aUserGroup = new UserGroup (sNameaCustomAttrs);
    .writeLock ().lock ();
    try
    {
      // Store
      _addUserGroup (aUserGroup);
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditCreateSuccess (.aUserGroup.getID (), sName);
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupCreated (aUserGroupfalse);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupCreated callback on " + aUserGroup.toString (), t);
      }
    return aUserGroup;
  }
                                               @Nonnull @Nonempty final String sName)
  {
    // Create user group
    final UserGroup aUserGroup = new UserGroup (sIDsName);
    .writeLock ().lock ();
    try
    {
      // Store
      _addUserGroup (aUserGroup);
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditCreateSuccess (.aUserGroup.getID (), "predefined-usergroup"sName);
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupCreated (aUserGrouptrue);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupCreated callback on " + aUserGroup.toString (), t);
      }
    return aUserGroup;
  }
  public boolean containsUserGroupWithID (@Nullable final String sUserGroupID)
  {
    if (StringHelper.hasNoText (sUserGroupID))
      return false;
    .readLock ().lock ();
    try
    {
      return .containsKey (sUserGroupID);
    }
    finally
    {
      .readLock ().unlock ();
    }
  }
  public boolean containsAllUserGroupsWithID (@Nullable final Collection <StringaUserGroupIDs)
  {
    if (ContainerHelper.isEmpty (aUserGroupIDs))
      return true;
    .readLock ().lock ();
    try
    {
      for (final String sUserGroupID : aUserGroupIDs)
        if (!.containsKey (sUserGroupID))
          return false;
      return true;
    }
    finally
    {
      .readLock ().unlock ();
    }
  }
  public UserGroup getUserGroupOfID (@Nullable final String sUserGroupID)
  {
    if (StringHelper.hasNoText (sUserGroupID))
      return null;
    .readLock ().lock ();
    try
    {
      return .get (sUserGroupID);
    }
    finally
    {
      .readLock ().unlock ();
    }
  }
  public List <? extends IUserGroupgetAllUserGroups ()
  {
    .readLock ().lock ();
    try
    {
      return ContainerHelper.newList (.values ());
    }
    finally
    {
      .readLock ().unlock ();
    }
  }
  public EChange deleteUserGroup (@Nullable final String sUserGroupID)
  {
    if (StringHelper.hasNoText (sUserGroupID))
      return .;
    IUserGroup aDeletedUserGroup;
    .writeLock ().lock ();
    try
    {
      aDeletedUserGroup = .remove (sUserGroupID);
      if (aDeletedUserGroup == null)
      {
        AuditUtils.onAuditDeleteFailure (."no-such-usergroup-id"sUserGroupID);
        return .;
      }
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditDeleteSuccess (.sUserGroupID);
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupDeleted (aDeletedUserGroup);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupDeleted callback on " + aDeletedUserGroup.toString (), t);
      }
    return .;
  }
  public EChange renameUserGroup (@Nullable final String sUserGroupID, @Nonnull @Nonempty final String sNewName)
  {
    // Resolve user group
    final UserGroup aUserGroup = getUserGroupOfID (sUserGroupID);
    if (aUserGroup == null)
    {
      AuditUtils.onAuditModifyFailure (.sUserGroupID"no-such-usergroup-id""name");
      return .;
    }
    .writeLock ().lock ();
    try
    {
      if (aUserGroup.setName (sNewName).isUnchanged ())
        return .;
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditModifySuccess (."name"sUserGroupIDsNewName);
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupRenamed (aUserGroup);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupRenamed callback on " + aUserGroup.toString (), t);
      }
    return .;
  }
  public EChange setUserGroupData (@Nullable final String sUserGroupID,
                                   @Nonnull @Nonempty final String sNewName,
                                   @Nullable final Map <String, ?> aNewCustomAttrs)
  {
    // Resolve user group
    final UserGroup aUserGroup = getUserGroupOfID (sUserGroupID);
    if (aUserGroup == null)
    {
      AuditUtils.onAuditModifyFailure (.sUserGroupID"no-such-usergroup-id");
      return .;
    }
    .writeLock ().lock ();
    try
    {
      EChange eChange = aUserGroup.setName (sNewName);
      eChange = eChange.or (aUserGroup.setAttributes (aNewCustomAttrs));
      if (eChange.isUnchanged ())
        return .;
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
                                     "all",
                                     aUserGroup.getID (),
                                     sNewName,
                                     StringHelper.getToString (aNewCustomAttrs));
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupUpdated (aUserGroup);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupUpdated callback on " + aUserGroup.toString (), t);
      }
    return .;
  }
  public EChange assignUserToUserGroup (@Nullable final String sUserGroupID, @Nonnull @Nonempty final String sUserID)
  {
    // Resolve user group
    final UserGroup aUserGroup = getUserGroupOfID (sUserGroupID);
    if (aUserGroup == null)
    {
      AuditUtils.onAuditModifyFailure (.sUserGroupID"no-such-usergroup-id""assign-user");
      return .;
    }
    .writeLock ().lock ();
    try
    {
      if (aUserGroup.assignUser (sUserID).isUnchanged ())
        return .;
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditModifySuccess (."assign-user"sUserGroupIDsUserID);
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupUserAssignment (aUserGroupsUserIDtrue);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupUserAssignment callback on " + aUserGroup.toString (), t);
      }
    return .;
  }
  public EChange unassignUserFromUserGroup (@Nullable final String sUserGroupID, @Nullable final String sUserID)
  {
    // Resolve user group
    final UserGroup aUserGroup = getUserGroupOfID (sUserGroupID);
    if (aUserGroup == null)
    {
      AuditUtils.onAuditModifyFailure (.sUserGroupID"no-such-usergroup-id""unassign-user");
      return .;
    }
    .writeLock ().lock ();
    try
    {
      if (aUserGroup.unassignUser (sUserID).isUnchanged ())
        return .;
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditModifySuccess (."unassign-user"sUserGroupIDsUserID);
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupUserAssignment (aUserGroupsUserIDfalse);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupUserAssignment callback on " + aUserGroup.toString (), t);
      }
    return .;
  }
  public EChange unassignUserFromAllUserGroups (@Nullable final String sUserID)
  {
    if (StringHelper.hasNoText (sUserID))
      return .;
    final List <IUserGroupaAffectedUserGroups = new ArrayList <IUserGroup> ();
    .writeLock ().lock ();
    try
    {
      EChange eChange = .;
      for (final UserGroup aUserGroup : .values ())
        if (aUserGroup.unassignUser (sUserID).isChanged ())
        {
          aAffectedUserGroups.add (aUserGroup);
          eChange = .;
        }
      if (eChange.isUnchanged ())
        return .;
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditModifySuccess (."unassign-user-from-all-usergroups"sUserID);
    // Execute callback as the very last action
    for (final IUserGroup aUserGroup : aAffectedUserGroups)
      for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
        try
        {
          aUserGroupCallback.onUserGroupUserAssignment (aUserGroupsUserIDfalse);
        }
        catch (final Throwable t)
        {
          .error ("Failed to invoke onUserGroupUserAssignment callback on " + aUserGroup.toString (), t);
        }
    return .;
  }
  public boolean isUserAssignedToUserGroup (@Nullable final String sUserGroupID, @Nullable final String sUserID)
  {
    if (StringHelper.hasNoText (sUserID))
      return false;
    final IUserGroup aUserGroup = getUserGroupOfID (sUserGroupID);
    return aUserGroup == null ? false : aUserGroup.containsUserID (sUserID);
  }
  {
    .readLock ().lock ();
    try
    {
      final List <IUserGroupret = new ArrayList <IUserGroup> ();
      if (StringHelper.hasText (sUserID))
        for (final IUserGroup aUserGroup : .values ())
          if (aUserGroup.containsUserID (sUserID))
            ret.add (aUserGroup);
      return ret;
    }
    finally
    {
      .readLock ().unlock ();
    }
  }
  public List <StringgetAllUserGroupIDsWithAssignedUser (@Nullable final String sUserID)
  {
    .readLock ().lock ();
    try
    {
      final List <Stringret = new ArrayList <String> ();
      if (StringHelper.hasText (sUserID))
        for (final IUserGroup aUserGroup : .values ())
          if (aUserGroup.containsUserID (sUserID))
            ret.add (aUserGroup.getID ());
      return ret;
    }
    finally
    {
      .readLock ().unlock ();
    }
  }
  public EChange assignRoleToUserGroup (@Nullable final String sUserGroupID, @Nonnull @Nonempty final String sRoleID)
  {
    // Resolve user group
    final UserGroup aUserGroup = getUserGroupOfID (sUserGroupID);
    if (aUserGroup == null)
    {
      AuditUtils.onAuditModifyFailure (.sUserGroupID"no-such-usergroup-id""assign-role");
      return .;
    }
    .writeLock ().lock ();
    try
    {
      if (aUserGroup.assignRole (sRoleID).isUnchanged ())
        return .;
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditModifySuccess (."assign-role"sUserGroupIDsRoleID);
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupRoleAssignment (aUserGroupsRoleIDtrue);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupRoleAssignment callback on " + aUserGroup.toString (), t);
      }
    return .;
  }
  public EChange unassignRoleFromUserGroup (@Nullable final String sUserGroupID, @Nullable final String sRoleID)
  {
    // Resolve user group
    final UserGroup aUserGroup = getUserGroupOfID (sUserGroupID);
    if (aUserGroup == null)
    {
      AuditUtils.onAuditModifyFailure (.sUserGroupID"no-such-usergroup-id""unassign-role");
      return .;
    }
    .writeLock ().lock ();
    try
    {
      if (aUserGroup.unassignRole (sRoleID).isUnchanged ())
        return .;
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditModifySuccess (."unassign-role"sUserGroupIDsRoleID);
    // Execute callback as the very last action
    for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
      try
      {
        aUserGroupCallback.onUserGroupRoleAssignment (aUserGroupsRoleIDfalse);
      }
      catch (final Throwable t)
      {
        .error ("Failed to invoke onUserGroupRoleAssignment callback on " + aUserGroup.toString (), t);
      }
    return .;
  }
  public EChange unassignRoleFromAllUserGroups (@Nullable final String sRoleID)
  {
    if (StringHelper.hasNoText (sRoleID))
      return .;
    final List <IUserGroupaAffectedUserGroups = new ArrayList <IUserGroup> ();
    .writeLock ().lock ();
    try
    {
      EChange eChange = .;
      for (final UserGroup aUserGroup : .values ())
        if (aUserGroup.unassignRole (sRoleID).isChanged ())
        {
          aAffectedUserGroups.add (aUserGroup);
          eChange = .;
        }
      if (eChange.isUnchanged ())
        return .;
      markAsChanged ();
    }
    finally
    {
      .writeLock ().unlock ();
    }
    AuditUtils.onAuditModifySuccess (."unassign-role-from-all-usergroups"sRoleID);
    // Execute callback as the very last action
    for (final IUserGroup aUserGroup : aAffectedUserGroups)
      for (final IUserGroupModificationCallback aUserGroupCallback : .getAllCallbacks ())
        try
        {
          aUserGroupCallback.onUserGroupRoleAssignment (aUserGroupsRoleIDfalse);
        }
        catch (final Throwable t)
        {
          .error ("Failed to invoke onUserGroupRoleAssignment callback on " + aUserGroup.toString (), t);
        }
    return .;
  }
  {
    .readLock ().lock ();
    try
    {
      final List <IUserGroupret = new ArrayList <IUserGroup> ();
      if (StringHelper.hasText (sRoleID))
        for (final IUserGroup aUserGroup : .values ())
          if (aUserGroup.containsRoleID (sRoleID))
            ret.add (aUserGroup);
      return ret;
    }
    finally
    {
      .readLock ().unlock ();
    }
  }
  public List <StringgetAllUserGroupIDsWithAssignedRole (@Nullable final String sRoleID)
  {
    .readLock ().lock ();
    try
    {
      final List <Stringret = new ArrayList <String> ();
      if (StringHelper.hasText (sRoleID))
        for (final IUserGroup aUserGroup : .values ())
          if (aUserGroup.containsRoleID (sRoleID))
            ret.add (aUserGroup.getID ());
      return ret;
    }
    finally
    {
      .readLock ().unlock ();
    }
  }
New to GrepCode? Check out our FAQ X