.toArray(n -> new String[n])));
            final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
            entity.setPermissions(split(form.permissions, "\n").get(stream -> stream.map(s -> permissionHelper.encode(s))
                    .filter(StringUtil::isNotBlank)
                    .distinct()
                    .toArray(n -> new String[n])));

                            .toArray(n -> new String[n])));
            final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
            entity.setPermissions(split(form.permissions, "\n").get(stream -> stream.map(s -> permissionHelper.encode(s))
                    .filter(StringUtil::isNotBlank)
                    .distinct()
                    .toArray(n -> new String[n])));

        return crawlingConfig.getId();
    }

    @Override
    public String getName() {
        return crawlingConfig.getName();
    }

    @Override
    public String[] getPermissions() {
        return crawlingConfig.getPermissions();
    }

    @Override
    public String[] getVirtualHosts() {
        return crawlingConfig.getVirtualHosts();
    }

    @Override
    public String getDocumentBoost() {

    //                                                                            Accessor
    //                                                                            ========
    public String[] getPermissions() {
        return user.getPermissions();
    }

    public String[] getRoles() {
        return user.getRoleNames();
    }

    public String[] getGroups() {
        return user.getGroupNames();
    }

        return stream(getPermissions()).get(stream -> stream.filter(s -> s.startsWith(fessConfig.getRoleSearchRolePrefix()))
                .map(s -> s.substring(1))
                .toArray(n -> new String[n]));
    }

    @Override
    public String[] getGroupNames() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        assertArrayEquals(permissions, user.getPermissions());

        // Test with single permission
        permissions = new String[] { "read" };
        user = new TestFessUser("testuser", new String[] {}, new String[] {}, permissions);
        assertArrayEquals(permissions, user.getPermissions());

        // Test with empty permissions
        permissions = new String[] {};

                return "";
            }
        });

        String[] permissions = ldapUser.getPermissions();
        assertNotNull(permissions);
        assertEquals(0, permissions.length);

        // Test that permissions are cached
        String[] permissions2 = ldapUser.getPermissions();
        assertSame(permissions, permissions2);
    }

    public void test_getPermissions_withBaseDnOnly() {

        // search

    }

    /**
     * Get the permissions.
     * @param request The request.
     * @return The permissions.
     */
    public OptionalEntity<Set<String>> getPermissions(final HttpServletRequest request) {
        final String token = ComponentUtil.getAccessTokenHelper().getAccessTokenFromRequest(request);
        if (StringUtil.isNotBlank(token)) {

        valueMap.put("action", Action.LOGIN.name());
        valueMap.put("user", user.map(FessUserBean::getUserId).orElse("-"));
        valueMap.put("permissions",
                user.map(u -> stream(u.getPermissions()).get(stream -> stream.collect(Collectors.joining(permissionSeparator))))
                        .filter(StringUtil::isNotBlank)
                        .orElse("-"));
        log(valueMap);
    }

    /**

        });

        final EditBody body = createEditBody(entity);
        final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
        body.permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                .filter(StringUtil::isNotBlank)
                .distinct()
                .collect(Collectors.joining("\n")));