spring:
 # The configuration of a datasource is not user service specific; it should only be pointed out that
 # that the user service requires a datasource.
 datasource:
    url: jdbc:postgresql://localhost:5432/postgres?currentSchema=foo
    username: foouser
    password: foopassword
    driver-class-name: org.postgresql.Driver

user-service:

  group:
    # a user group is to be typified; possible types can be
    # deposited comma-separated at this point
    #
    # If the type "Standard" is specified, no type must be specified when saving a user group record.
    # In such a case the type "Standard" will be set automatically.
    #
    types: Standard, OU, Job
    #
    # A user group can have freely definable attributes assigned to it; such
    # definitions can be made here in a semicolon-separated way.
    # The values of a definition are comma-separated.
    # The first value specifies the attribute name, the second the type and
    # the third, whether the attribute value is a mandatory value.
    # Possible types are: boolean, decimal, long, datetime, string, blob;
    #
    extra-fields: selectable,boolean,false;fooDate,datetime,false;

  user:
    # Specify the superuser based on a comma-separated list of user names; if the value -dbFlag- is entered here,
    # then the superuser will be determined by a flag in the
    # user database table
    #
    superuser: -dbFlag-
    #
    # A user can be assigned freely definable attributes.
    # further description see above under user-service.group.extra-fields
    extra-fields: fooDecimal,decimal,false;fooString1,string,false;fooString2,string,false

  auth:
    # The user service supports the integration of Spring security. With the following
    # configuration you can specify the implementation of the Spring Spring-Security-Userdetail-Interfaces.
    # (Default is de.eitco.commons.user.management.common.auth.UserDetailsDB)
    #
    user-details-path: de.eitco.commons.user.management.common.auth.UserDetailsDB
    #
    # The following configuration specifies which key is used to identify the user
    # to whom the request is assigned via request token is to be
    # determined by the user service. The request token can contain the user name or the external
    # user ID. Possible configuration values are NAME or EXTERNAL_ID (default is NAME).
    #
    user-identification-field: NAME

@Autowired
UserManager userMgr;
User user = new User();
user.setUsername("user@foo.foo");
user = userMgr.saveEntity(user);

@Autowired
UserManager userMgr;
// Read user record by means of e.g. getEntityByUsername()
User user = userMgr.getEntityByUsername("user@foo.foo");
// change email address
user.setEmail("user@foo.foo");
user = userMgr.saveEntity(user);

@Autowired
UserManager userMgr;
// Delete existing user by system ID
userMgr.deleteEntity(user.getId());

@Autowired
UserToUserGroupManager userToGroupMgr;
// such assignment is done by user id and group id
userToGroupMgr.addUserToGroup(userId, groupId);

@Autowired
UserToUserGroupManager userToGroupMgr;
// remove user from group is done using user id and group id
userToGroupMgr.removeUserFromGroup(userId, groupId);

@Autowired
UserToUserGroupManager userToGroupMgr;
// Note: method accesses the database directly; so no cache usage.
List<User> userToGroupMgr.listUsersOfGroup(Long groupId);

@Autowired
UserToUserGroupManager userToGroupMgr;
// Note: method accesses the database directly; so no cache usage
List<UserGroup> userToGroupMgr.listGroupsOfUser(Long userId);

@Autowired
UserGroupToGroupManager userGroupToGroupMgr;
// add a subgroup to a group
groupToGroupMgr.addSubGroup(groupId, subGroupId);

@Autowired
UserGroupToGroupManager userGroupToGroupMgr;
// remove a subgroup from a group
groupToGroupMgr.removeSubGroup(groupId, subGroupId);

@Autowired
UserGroupToGroupManager userGroupToGroupMgr;
// list the direct subgroups of a group
List<UserGroup> directSubGroupList = groupToGroupMgr.getDirectSubGroups(Long groupId);

// list the direct subgroups of a group
List<UserGroup> directSuperGroupList = groupToGroupMgr.getDirectSuperGroups(Long groupId);

@Autowired
UserManager userMgr;
// Create ServiceQuery instance
ServiceQuery serviceQuery = userMgr.newQuery();

// RETRIEVE ALL USERS WITH ALL DIRECT AND FREELY DEFINABLE ATTRIBUTES

