elephant-dossier/src/main/java/org/turro/dossier/dossier/ParticipantSet.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.dossier.dossier;
 
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import java.util.function.Predicate;
import org.turro.action.Contacts;
import org.turro.string.Strings;
import org.turro.auth.Authentication;
import org.turro.dossier.entity.CategoryParticipant;
import org.turro.dossier.entity.IDossierParticipant;
import org.turro.dossier.entity.IssueParticipant;
import org.turro.dossier.entity.IssueParticipantRole;
import org.turro.dossier.entity.Participant;
import org.turro.dossier.entity.ParticipantRole;
import org.turro.plugin.contacts.ContactList;
import org.turro.plugin.contacts.IContact;
import org.turro.visual.RoleUtil;
 
public class ParticipantSet<P> extends TreeSet<P> {
  
  public ParticipantSet(Collection<? extends P> collection) {
    super(new ParticipantComparator());
    addAllExceptEmpties(collection);
  }
 
  public ParticipantSet() {
    super(new ParticipantComparator());
  }
 
  @Override
  public boolean addAll(Collection<? extends P> collection) {
    addAllExceptEmpties(collection);
    return true;
  }
 
  public boolean isParticipant() {
    return isParticipant(getContact(null));
  }
  
  public boolean isParticipant(IContact contact) {
    return getActiveParticipation(contact) != null;
  }
  
  public boolean isIssueParticipant(IContact contact) {
    return getActiveParticipation(contact) instanceof IssueParticipant;
  }
  
  public boolean isIssueActiveParticipant(IContact contact) {
    Object obj = getActiveParticipation(contact);
    if(obj instanceof IssueParticipant) {
      IssueParticipant ip = (IssueParticipant) obj;
      return !IssueParticipantRole.ISSUE_ASSISTANT.equals(ip.getRole());
    }
    return false;
  }
  
  public boolean isDossierParticipant(IContact contact) {
    return getActiveParticipation(contact) instanceof Participant;
  }
  
  public boolean isCategoryParticipant(IContact contact) {
    return getActiveParticipation(contact) instanceof CategoryParticipant;
  }
  
  public boolean isReporter(IContact contact) {
    return participatesAs(contact, IssueParticipantRole.ISSUE_REPORTER) != null;
  }
  
  public boolean isResponsible(IContact contact) {
    return participatesAs(contact, IssueParticipantRole.ISSUE_RESPONSIBLE) != null;
  }
  
  public boolean isQA(IContact contact) {
    return participatesAs(contact, IssueParticipantRole.ISSUE_QA) != null;
  }
  
  public boolean isAssistant(IContact contact) {
    return participatesAs(contact, IssueParticipantRole.ISSUE_ASSISTANT) != null;
  }
  
  public boolean isOwner(IContact contact) {
    return participatesAs(contact, ParticipantRole.PARTICIPANT_OWNER) != null;
  }
  
  public boolean isSubject(IContact contact) {
    return participatesAs(contact, ParticipantRole.PARTICIPANT_SUBJECT) != null;
  }
  
  public boolean isShowAllAttachments(IContact contact) {
    return getIShowAllAttachments().contains(getContact(contact));
  }
  
  public boolean isShowAllIssues(IContact contact) {
    return getIShowAllIssues().contains(getContact(contact));
  }
  
  public boolean isShowParticipants(IContact contact) {
    return getIShowParticipants().contains(getContact(contact));
  }
  
  public boolean isReceiveAllEmails(IContact contact) {
    return getIReceiveAllEmails().contains(getContact(contact));
  }
  
  public boolean isBindingVote(IContact contact) {
    return getIBidingVote().contains(getContact(contact));
  }
  
  public boolean isDriver() {
    return isDriver(null);
  }
  
  public boolean isDriver(IContact contact) {
    return getIDrivers().contains(getContact(contact));
  }
  
  public boolean isOfferer() {
    return isOfferer(null);
  }
  
  public boolean isOfferer(IContact contact) {
    return getIOfferers().contains(getContact(contact));
  }
 
  public boolean isBeneficiary() {
    return isBeneficiary(null);
  }
  
