private List<ContentProviderJsonResponse> revokeActPermissions(String userEmail, Map<Long, List<Long>> accountMap) {
        return accountMap.entrySet().stream().
            filter(entry -> !entry.getValue().isEmpty()).
            map(entry -> {
                long contentProviderId = entry.getKey();
                ContentProvider contentProvider = contentProviderDAO.getContentProvider(contentProviderId);
                return userApi.revokeActPermissions(contentProvider, userEmail);
            }).collect(toList());
    }

    private List<String> addUserToAccounts(ContentProviderUsersCreationData usersCreationData) throws Exception {
        if (usersCreationData.getCreateUserAccounts() == null) {
            return Collections.emptyList();
        }

        try {
            BrooklynUser user = userManagementService.getUserByEmail(usersCreationData.getEmail());
            MasterAccount userMa = masterAccountService.getMasterAccount(usersCreationData.getMasterAccountId());

            Map<Long, List<Long>> createUserAccounts = usersCreationData.getCreateUserAccounts();

            Predicate<Map.Entry<Long, List<Long>>> filterEmptyCP = entry -> {
                return !CollectionUtils.isEmpty(entry.getValue());
            };

            Function<Map.Entry<Long, List<Long>>, SimpleEntry<ContentProvider, List<Long>>> convertContentProvider =
                    entry -> {
                        return new SimpleEntry<ContentProvider, List<Long>>(
                                contentProviderDAO.getContentProvider(entry.getKey()), entry.getValue());
                    };

            Function<SimpleEntry<ContentProvider, List<Long>>,
                CompletableFuture<SimpleEntry<ContentProvider, List<Long>>>> convertToSupplier =
                    entry-> {
                        return SubjectAwareCompletableFuture.supplyAsync(
                            () -> { // clear existing user accounts
                                ContentProvider provider = entry.getKey();
                                String userEmail = user.getUserEmail();
                                long masterAccountId = usersCreationData.getMasterAccountId();

                                List<Long> existsList = userApi.getUserCPAccounts(provider, userEmail, Boolean.TRUE);
                                List<Long> linkUserAccList = Lists.newArrayList(entry.getValue());

                                entry.getValue().removeAll(existsList);
                                linkUserAccList.retainAll(existsList);

                                userApi.enableUserInCpAccounts(provider, userEmail, linkUserAccList);

                                linkUserAccList.forEach(accountId -> {
                                    linkCmpUser(provider.getId(), accountId, masterAccountId, userEmail);
                                });

                                return entry;
                            });
                    };

            List<CompletableFuture<SimpleEntry<ContentProvider, List<Long>>>> clearExistingAccounts =
                    createUserAccounts.entrySet().stream().
                        filter(filterEmptyCP).map(convertContentProvider).map(convertToSupplier).collect(toList());

            String userEmail = usersCreationData.getEmail();
            String password = StringUtils.isEmpty(usersCreationData.getPassword()) ?
                passwordService.generatePassword(user.getDefaultMasterAccountId()) :
                usersCreationData.getPassword();
            user.setPassword(password);

            List<CompletableFuture<List<String>>> futures = clearExistingAccounts.stream()
                    .map(future -> future.<List<String>>thenApply(entry -> {
                        if (entry.getValue().isEmpty())
                            return Collections.emptyList();
                        long cpId = entry.getKey().getId();
                        List<CompletableFuture<String>> errors = entry.getValue().stream()
                                //.map(acc -> getCPUserObject(user, entry.getKey().getId(), acc, baseUserName, licenseId, adminOrg))
                                .map(accountId -> usersCreationData.getContentProviderUser(cpId, accountId, user))
                                .map(cpUser -> performCreateUserRequest(userEmail, cpUser, entry.getKey(), userMa))
                                .collect(toList());
                        // wait for all responses to single cp
                        SubjectAwareCompletableFuture.allOf(errors.toArray(new CompletableFuture[errors.size()])).join();
                        return errors.stream().map(f -> f.join()).collect(toList());
                    }))
                    .collect(toList());
            // wait for top-level requests to content providers
            SubjectAwareCompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()])).join();
            return futures.stream()
                    .<String>flatMap(future -> future.join().stream())
                    .filter(s -> !StringUtils.isEmpty(s)) // remove nulls and empty messages
                    .distinct() // remove duplicates, when error occured in multiple accounts of 1 cp
                    .collect(toList());

        } catch (Exception ex) {
            return Arrays.asList(ex.getMessage());
        }
    }