import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
public void setUserPassword(String realmId, String username, String newPassword) {
    List<UserRepresentation> retrieveUserList = client.realm(realmId).users().search(username,
            null,
            null,
            null,
            0, 1);
    if (!retrieveUserList.isEmpty()) {
        UserResource retrievedUser = client.realm(realmId).users().get(retrieveUserList.get(0).getId());
        CredentialRepresentation credential = new CredentialRepresentation();
        credential.setType(CredentialRepresentation.PASSWORD);
        credential.setValue(newPassword);
        credential.setTemporary(false);
        retrievedUser.resetPassword(credential);
        // Remove the UPDATE_PASSWORD required action
        UserRepresentation userRepresentation = retrievedUser.toRepresentation();
        userRepresentation.getRequiredActions().remove("UPDATE_PASSWORD");
        retrievedUser.update(userRepresentation);
    } else {
        throw new RuntimeException("Requested user not found");
    }
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public String createUser(String username, String password, String firstname, String lastname, String email, List<String> rolenames) {
	if (username.equals("user")) {
		throw new UnsupportedOperationException("Dont't do that! (Sso rest api doesn't create user with username 'user' properly)");
	}

	CredentialRepresentation cr = new CredentialRepresentation();
	cr.setType(CredentialRepresentation.PASSWORD);
	cr.setValue(password);
	cr.setTemporary(false);

	UserRepresentation ur = new UserRepresentation();
	ur.setUsername(username);
	ur.setCredentials(Arrays.asList(cr));
	ur.setFirstName(firstname);
	ur.setLastName(lastname);
	ur.setEmail(email);
	ur.setEnabled(true);

	Response response = client.realm(realmName).users().create(ur);
	response.close();

	String userId = getUserId(username);
	client.realm(realmName).users().get(userId).resetPassword(cr);

	if (rolenames != null && rolenames.size() > 0) {
		addRealmRolesToUser(userId, rolenames);
	}

	return userId;
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public String getEmailVerifiedUpdatedFlag(String userId) {
  UserResource resource =
      keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(userId);
  UserRepresentation user = resource.toRepresentation();
  Map<String, List<String>> map = user.getAttributes();
  List<String> list = map.get(JsonKey.EMAIL_VERIFIED_UPDATED);
  if (!list.isEmpty()) {
    return list.get(0);
  } else {
    return "";
  }
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public String getLastLoginTime(String userId) {
  String lastLoginTime = null;
  try {
    UserResource resource =
        keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(userId);
    UserRepresentation ur = resource.toRepresentation();
    Map<String, List<String>> map = ur.getAttributes();
    if (map == null) {
      map = new HashMap<>();
    }
    List<String> list = map.get(JsonKey.LAST_LOGIN_TIME);
    if (list != null && !list.isEmpty()) {
      lastLoginTime = list.get(0);
    }
  } catch (Exception e) {
    ProjectLogger.log(e.getMessage(), e);
  }
  return lastLoginTime;
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public String setEmailVerifiedTrue(String userId) {
  try {
    UserResource resource =
        keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(userId);
    UserRepresentation ur = resource.toRepresentation();
    ur.setEmailVerified(true);
    if (isNotNull(resource)) {
      try {
        resource.update(ur);
      } catch (Exception ex) {
        ProjectLogger.log(ex.getMessage(), ex);
        throw new ProjectCommonException(ResponseCode.invalidUsrData.getErrorCode(),
            ResponseCode.invalidUsrData.getErrorMessage(),
            ResponseCode.CLIENT_ERROR.getResponseCode());
      }

    }
  } catch (Exception e) {
    ProjectLogger.log(e.getMessage(), e);
    throw new ProjectCommonException(ResponseCode.invalidUsrData.getErrorCode(),
        ResponseCode.invalidUsrData.getErrorMessage(),
        ResponseCode.CLIENT_ERROR.getResponseCode());
  }
  return JsonKey.SUCCESS;
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public String setEmailVerifiedAsFalse(String userId) {
  try {
    UserResource resource =
        keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(userId);
    UserRepresentation ur = resource.toRepresentation();
    ur.setEmailVerified(false);
    if (isNotNull(resource)) {
      try {
        resource.update(ur);
      } catch (Exception ex) {
        ProjectLogger.log(ex.getMessage(), ex);
        throw new ProjectCommonException(ResponseCode.invalidUsrData.getErrorCode(),
            ResponseCode.invalidUsrData.getErrorMessage(),
            ResponseCode.CLIENT_ERROR.getResponseCode());
      }

    }
  } catch (Exception e) {
    ProjectLogger.log(e.getMessage(), e);
    throw new ProjectCommonException(ResponseCode.invalidUsrData.getErrorCode(),
        ResponseCode.invalidUsrData.getErrorMessage(),
        ResponseCode.CLIENT_ERROR.getResponseCode());
  }
  return JsonKey.SUCCESS;
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
/**
 * Check the existence of user with email.
 *
 * @param email         email of the user
 * @throws IOException
 */
public void checkUserExistence(String email) throws IOException, DuplicatedKeycloakEntry{
    // First try: Find the user by searching for the username field
    List<UserRepresentation> users = getProjectUserRealm().users().search(email, null, null, null, -1, -1);

    String errMsg = "";
    // If we found one, it already has the user
    if (users.size()>0){
        throw new DuplicatedKeycloakEntry("User with username: " +email + " already exists.", errMsg);
    }

    // Second try: Find the user by searching for the email field
    users = getProjectUserRealm().users().search(null, null, null, email, -1, -1);
    // If we found one, it already has the user
    if (users.size()>0){
        throw new DuplicatedKeycloakEntry("User with email: " +email + " already exists.", errMsg);
    }
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
/**
 * Delete a user from Keycloak
 * 
 * @param email  email of the user to delete
 */
public void deleteUser(String email) {
    // First try: Find the user by searching for the username
    List<UserRepresentation> users = getProjectUserRealm().users().search(email, null, null, null, -1, -1);
    // If we found one, delete it
    if (!users.isEmpty()) {
        getProjectUserRealm().users().get(users.get(0).getId()).remove();
        return ;
    }
    // Second try: Find the user by searching for the email
    users = getProjectUserRealm().users().search(null, null, null, email, -1, -1);
    // If we found one, delete it
    if (!users.isEmpty()) {
        getProjectUserRealm().users().get(users.get(0).getId()).remove();
        return ;
    }
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public void createRealm(String realmName, String realmAdminUser) {
    final RealmRepresentation newRealm = new RealmRepresentation();
    newRealm.setRealm(realmName);
    newRealm.setEnabled(true);
    newRealm.setPasswordPolicy("hashAlgorithm(scramsha1)");

    final UserRepresentation newUser = new UserRepresentation();
    newUser.setUsername(realmAdminUser);

    newUser.setEnabled(true);
    newUser.setClientRoles(Collections.singletonMap("realm-management", Collections.singletonList("manage-users")));

    newRealm.setUsers(Collections.singletonList(newUser));

    try (CloseableKeycloak wrapper = new CloseableKeycloak(params)) {
        wrapper.get().realms().create(newRealm);
    }
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public User update(User entity) throws SecurityManagementException {
    checkNotNull("entity",
                 entity);
    consumeRealm(realmResource -> {
        UsersResource usersResource = realmResource.users();
        UserResource userResource = getUserResource(usersResource,
                                                    entity.getIdentifier());
        if (userResource == null) {
            throw new UserNotFoundException(entity.getIdentifier());
        }
        UserRepresentation userRepresentation = new UserRepresentation();
        fillUserRepresentationAttributes(entity,
                                         userRepresentation);
        ClientResponse response = (ClientResponse) userResource.update(userRepresentation);
        handleResponse(response);
    });
    return entity;
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
private List<UserRepresentation> getUserRepresentations(String pattern,
                                                        int start,
                                                        int size) {
    List<UserRepresentation> result = null;
    if (isEmpty(pattern)) {
        result = userRepresentations.subList(start,
                                             start + size);
    } else {
        UserResource userResource = getUser(userResources,
                                            pattern);
        if (userResource != null) {
            result = new ArrayList<UserRepresentation>(1);
            result.add(userResource.toRepresentation());
        }
    }
    return result;
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public void updateUserDetails(User user) {
	UserRepresentation ur = client.realm(realmName).users().get(user.id).toRepresentation();
	ur.setFirstName(user.firstName);
	ur.setLastName(user.lastName);
	ur.setEmail(user.email);

	client.realm(realmName).users().get(user.id).update(ur);
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
/**
 * Method to deactivate the user on basis of user id.
 *
 * @param request Map
 * @return boolean true if success otherwise false .
 */
@Override
public String deactivateUser(Map<String, Object> request) {
  try {
    Keycloak keycloak = KeyCloakConnectionProvider.getConnection();
    String userId = (String) request.get(JsonKey.USER_ID);
    UserResource resource =
        keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(userId);
    UserRepresentation ur = resource.toRepresentation();
    ur.setEnabled(false);
    if (isNotNull(resource)) {
      try {
        resource.update(ur);
      } catch (Exception ex) {
        ProjectLogger.log(ex.getMessage(), ex);
        throw new ProjectCommonException(ResponseCode.invalidUsrData.getErrorCode(),
            ResponseCode.invalidUsrData.getErrorMessage(),
            ResponseCode.CLIENT_ERROR.getResponseCode());
      }

    }
  } catch (Exception e) {
    ProjectLogger.log(e.getMessage(), e);
    throw new ProjectCommonException(ResponseCode.invalidUsrData.getErrorCode(),
        ResponseCode.invalidUsrData.getErrorMessage(),
        ResponseCode.CLIENT_ERROR.getResponseCode());
  }
  return JsonKey.SUCCESS;
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public void setEmailVerifiedUpdatedFlag(String userId, String flag) {
  UserResource resource =
      keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(userId);
  UserRepresentation user = resource.toRepresentation();
  Map<String, List<String>> map = user.getAttributes();
  List<String> list = new ArrayList<>();
  list.add(flag);
  if (map == null) {
    map = new HashMap<>();
  }
  map.put(JsonKey.EMAIL_VERIFIED_UPDATED, list);
  user.setAttributes(map);
  resource.update(user);
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public boolean addUserLoginTime(String userId) {
  boolean response = true;
  try {
    UserResource resource =
        keycloak.realm(KeyCloakConnectionProvider.SSO_REALM).users().get(userId);
    UserRepresentation ur = resource.toRepresentation();
    Map<String, List<String>> map = ur.getAttributes();
    List<String> list = new ArrayList<>();
    if (map == null) {
      map = new HashMap<>();
    }
    List<String> currentLogTime = map.get(JsonKey.CURRENT_LOGIN_TIME);
    if (currentLogTime == null || currentLogTime.isEmpty()) {
      currentLogTime = new ArrayList<>();
      currentLogTime.add(Long.toString(System.currentTimeMillis()));
    } else {
      list.add(currentLogTime.get(0));
      currentLogTime.clear();
      currentLogTime.add(0, Long.toString(System.currentTimeMillis()));
    }
    map.put(JsonKey.CURRENT_LOGIN_TIME, currentLogTime);
    map.put(JsonKey.LAST_LOGIN_TIME, list);
    ur.setAttributes(map);
    resource.update(ur);
  } catch (Exception e) {
    ProjectLogger.log(e.getMessage(), e);
    response = false;
  }
  return response;
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
/**
 * Delete Identity Provider with the given alias
 * 
 * @param orgMrn  MRN of the IDP to delete.
 */
public void deleteIdentityProvider(String orgMrn) {
    // First delete any users associated with the IDP. Find it by username, which is the mrn
    String alias = MrnUtil.getOrgShortNameFromOrgMrn(orgMrn);
    String searchStr = MrnUtil.getMrnPrefix(orgMrn) + ":user:" + alias + ":";
    List<UserRepresentation> users = getBrokerRealm().users().search(/* username*/ searchStr, /* firstName */ null, /* lastName */ null, /* email */ null,  /* first */ 0, /* max*/ 0);
    for (UserRepresentation user : users) {
        if (user.getUsername().startsWith(searchStr)) {
            getBrokerRealm().users().get(user.getId()).remove();
        }
    }
    // Delete IDP
    getBrokerRealm().identityProviders().get(alias).remove();
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
private String getClientId(CloseableKeycloak keycloak, String realm, String username) {
    List<UserRepresentation> users = keycloak.get().realm(realm).users().search(username);
    if (!users.isEmpty()) {
        return users.get(0).getId();
    }
    throw new RuntimeException("Unable to find user: " + username);
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
public void createUser(String realm, String userName, String password, long timeout, TimeUnit timeUnit) throws Exception {

        int maxRetries = 10;
        try (CloseableKeycloak keycloak = new CloseableKeycloak(endpoint, credentials, trustStore)) {
            RealmResource realmResource = waitForRealm(keycloak.get(), realm, timeout, timeUnit);

            for (int retries = 0; retries < maxRetries; retries++) {
                try {
                    if (realmResource.users().search(userName).isEmpty()) {
                        UserRepresentation userRep = new UserRepresentation();
                        userRep.setUsername(userName);
                        CredentialRepresentation cred = new CredentialRepresentation();
                        cred.setType(CredentialRepresentation.PASSWORD);
                        cred.setValue(password);
                        cred.setTemporary(false);
                        userRep.setCredentials(Arrays.asList(cred));
                        userRep.setEnabled(true);
                        Response response = keycloak.get().realm(realm).users().create(userRep);
                        if (response.getStatus() != 201) {
                            throw new RuntimeException("Unable to create user: " + response.getStatus());
                        }
                    } else {
                        Logging.log.info("User " + userName + " already created, skipping");
                    }
                    break;
                } catch (Exception e) {
                    Logging.log.info("Exception querying keycloak ({}), retrying", e.getMessage());
                    Thread.sleep(2000);
                }
            }
        }
    }
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public Set<String> getUsers(String criteria) {
    RealmResource realm = connectToRealm();

    List<UserRepresentation> users = realm.users().search(criteria, 0, 10);
    return users.stream().map(u -> u.getUsername()).collect(Collectors.toSet());
}
 

import org.keycloak.representations.idm.UserRepresentation; //导入依赖的package包/类
@Override
public boolean userExists(String user) {
    RealmResource realm = connectToRealm();
    
    List<UserRepresentation> users = realm.users().search(user, 0, 100);
    Set<String> usersSet = users.stream().map(u -> u.getUsername()).collect(Collectors.toSet());

    return usersSet.contains(user);
}