// call the listEntities method based on the created ServiceQuery instance;
// in the simple case, i.e. without specifying any select, filter or sort attributes
// all users with all direct and freely definable attributes are returned; in
// such a case, null could also be passed instead of the ServiceQuery instance
QueryResult<User> userResult = userMgr.listEntities(serviceQuery);

// The QueryResult instance contains the result list.
List<User> userList = userResult.getList();

// SELECT SPECIFIC ATTRIBUTES
serviceQuery .addSelect("u.username", "ue.foo", "r.name");

// FILTER BY SPECIFIC ATTRIBUTES
serviceQuery.addFilterEq("u.username", "mustermann"); // exact match filter
serviceQuery.addFilterEq("u.username", "mus", ServiceQuery.TXT_MATCH_STYLE_STARTS_WITH) // starts with match filter
serviceQuery.addFilterEq("u.username", "uster", ServiceQuery.TXT_MATCH_STYLE_SUBSTRING) // substring match filter
serviceQuery.addFilterEq("ue.fooDate", myDate); // equals filter
serviceQuery.addFilterEq("ue.fooLong", 1L); // equals filter
serviceQuery.addToOrFilterEq("u.firstname", "Erika");
serviceQuery.addToOrFilterEq("u.firstname", "Max") // exact match Erika or Max
serviceQuery.addFilterIn("ue.fooLong", myLongCollection); // in condition
etc.

// SORT BY SPECIFIC ATTRIBUTES
serviceQuery.addOrderBy("u.username", ServiceQuery.SORT_DESC); // sort in descending order
etc.

// START-ROW, END-ROW and COUNT
serviceQuery.setStartRow(0); // "start row" included
serviceQuery.setEndRow(10); // "end row" not included (compare Java substring method)
serviceQuery.withCount(); // in addition to the partial hit list "start/end" the actual total hit count
                             // of the formulated query, which is then supplied in the result when calling withCount

@Async
@EventListener
public void handleEvent(BeforeGroupCreateEvent event) {
// do something
}

//---------------------------------------------------------------------
// Subsequent queries whether a user is superuser, is in role x, etc.
//---------------------------------------------------------------------
AuthLookup.isSuperuser();
AuthLookup.isSuperuser(String username);

AuthLookup.isInRole(String roleName);
AuthLookup.isInRole(String username, String roleName);

AuthLookup.isInGroup(String groupShortname);
AuthLookup.isInGroup(String username, String groupShortname);

AuthLookup.isPrivilegeGranted(String tokenName);
AuthLookup.isPrivilegeGranted(String username, String tokenName);

AuthLookup.areAllPrivilegesGranted(String... tokenNameList);
AuthLookup.areAllPrivilegesGranted(String username, String... tokenNameList);

AuthLookup.isOnePrivilegesGranted(String...tokenNameList),
AuthLookup.isOnePrivilegeGranted(String username, String...tokenNameList),

AuthLookup.isPrivilegeGrantedGroup(String tokenName, String groupShortname);
AuthLookup.isPrivilegeGrantedGroup(String username, String tokenName, String groupShortname);

 ....

//-----------------------------------------------------------------------------------------------
// Following lookup queries for a user's group, role, etc. listings.
//
// The following lookup methods are not intended for user management. For this purpose the
// managers should be used for that. The lookup methods are intended to support the formulation of corresponding queries
// such as e.g., the formulation of ACL queries, to support e.g., joins
// related to e.g. group hierarchies.
//
// If the user is a superuser, then the following methods return null; otherwise
// always return a collection, i.e., also an empty collection.
//-----------------------------------------------------------------------------------------------

Collection<String> roleNameList = AuthLookup.listRoles();
Collection<String> roleNameList = AuthLookup.listRoles(String username);

Collection<String> groupShortnameList = AuthLookup.listGroups();
Collection<String> groupShortnameList = AuthLookup.listGroups(String username);

Collection<String> tokeNameList = AuthLookup.listPrivilegesGranted();
Collection<String> tokeNameList = AuthLookup.listPrivilegesGranted(String username);

Collection<String> tokeNameList = AuthLookup.listPrivilegesGrantedGroup(String groupShortname);
Collection<String> tokeNameList = AuthLookup.listPrivilegesGrantedGroup(String username, String groupShortname);

// the current user can be retrieved via UserContext
User user = UserContext.getCurrentUser();

