ioan.surariu

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-security</artifactId>
</dependency>

<dependency>
	<groupId>org.keycloak</groupId>
	<artifactId>keycloak-spring-boot-starter</artifactId>
	<version>${keycloak.version}</version>
</dependency>

<dependency>
	<groupId>org.keycloak</groupId>
	<artifactId>keycloak-admin-client</artifactId>
	<version>${keycloak.version}</version>
</dependency>

# General setting
is:
  keycloak:
    admin:
      user: admin
      password: admin
server:
  port: 8888

# Keycloak settings
keycloak:
  realm: IS Test
  auth-server-url: http://192.168.56.105:8090/auth
  ssl-required: none
  resource: is-keycloak
  use-resource-role-mappings: true
  bearer-only: true
  cors: true
  principal-attribute: preferred_username

@Configuration
@EnableWebSecurity
@ComponentScan(basePackageClasses = KeycloakSecurityComponents.class)
public class SpringSecurity extends KeycloakWebSecurityConfigurerAdapter {
    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) {
        KeycloakAuthenticationProvider authenticationProvider = keycloakAuthenticationProvider();
        authenticationProvider.setGrantedAuthoritiesMapper(new SimpleAuthorityMapper());
        auth.authenticationProvider(authenticationProvider);
    }

    @Bean
    public KeycloakSpringBootConfigResolver keycloakConfigResolver() {
        return new KeycloakSpringBootConfigResolver();
    }

    @Bean
    @Override
    protected SessionAuthenticationStrategy sessionAuthenticationStrategy() {
        return new RegisterSessionAuthenticationStrategy(new SessionRegistryImpl());
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        super.configure(http);
        http.cors().and().csrf().disable();
        http.authorizeRequests()
                .anyRequest()
                .permitAll();
    }
}

@PostMapping("/user")
public ResponseEntity<String> createUser(@RequestParam String username, @RequestParam String password) {
	if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password)) {
		return ResponseEntity.badRequest().body("Empty username or password");
	}
	CredentialRepresentation credentials = new CredentialRepresentation();
	credentials.setType(CredentialRepresentation.PASSWORD);
	credentials.setValue(password);
	credentials.setTemporary(false);
	UserRepresentation userRepresentation = new UserRepresentation();
	userRepresentation.setUsername(username);
	userRepresentation.setCredentials(Arrays.asList(credentials));
	userRepresentation.setEnabled(true);
	Map<String, List<String>> attributes = new HashMap<>();
	attributes.put("description", Arrays.asList("A test user"));
	userRepresentation.setAttributes(attributes);
	Keycloak keycloak = getKeycloakInstance();
	Response result = keycloak.realm(keycloakRealm).users().create(userRepresentation);
	return new ResponseEntity<>(HttpStatus.valueOf(result.getStatus()));
}

@GetMapping("/users")
public List<UserRepresentation> getUsers() {
	Keycloak keycloak = getKeycloakInstance();
	List<UserRepresentation> userRepresentations = keycloak.realm(keycloakRealm).users().list();
	return userRepresentations;
}

@PutMapping("/user")
public ResponseEntity<UserRepresentation> updateUserDescriptionAttribute(@RequestParam String username,
																		 @RequestParam String description) {
	Keycloak keycloak = getKeycloakInstance();
	Optional<UserRepresentation> user = keycloak.realm(keycloakRealm).users().search(username).stream()
			.filter(u -> u.getUsername().equals(username)).findFirst();
	if (user.isPresent()) {
		UserRepresentation userRepresentation = user.get();
		UserResource userResource = keycloak.realm(keycloakRealm).users().get(userRepresentation.getId());
		Map<String, List<String>> attributes = new HashMap<>();
		attributes.put("description", Arrays.asList(description));
		userRepresentation.setAttributes(attributes);
		userResource.update(userRepresentation);
		return ResponseEntity.ok().body(userRepresentation);
	} else {
		return ResponseEntity.badRequest().build();
	}
}

@DeleteMapping("/user")
public void deleteUser(String username) {
	Keycloak keycloak = getKeycloakInstance();
        UsersResource users = keycloak.realm(keycloakRealm).users();
        users.search(username).stream()
                .forEach(user -> keycloak.realm(keycloakRealm).users().delete(user.getId()));
}

@GetMapping("/roles")
public ResponseEntity<List<RoleRepresentation>> getRoles() {
	Keycloak keycloak = getKeycloakInstance();
	ClientRepresentation clientRepresentation = keycloak.realm(keycloakRealm).clients().findByClientId(keycloakClient).get(0);
	List<RoleRepresentation> roles = keycloak.realm(keycloakRealm).clients().get(clientRepresentation.getId()).roles().list();
	return ResponseEntity.ok(roles);
}

@GetMapping("/roles-by-user")
public ResponseEntity<List<RoleRepresentation>> getRolesByUser(@RequestParam String username) {
	Keycloak keycloak = getKeycloakInstance();
	Optional<UserRepresentation> user = keycloak.realm(keycloakRealm).users().search(username).stream()
			.filter(u -> u.getUsername().equals(username)).findFirst();
	if (user.isPresent()) {
		UserRepresentation userRepresentation = user.get();
		UserResource userResource = keycloak.realm(keycloakRealm).users().get(userRepresentation.getId());
		ClientRepresentation clientRepresentation = keycloak.realm(keycloakRealm).clients().findByClientId(keycloakClient).get(0);
		List<RoleRepresentation> roles = userResource.roles().clientLevel(clientRepresentation.getId()).listAll();
		return ResponseEntity.ok(roles);
	} else {
		return ResponseEntity.badRequest().build();
	}
}