  public boolean isBeneficiary(IContact contact) {
    return getIBeneficiaries().contains(getContact(contact));
  }
  
  public boolean isCoordinator() {
    return isCoordinator(null);
  }
  
  public boolean isCoordinator(IContact contact) {
    return getICoordinators().contains(getContact(contact));
  }
  
  public boolean isSupport() {
    return isSupport(null);
  }
  
  public boolean isSupport(IContact contact) {
    return getISupport().contains(getContact(contact));
  }
  
  public boolean isFunding() {
    return isFunding(null);
  }
  
  public boolean isFunding(IContact contact) {
    return getIFunding().contains(getContact(contact));
  }
  
  public boolean isResearch() {
    return isResearch(null);
  }
  
  public boolean isResearch(IContact contact) {
    return getIResearch().contains(getContact(contact));
  }
  
  public boolean isConsortium() {
    return isConsortium(null);
  }
  
  public boolean isConsortium(IContact contact) {
    return getIConsortium().contains(getContact(contact));
  }
  
  public boolean isAdmin() {
    return isAdmin(null);
  }
  
  public boolean isAdmin(IContact contact) {
    return getIAdmins().contains(getContact(contact));
  }
  
  public Object participatesAs(IContact contact, Object participation) {
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        if(dp.getRole().equals(participation) && dp.getIdContact().equals(getContact(contact).getId())) {
          return dp;
        }
      } else if(obj instanceof IssueParticipant) {
        IssueParticipant ip = (IssueParticipant) obj;
        if(ip.getRole().equals(participation) && ip.getIdContact().equals(getContact(contact).getId())) {
          return ip;
        }
      }
    }
    return null;
  }
  
  public Object getActiveParticipation(IContact contact) {
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        if(!dp.getRole().equals(ParticipantRole.PARTICIPANT_SUBJECT) && dp.getIdContact().equals(getContact(contact).getId())) {
          return dp;
        }
      } else if(obj instanceof IssueParticipant) {
        IssueParticipant ip = (IssueParticipant) obj;
        if(ip.getIdContact().equals(getContact(contact).getId())) {
          return ip;
        }
      }
    }
    return null;
  }
  
  public Object getParticipation(IContact contact) {
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        if(dp.getIdContact().equals(getContact(contact).getId())) {
          return dp;
        }
      } else if(obj instanceof IssueParticipant) {
        IssueParticipant ip = (IssueParticipant) obj;
        if(ip.getIdContact().equals(getContact(contact).getId())) {
          return ip;
        }
      }
    }
    return null;
  }
  
  public IDossierParticipant getActiveDossierParticipation(IContact contact) {
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        if(!dp.getRole().equals(ParticipantRole.PARTICIPANT_SUBJECT) && dp.getIdContact().equals(getContact(contact).getId())) {
          return dp;
        }
      }
    }
    return null;
  }
  
  public boolean canShowAllAttachments(IContact contact) {
    if(isIssueParticipant(contact)) {
      return true;
    } else {
      IDossierParticipant dp = getActiveDossierParticipation(contact);
      if(dp != null) {
        return dp.isShowAllAttachments();
      }
    }
    return false;
  }
  
  public boolean canShowIssue(IContact contact) {
    if(isIssueParticipant(contact)) {
      return true;
    } else {
      IDossierParticipant dp = getActiveDossierParticipation(contact);
      if(dp != null) {
        return dp.isShowAllIssues();
      }
    }
    return false;
  }
  
  public boolean canShowParticipants(IContact contact) {
    IDossierParticipant dp = getActiveDossierParticipation(contact);
    return isIssueActiveParticipant(contact) || (dp != null && dp.isShowParticipants());
  }
  
  /* Checks only in dossiers and categories */
  
  public String getDiscriminator(IContact contact) {
    IDossierParticipant dp = getActiveDossierParticipation(contact);
    return dp != null ? dp.getDiscriminator() : null;
  }
  
  public boolean isParticipantByDiscriminator(IContact contact, String discriminator) {
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        if(dp != null && !Strings.isBlank(discriminator) && discriminator.equalsIgnoreCase(dp.getDiscriminator()) 
                && dp.getIdContact().equals(contact.getId())) {
          return true;
        }
      }
    }
    return false;
  }
 
  public Collection<String> getDiscriminators() {
    Set<String> discriminators = new TreeSet<>();
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        discriminators.add(dp.getDiscriminator() == null ? "" : dp.getDiscriminator());
      }
      
    }
    return discriminators;
  }
  
  public Collection<IDossierParticipant> getParticipantsByDiscriminator(String discriminator) {
    Set<IDossierParticipant> participants = new ParticipantSet<>();
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        if((Strings.isBlank(discriminator) && Strings.isBlank(dp.getDiscriminator())) || 
                discriminator.equals(dp.getDiscriminator())) {
          participants.add(dp);
        }
      }
    }
    return participants;
  }
  
  public boolean isVoteParticipant(IContact contact) {
    IDossierParticipant dp = getActiveDossierParticipation(contact);
    return dp != null && dp.isBindingVote();
  }
 
  public Collection<IContact> getVoteIParticipants() {
    ContactList list = new ContactList();
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        if(dp.isBindingVote()) {
          list.add(dp.getIContact());
        }
      }
    }
    return list;
  }
  
  public Collection<IssueParticipant> getReporters() {
    Set<IssueParticipant> participants = new ParticipantSet<>();
    for(Object obj : this) {
      if(obj instanceof IssueParticipant) {
        IssueParticipant dp = (IssueParticipant) obj;
        if(dp.getRole().equals(IssueParticipantRole.ISSUE_REPORTER)) {
          participants.add(dp);
        }
      }
    }
    return participants;
  }
 
  public Collection<IssueParticipant> getResponsibles() {
    Set<IssueParticipant> participants = new ParticipantSet<>();
    for(Object obj : this) {
      if(obj instanceof IssueParticipant) {
        IssueParticipant dp = (IssueParticipant) obj;
        if(dp.getRole().equals(IssueParticipantRole.ISSUE_RESPONSIBLE)) {
          participants.add(dp);
        }
      }
    }
    return participants;
  }
 
  public HashSet<String> getParticipationStrings(IContact contact) {
    HashSet<String> set = new HashSet<>();
    if(Contacts.isValid(contact)) {
      for(Object obj : this) {
        if(obj instanceof IDossierParticipant) {
          IDossierParticipant dp = (IDossierParticipant) obj;
          if(dp.getIdContact().equals(contact.getId())) {
            set.addAll(RoleUtil.getStringRoles(dp));
          }
        } else if(obj instanceof IssueParticipant) {
          IssueParticipant ip = (IssueParticipant) obj;
          if(ip.getIdContact().equals(contact.getId())) {
            set.addAll(RoleUtil.getStringRoles(ip));
          }
        }
      }
    }
    return set;
  }
 
  /* Participation helpers */
  
  public Collection<IDossierParticipant> getOwners() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> 
            t.getRole().equals(ParticipantRole.PARTICIPANT_OWNER));
  }
  
  public Collection<IDossierParticipant> getAssistants() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> 
            t.getRole().equals(ParticipantRole.PARTICIPANT_ASSISTANT));
  }
  
  public Collection<IDossierParticipant> getSubjects() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> 
            t.getRole().equals(ParticipantRole.PARTICIPANT_SUBJECT));
  }
  
  public Collection<IDossierParticipant> getShowAllAttachments() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isShowAllAttachments());
  }
  
  public Collection<IDossierParticipant> getShowAllIssues() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isShowAllIssues());
  }
  
  public Collection<IDossierParticipant> getShowParticipants() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isShowParticipants());
  }
  
  public Collection<IDossierParticipant> getReceiveAllEmails() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isReceiveAllEmails());
  }
  
  public Collection<IDossierParticipant> getBidingVote() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isBindingVote());
  }
  
  public Collection<IDossierParticipant> getDrivers() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isDriver());
  }
  
  public Collection<IDossierParticipant> getOfferers() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isOfferer());
  }
 
  public Collection<IDossierParticipant> getBeneficiaries() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isBeneficiary());
  }
  
  public Collection<IDossierParticipant> getCoordinators() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isCoordinator());
  }
 
  public Collection<IDossierParticipant> getSupport() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isSupport());
  }
 
  public Collection<IDossierParticipant> getFunding() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isFunding());
  }
 
  public Collection<IDossierParticipant> getResearch() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isResearch());
  }
 
  public Collection<IDossierParticipant> getConsortium() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isConsortium());
  }
 
  public Collection<IDossierParticipant> getAdmins() {
    return getByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isAdmin());
  }
 
  public Collection<IDossierParticipant> getByFunction(Predicate whatIs) {
    Set<IDossierParticipant> set = new ParticipantSet<>();
    this.stream().filter((dp) -> ((dp instanceof IDossierParticipant) && whatIs.test(dp))).forEachOrdered((dp) -> {
      set.add((IDossierParticipant) dp);
    });
    return set;
  }
  
  /* IContact helpers */
  
  public boolean isRole(IContact contact, ParticipantRole role) {
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        if(dp.getIdContact().equals(contact.getId()) && dp.getRole().equals(role)) {
          return true;
        }
      }
    }
    return false;
  }
  
  public Collection<IContact> getIParticipants() {
    ContactList list = new ContactList();
    for(Object obj : this) {
      if(obj instanceof IDossierParticipant) {
        IDossierParticipant dp = (IDossierParticipant) obj;
        list.add(dp.getIContact());
      } else if(obj instanceof IssueParticipant) {
        IssueParticipant ip = (IssueParticipant) obj;
        list.add(ip.getIContact());
      }
    }
    return list;
  }
  
  public Collection<IContact> getIShowAllAttachments() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isShowAllAttachments());
  }
  
  public Collection<IContact> getIShowAllIssues() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isShowAllIssues());
  }
  
  public Collection<IContact> getIShowParticipants() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isShowParticipants());
  }
  
  public Collection<IContact> getIReceiveAllEmails() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isReceiveAllEmails());
  }
  
  public Collection<IContact> getIBidingVote() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isBindingVote());
  }
  
  public Collection<IContact> getIDrivers() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isDriver());
  }
  
  public Collection<IContact> getIOfferers() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isOfferer());
  }
 
  public Collection<IContact> getIBeneficiaries() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isBeneficiary());
  }
  
  public Collection<IContact> getICoordinators() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isCoordinator());
  }
 
  public Collection<IContact> getISupport() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isSupport());
  }
 
  public Collection<IContact> getIFunding() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isFunding());
  }
 
  public Collection<IContact> getIResearch() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isResearch());
  }
 
  public Collection<IContact> getIConsortium() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isConsortium());
  }
 
  public Collection<IContact> getIAdmins() {
    return getIContactsByFunction((Predicate<IDossierParticipant>) (IDossierParticipant t) -> t.isAdmin());
  }
 
  public Collection<IContact> getIContactsByFunction(Predicate whatIs) {
    ContactList list = new ContactList();
    this.stream().filter((obj) -> (obj instanceof IDossierParticipant))
            .map((obj) -> (IDossierParticipant) obj).filter((p) -> (whatIs.test(p))).forEachOrdered((p) -> {
      list.add(p.getIContact());
    });
    return list;
  }
  
  /* Empties */
  
  private void addAllExceptEmpties(Collection<? extends P> collection) {
    for(P obj: collection) {
      if(!isEmpty(obj)) add(obj);
    }
  }
 
  private boolean isEmpty(Object obj) {
    if(obj instanceof Participant) {
      return ((Participant) obj).isEmpty();
    } else if(obj instanceof CategoryParticipant) {
      return ((CategoryParticipant) obj).isEmpty();
    } else if(obj instanceof IssueParticipant) {
      return ((IssueParticipant) obj).isEmpty();
    }
    return true;
  }
  
  /* Authenticated */
  
  private IContact _contact;
 
  private IContact getContact(IContact contact) {
    if(contact != null) {
      _contact = contact;
    }
    if(_contact == null) {
      _contact = Authentication.getIContact();
    }
    return _contact;
  }
 
}