public static User getCurrentUser() {
    SecurityContext secCtx = SecurityContextHolder.getContext();
    if (secCtx == null) {
        // using the user context of the user service a user can also be set independently of the
        // security context; e.g. to set backend job executions // within a user context.
        // within a user context; this context is returned with getUser()
        return getUser();
    }

    Authentication auth = secCtx.getAuthentication();
    if (auth == null) {
        return getUser();
    }

    if (auth instanceof CommonAuthentication) {
        UUID userIdentifier = ((CommonAuthentication) auth).getUserIdentifier();
        UserManager userManager = BeanLookup.getBean(UserManager.class);
        return userManager.getEntityByUuid(userIdentifier.toString());
    }

    Object principal = auth.getPrincipal();
    if (principal instanceof UserDetails) {
        // Note: The user service provides a user-details implementation that can be used
        // can be used to create an authentication instance.
        return ((UserDetails) principal).getUser();
    }
    return UserContext.getUser();
}

# Spring configuration: reference to the actual infinispan configuration file.
# This reference can be a direct reference to the file system or an indirect one
# via classpath.
# See also: 'https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-caching-provider-infinispan'

infinispan:
   embedded:
     configXml: infinispan.xml

<?xml version="1.0" encoding="UTF-8"?>
<infinispan
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:infinispan:config:9.4 http://www.infinispan.org/schemas/infinispan-config-9.4.xsd"
xmlns="urn:infinispan:config:9.4">

    <!--
         Notes for the following expiration configuration:
         lifespan, interval and max-idle in millis
         lifespan: the time that an entity is kept in the cache before it is evicted
         max-idle: the idle time of an entity before it is evicted; -1 means ignoring max-idle
         interval: the check period for eviction
     -->

     <cache-container>

         <!-- - - - - - - - - - - - - - - - - - - - -->
         <!-- simple cache for single node systems  -->
         <!-- - - - - - - - - - - - - - - - - - - - -->
         <local-cache-configuration name="user-cache-local" simple-cache="true">
            <expiration lifespan="43200000" interval="300000" max-idle="-1"/>
         </local-cache-configuration>


         <!-- - - - - - - - - - - - - - - - - - - - - -->
         <!-- invalidation cache for cluster systems  -->
         <!-- - - - - - - - - - - - - - - - - - - - - -->
         <!--        <transport cluster="cmn-cache-cluster"/>                                   -->
         <!--        <invalidation-cache-configuration name="user-cache-cluster" mode="ASYNC">  -->
         <!--            <expiration lifespan="43200000" interval="300000" max-idle="-1"/>      -->
         <!--        </invalidation-cache-configuration>-->

     </cache-container>
</infinispan>

spring:
   cache:
      type: CUSTOM

spring:
   cache:
      type: INFINISPAN

    @Bean
    @Conditional(CustomCacheManagerChecker.class)
    public CustomCacheManager customCacheManager() {
        return new MyCacheManager();
    }

public interface CustomCacheManager {
    Cache getCache(String cacheName);
    Cache getCache(String cacheName, @Nullable Map<String, Object> cacheConfiguration);
}

<dependency>
     <groupId>de.eitco.commons</groupId>
     <artifactId>cmn-user-management-test-with-user</artifactId>
     <version>entsprechende Version</version>
     <scope>test</scope>
 </dependency>

user-service:
   config-data:
     tenants:
      # see explanation of tenant-id for token import
      - tenant-id: all

      groups:
          # z.B. GUID from Active Directory
        - externalId: C7FE1854-9428-44B6-9A77-3FADE10C1BCF
          # z.B. DN from Active Directory
          externalPath: groups.employee
          type: Standard
          shortname: fooGroup1
          longname: fooGroup1Longname
          division: fooGroup1Division
          area: fooGroup1Area
          enabled: true
          escription: This is...
          # the role fooRole1 is assigned to the group
          memberOfRoles: fooRole1

        - externalId: D7FE1854-9428-44B6-9A77-3FADE10C1BCF
          externalPath: groups.developer
          type: Standard
          shortname: fooGroup2
          longname: fooGroup2Longname
          division: fooGroup2Division
          area: fooGroup2Area
          enabled: true
          description: This is...

          # the group is assigned to the roles fooRole1 and fooRole2
          memberOfRoles: fooRole1,fooRole2

          # the group is classified as a subgroup of the group fooGroup1
          subGroupOfGroups: fooGroup1