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

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

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

    public boolean isEditable() {
        return user.isEditable();
    }

    public boolean hasRole(final String role) {

    public String[] getRoleNames() {
        return stream(getRoles()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    @Override
    public String[] getGroupNames() {
        return stream(getGroups()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    private String decode(final String value) {
        return new String(Base64.getDecoder().decode(value), Constants.CHARSET_UTF_8);
    }

        // Test with empty groups
        testUser.setGroupNames(new String[] {});
        assertNotNull(fessUserBean.getGroups());
        assertEquals(0, fessUserBean.getGroups().length);

        // Test with single group
        testUser.setGroupNames(new String[] { "developers" });
        String[] groups = fessUserBean.getGroups();
        assertEquals(1, groups.length);
        assertEquals("developers", groups[0]);

        final User user = new User();
        assertNull(user.getGroups());

        final String[] groups = new String[] { "group1", "group2" };
        user.setGroups(groups);
        assertNotNull(user.getGroups());
        assertEquals(2, user.getGroups().length);
        assertEquals("group1", user.getGroups()[0]);
        assertEquals("group2", user.getGroups()[1]);
    }

    @Test

            op.setRefreshPolicy(Constants.TRUE);
        });

        userBhv.selectCursor(cb -> cb.query().setGroups_Equal(group.getId()), entity -> {
            entity.setGroups(
                    stream(entity.getGroups()).get(stream -> stream.filter(s -> !s.equals(group.getId())).toArray(n -> new String[n])));
            userBhv.insertOrUpdate(entity);
        });

    }

    /**

            if (StringUtil.isEmpty(key) || userBean
                    .map(user -> stream(user.getRoles()).get(stream -> stream.anyMatch(s -> (ROLE_VALUE_PREFIX + s).equals(key)))
                            || stream(user.getGroups()).get(stream -> stream.anyMatch(s -> (GROUP_VALUE_PREFIX + s).equals(key))))
                    .orElse(false)) {
                return p.getSecond();
            }
            return null;

     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse edit(final EditForm form) {
        validate(form, messages -> {}, this::asListHtml);
        final String id = form.id;
        groupService.getGroup(id).ifPresent(entity -> {
            copyBeanToBean(entity, form, op -> {});
        }).orElse(() -> {
            throwValidationError(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, id), this::asListHtml);

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.api.admin.group;

import static org.codelibs.fess.app.web.admin.group.AdminGroupAction.getGroup;
import static org.codelibs.fess.app.web.admin.group.AdminGroupAction.validateAttributes;

import java.util.List;
import java.util.stream.Collectors;

import org.apache.logging.log4j.LogManager;

            return authResult;
        }

        /**
         * Sets the user's group memberships.
         * @param groups Array of group names.
         */
        public synchronized void setGroups(final String[] groups) {
            this.groups = groups;
        }

        /**
         * Sets the user's role assignments.
         * @param roles Array of role names.
         */

            final RESULT result = entityType.newInstance();
            result.setName(DfTypeUtil.toString(source.get(NAME)));
            result.setPassword(DfTypeUtil.toString(source.get(PASSWORD)));
            result.setGroups(toStringArray(source.get(GROUPS)));
            result.setRoles(toStringArray(source.get(ROLES)));
            result.setAttributes(source.entrySet()
                    .stream()