UsersCreatedAfterGroup.java

package org.fenixedu.bennu.core.example.domain.groups;

import java.lang.reflect.UndeclaredThrowableException;
import java.util.List;
import java.util.Set;
import java.util.stream.Stream;

import org.fenixedu.bennu.core.annotation.GroupArgument;
import org.fenixedu.bennu.core.annotation.GroupOperator;
import org.fenixedu.bennu.core.domain.Bennu;
import org.fenixedu.bennu.core.domain.User;
import org.fenixedu.bennu.core.domain.groups.PersistentGroup;
import org.fenixedu.bennu.core.groups.CustomGroup;
import org.fenixedu.bennu.core.groups.Group;
import org.joda.time.DateTime;

import pt.ist.fenixframework.FenixFramework;

public class UsersCreatedAfterGroup extends UsersCreatedAfterGroup_Base {
    @GroupOperator("after")
    public static class UsersCreatedAfter extends CustomGroup {
        private static final long serialVersionUID = -5322710492297718102L;

        @GroupArgument("")
        private DateTime date;

        @GroupArgument
        private Boolean inclusive;

        @GroupArgument("things")
        private Set<String> stuff;

        @GroupArgument
        private List<String> x1;

        @GroupArgument
        private String[] x2;

        protected UsersCreatedAfter() {
        }

        public UsersCreatedAfter(DateTime date) {
            this.date = date;
        }

        @Override
        public String getPresentationName() {
            return "Users Created After " + date.toString();
        }

        @Override
        public PersistentGroup toPersistentGroup() {
            return UsersCreatedAfterGroup.getInstance(date);
        }

        @Override
        public Stream<User> getMembers() {
            return Bennu.getInstance().getUserSet().stream().filter(user -> user.getCreated().isAfter(date));
        }

        @Override
        public Stream<User> getMembers(DateTime when) {
            return getMembers();
        }

        @Override
        public boolean isMember(User user) {
            return user != null && user.getCreated().isAfter(date);
        }

        @Override
        public boolean isMember(User user, DateTime when) {
            return isMember(user);
        }

        @Override
        public boolean equals(Object object) {
            if (object instanceof UsersCreatedAfter) {
                return date.equals(((UsersCreatedAfter) object).date);
            }
            return false;
        }

        @Override
        public int hashCode() {
            return date.hashCode();
        }
    }

    protected UsersCreatedAfterGroup(DateTime date) {
        super();
        setDate(date);
    }

    @Override
    public Group toGroup() {
        return new UsersCreatedAfter(getDate());
    }

    public static PersistentGroup getInstance(DateTime date) {
        try {
            return FenixFramework.atomic(() -> new UsersCreatedAfterGroup(date));
        } catch (Exception e) {
            throw new UndeclaredThrowableException(e);
        }
    }
}