DossierIterator.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2013 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.www;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import org.turro.string.ObjectString;
import org.turro.string.Strings;
import org.turro.action.IEntityCtrl;
import org.turro.action.Plugins;
import org.turro.attach.www.AttachCtrl;
import org.turro.auth.Authentication;
import org.turro.charts.Data;
import org.turro.collections.ItemOf;
import org.turro.collections.SetOf;
import org.turro.dossier.command.DossierAction;
import org.turro.dossier.db.DossierPU;
import org.turro.dossier.dossier.DossierWrapper;
import org.turro.dossier.dossier.ProjectContext;
import org.turro.dossier.dw.DWIssueModel;
import org.turro.dossier.dw.DWWebChart;
import org.turro.dossier.entity.Category;
import org.turro.dossier.entity.Dossier;
import org.turro.dossier.entity.DossierStatus;
import org.turro.dossier.entity.DossierType;
import org.turro.dossier.entity.Issue;
import org.turro.dossier.entity.IssueResolution;
import org.turro.dossier.entity.IssueStatus;
import org.turro.dossier.entity.IssueType;
import org.turro.dossier.entity.ParticipantRole;
import org.turro.dossier.issue.IssueWrapper;
import org.turro.dossier.search.CategoryResults;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.db.WhereClause;
import org.turro.elephant.impl.repository.Repository;
import org.turro.elephant.impl.repository.RepositoryFile;
import org.turro.elephant.web.SocialImageMap;
import org.turro.elephant.web.SocialNet;
import org.turro.entities.Entities;
import org.turro.file.util.FileAttach;
import org.turro.i18n.I_;
import org.turro.indicator.Statistics;
import org.turro.jpa.entity.EntityWebUrls;
import org.turro.jpa.iterator.DaoHtmlIterator;
import org.turro.jpa.search.DaoHtmlSearch;
import org.turro.jpa.search.DaoSearchKey;
import org.turro.mail.recipients.MailContact;
import org.turro.marker.ElephantMarker;
import org.turro.marker.MarkerHelper;
import org.turro.math.Numbers;
import org.turro.participation.ParticipationReason;
import org.turro.phase.PhaseDefinitions;
import org.turro.plugin.contacts.ContactList;
import org.turro.plugin.contacts.IContact;
import org.turro.polls.PollsCtrl;
import org.turro.tags.TagCloud;
import org.turro.util.Arrays;
import org.turro.visual.DossierVisualElements;
import org.turro.visual.VisualElements;
import org.turro.www.commentit.CommentItCtrl;
import org.turro.www.describeit.DescribeItCtrl;
import org.turro.www.starit.StarItCtrl;
import org.turro.www.voteit.VoteItCtrl;
 
public class DossierIterator extends DaoHtmlIterator<Dossier, Long>  {
 
  private final String pubPath, uniqueId;
  private String actualParameters, allowedCategories, issuePath, pendingWorths;
  private long categoryId, dossierId, lastCategoryId = -1;
  private List<String> dossierTypes, dossierStatus, projectPhases;
  private boolean showSubject;
  private boolean all, direct;
  private Collection<IContact> related;
  private PhaseHtmlFilter phaseFilter;
  
  public DossierIterator(IConstructor constructor, String pubPath, String uniqueId) {
    this(constructor, false, pubPath, uniqueId);
  }
 
  public DossierIterator(IConstructor constructor, boolean mail, String pubPath, String uniqueId) {
    super(new DossierPU(), new ElephantMarker(constructor, mail));
    this.pubPath = pubPath;
    this.uniqueId = uniqueId;
    this.all = Application.getApplication().isInRole("dossier:all");
  }
 
  public void setCategoryId(long categoryId) {
    this.categoryId = categoryId;
  }
 
  public void setDossierId(long dossierId) {
    this.dossierId = dossierId;
  }
 
  void setDossierTypes(List<String> dossierTypes) {
    this.dossierTypes = dossierTypes;
  }
 
  public void setDossierStatus(List<String> dossierStatus) {
    this.dossierStatus = dossierStatus;
  }
 
  public List<String> getProjectPhases() {
    return projectPhases;
  }
 
  public void setProjectPhases(List<String> projectPhases) {
    this.projectPhases = projectPhases;
  }
 
  public boolean isShowSubject() {
    return showSubject;
  }
 
  public void setShowSubject(boolean showSubject) {
    this.showSubject = showSubject;
  }
 
  public void setAllowedCategories(String allowedCategories) {
    this.allowedCategories = allowedCategories;
  }
 
  public boolean isDirect() {
    return direct;
  }
 
  public void setDirect(boolean direct) {
    this.direct = direct;
  }
 
  public void setRelated(Collection<IContact> related) {
    this.related = related;
  }
 
  public String getPendingWorths() {
    return pendingWorths;
  }
 
  public void setPendingWorths(String pendingWorths) {
    this.pendingWorths = pendingWorths;
  }
 
  public String getIssuePath() {
    return issuePath;
  }
 
  public void setIssuePath(String issuePath) {
    this.issuePath = issuePath;
  }
 
  public PhaseHtmlFilter getPhaseFilter() {
    return phaseFilter;
  }
 
  public void setPhaseFilter(PhaseHtmlFilter phaseFilter) {
    this.phaseFilter = phaseFilter;
  }
 
  @Override
  protected WhereClause getWhereClause() {
    WhereClause wc = new WhereClause();
    wc.addClause("select distinct dossier from Dossier as dossier");
    wc.addClause("left outer join dossier.participants participant");
    wc.addClause("left outer join dossier.project project");
    return Statistics.load(constructor, "DossierRanking", "DossierContactMatching", wc)
          .allowMatching(isAllowMatching())
          .allowRanking(isAllowRanking())
          .doMatching(isDoMatching())
          .setContact(Authentication.getIContact())
          .setEntityFields("dossier", "id")
          .setDefaultSorting("dossier.description")
          .onCriteria(w -> addCriteria(w, true))
          .getClause();
  }
 
  @Override
  protected WhereClause getCountClause() {
    WhereClause wc = new WhereClause();
    wc.addClause("select count(distinct dossier) from Dossier as dossier");
    wc.addClause("left outer join dossier.participants participant");
    wc.addClause("left outer join dossier.project project");
    addCriteria(wc, true);
    return wc;
  }
 
  public String getActualParameters() {
    return Strings.isBlank(actualParameters) ? "?a=b" : actualParameters;
  }
  
  public AttachCtrl getAttachments(Object obj) {
    if(obj instanceof Issue) {
      Issue issue = (Issue) obj;
      AttachCtrl ac = new AttachCtrl(constructor);
      ac.setEntityPath(DossierPU.getObjectPath(issue));
      if(isRestricted() && new DossierWrapper(issue.getDossier()).getCanShowAllAttachments()) {
        ac.setPublicOnly(false);
      } else {
        ac.setPublicOnly(true);
      }
      return ac;
    } else if(obj instanceof Dossier) {
      Dossier dossier = (Dossier) obj;
      AttachCtrl ac = new AttachCtrl(constructor);
      ac.setEntityPath(DossierPU.getObjectPath(dossier));
      IContact contact = Authentication.getIContact();
      ac.addRestrictedFolders(dossier.getFullParticipants().getParticipationStrings(contact));
      if(isRestricted() && new DossierWrapper(dossier).getCanShowAllAttachments()) {
        ac.setPublicOnly(false);
      } else {
        ac.setPublicOnly(true);
      }
      return ac;
    }
    return null;
  }
 
  public String getCreateIssueCtrl(String link, Dossier dossier, String template) {
    return CreateIssueCtrl.createIssue(link, dossier.getId() + "", template);
  }
  
  public String getAddInformationCtrl(String link, Issue issue, String template) {
    return AddInformationCtrl.addInformation(new IssueWrapper(issue), link, template);
  }
  
  public Object getParticipationCtrl(Dossier dossier, ParticipationReason reason) {
    return Entities.getController(dossier).getParticipationControl(constructor, reason);
  }
  
  @Override
  protected void renderSummary(ElephantMarker marker, Dossier e, int page) {
    if(e != null) {
      marker.put("dossier", e);
      marker.put("newCategory", e.getCategory().getId() != lastCategoryId);
      lastCategoryId = e.getCategory().getId();
      prepareValues(e, page, false);
      marker.put("restricted", isRestricted());
    }
    marker.process("dossier", getSummaryTemplate());
    actualParameters = getPageLink(page);
  }
 
  @Override
  protected void renderItem(ElephantMarker marker, Dossier e, int page) {
    Long issueId = (Long) ObjectString.parseString(constructor.getParameter("issueId"), Long.class, false);
    if(issueId != null) {
      Issue issue = dao.find(Issue.class, issueId);
      if(issue != null && issue.getDossier().getId().equals(e.getId())) {
        marker.put("issue", issue);
        if(!Strings.isBlank(issue.getFullDescription(showSubject))) {
          constructor.addOnLoadedJavaScript(
            "jQuery('title').html('" + issue.getFullDescription(showSubject).replace("'", "\\'") + "');"
          );
        }
        prepareValues(issue, page, false);
        marker.put("restricted", isRestricted());
        marker.process("issue", getFullTemplate());
      }
    } else {
      marker.put("dossier", e);
//      if(!Strings.isBlank(e.getFullDescription(showSubject))) {
//        constructor.addOnLoadedJavaScript(
//          "jQuery('title').html('" + e.getFullDescription(showSubject).replace("'", "\\'") + "');"
//        );
//      }
      prepareValues(e, page, false);
      marker.put("restricted", isRestricted());
      marker.process("dossier", getFullTemplate());
    }
    actualParameters = getPageLink(page);
  }
 
  @Override
  protected String entityRoot() {
    return "dossier";
  }
 
  @Override
  protected Dossier entity(Long value) {
    WhereClause wc = new WhereClause();
    wc.addClause("select distinct dossier from Dossier as dossier");
    wc.addClause("left outer join dossier.participants participant");
    wc.addClause("left outer join dossier.project project");
    addCriteria(wc, true);
    wc.addClause("and dossier.id = :id");
    wc.addNamedValue("id", value);
    return (Dossier) dao.getSingleResultOrNull(wc);
  }
  
  @Override
  protected Long getIdentifier() {
    Long identifier = getIDFromURL("/dossier");
    if(identifier == null) {
      identifier = super.getIdentifier();
    }
    return identifier;
  }
  
  private void addCriteria(WhereClause wc, boolean filterPhase) {
    addCategories(wc);
    if(!Strings.isBlank(pubPath) && isSearchOption()) {
      DaoHtmlSearch dhs = DaoHtmlSearch.getInstance(constructor, ElephantContext.getContextVariable(constructor));
      if(dhs != null) {
        DaoSearchKey dsk = dhs.get("search-value");
        if(dsk != null) {
          dsk.applyToQuery(wc, Arrays.objects("dossier.description"), true);
        }
      }
      if(filterPhase) {
        PhaseHtmlFilter phf = PhaseHtmlFilter.getInstance(constructor,  ElephantContext.getContextVariable(constructor));
        if(phf != null && !phf.isEmpty()) {
          int phase = Numbers.from(phf.getPhase(), -1).intValue();
          if(phase > -1) {
            String par = "phase" + wc.getUniqueSuffix();
            wc.addClause("and dossier.project.phase = :" + par);
            wc.addNamedValue(par, phase);
          }
        }
      }
    }
    if(!isRestricted()) {
      wc.addClause("and dossier.publishable = TRUE");
    }
    if(!Strings.isBlank(pendingWorths)) {
      IContact contact = Authentication.getIContact();
      wc.addClause("and not exists (");
      wc.addClause("select v from WorthValue v"); 
      wc.addClause("where v.dossier = dossier");
      wc.addClause("and v.worthDefinition.id in (" + pendingWorths + ")");
      wc.addClause("and v.idContact = :pendContact");
      wc.addNamedValue("pendContact", contact.getId());
      wc.addClause(")");
    }
    if(categoryId > 0) {
      wc.addClause("and dossier.category.id in (" + getCategories(categoryId) + ")");
    } else if(dossierId > 0) {
      wc.addClause("and dossier.id = " + dossierId);
    } else if(!Strings.isBlank(allowedCategories)) {
      if(!wantItem()) {
        String selCat = CategoriesTree.getSelectedItem(constructor, ElephantContext.getContextVariable(constructor));
        if(!Strings.isBlank(selCat)) {
          wc.addClause("and dossier.category.fullDescription like '" + Category.getPathToFullDescription(selCat + "%'"));
        }
      }
      if(!"all".equals(allowedCategories)) {
        CategoryResults.addExistsCategoryAffiliance(wc, allowedCategories, "dossier");
      }
    }
    if(dossierTypes != null && dossierTypes.size() > 0) {
      wc.addClause("and dossier.type in (:types)");
      wc.addNamedValue("types", Arrays.fromCollection(dossierTypes).map(t -> typeValue((String) t)));
    }
    if(dossierStatus != null && dossierStatus.size() > 0) {
      wc.addClause("and dossier.status in (:status)");
      wc.addNamedValue("status", Arrays.fromCollection(dossierStatus).map(t -> statusValue((String) t)));
    }
    if(filterPhase) {
      if(projectPhases != null && !projectPhases.isEmpty()) {
        List<Integer> indexes = PhaseDefinitions.instance().stream()
                .filter(pd -> pd.anyStringMatch(projectPhases))
                .map(pd -> pd.getIndex()).toList();
        wc.addClause("and dossier.project.phase in (:phases)");
        wc.addNamedValue("phases", indexes);
      }
    }
    if(TagCloud.hasSelected(constructor, "dossier")) {
      wc.addIn("and", "dossier.id", TagCloud.getIdentifiersAsLong(constructor, "dossier"));
    }
  }
 
  @Override
  protected boolean isValid(Dossier e) {
    if(isRestricted() && e != null) {
      return all || new DossierWrapper(e).isParticipant();
    } else {
      return super.isValid(e);
    }    
  }
 
  @Override
  protected VisualElements loadVisuals() {
    return DossierVisualElements.load();
  }
 
  private String getCategories(long categoryId) {
    String result = null;
    Category category = dao.find(Category.class, Long.valueOf(categoryId));
    return addCategory(category, result);
  }
 
  private String addCategory(Category category, String result) {
    if(category != null) {
      result = (String) (((result == null) ? "" : result + ",") + category.getId());
      for(Category c : category.getChildren()) {
        result = addCategory(c, result);
      }      
    }
    return result;
  }
 
  private void prepareValues(final Dossier dossier, int page, boolean asMail) {   
    DossierWrapper dw = new DossierWrapper(dossier);
    marker.put("wrapper", dw);
    marker.put("iee", Entities.getController(dossier));
 
    if(asMail && pubPath != null) {
      marker.put("name", MailContact.createLink(dossier.getDescription(), getItemLink(dossier, page), false));
    } else {
      marker.put("name", dossier.getDescription());
    }
    String link = getItemLink(dossier, page);
    if(link != null) {
      marker.put("path", link);
      marker.put("all", getPageLink(page));
    }
    if(!Strings.isBlank(pubPath)) {
      marker.put("readall", getItemLink(dossier, page));
    }
    marker.put("dossierClass", "dossier" +
            (dossier.getStatus().equals(DossierStatus.DOSSIER_OPENED) ? " openned" : "") +
            (dossier.getStatus().equals(DossierStatus.DOSSIER_CLOSED) ? " closed" : "") +
            (dossier.getStatus().equals(DossierStatus.DOSSIER_FROZEN) ? " frozen" : ""));
    if(!Strings.isBlank(issuePath)) {
      marker.put("issuePath", ElephantContext.getRootWebPath() + issuePath);
    } else if(dw.getCanShowAllIssues()) {
      marker.put("issuePath", ElephantContext.getRootWebPath() + "/user/kbase");
    }
    
    if(isAllowVotes()) {
      if(dossier.getType().isVotes()) {
        VoteItCtrl vic = new VoteItCtrl(constructor);
        vic.setEntityPath(DossierPU.getObjectPath(dossier));
        vic.setForbiden(!dossier.getStatus().isOpen());
          if(dossier.getType().isSecret()) {
          vic.setForbid(true);
          vic.setAllowed((ContactList) dossier.getFullParticipants().getVoteIParticipants());
        }
        marker.put("vic", vic);
      }
    }
    if(isAllowInterest()) {
      StarItCtrl sic = new StarItCtrl(constructor);
      sic.setEntityPath(DossierPU.getObjectPath(dossier));
      marker.put("sic", sic);
    }
    if(isAllowComments()) {
      CommentItCtrl cic = new CommentItCtrl(constructor);
      cic.setEntityPath(DossierPU.getObjectPath(dossier));
      marker.put("cic", cic);
    }
    if(isAllowAttachments()) {
      AttachCtrl ac = new AttachCtrl(constructor);
      ac.setEntityPath(DossierPU.getObjectPath(dossier));
      ac.setPublicOnly(true);
      IContact contact = Authentication.getIContact();
      ac.addRestrictedFolders(dossier.getFullParticipants().getParticipationStrings(contact));
      marker.put("ac", ac);
    }
    if(isAllowDescriptions()) {
      DescribeItCtrl dic = new DescribeItCtrl(constructor);
      dic.setEntityPath(DossierPU.getObjectPath(dossier));
      marker.put("dic", dic);
    }
    PollsCtrl pollc = new PollsCtrl(constructor);
    pollc.setEntityPath(DossierPU.getObjectPath(dossier));
    marker.put("pollc", pollc);
    
    final DWIssueModel issueModel = new DWIssueModel();
    issueModel.setDossierId(dossier.getId());
    marker.put("issueModel", issueModel);
    DWWebChart type = new DWWebChart(constructor) {
      @Override
      protected void onCreate(Data data, Object[] pars) {
        data.setLink(ElephantContext.getRootWebPath() + KnowledgeBaseDashboard.createLink("*", false, 
                (Set<IssueType>) EnumSet.of((IssueType) pars[0]), null, null, dossier.getId()));
      }
      @Override
      protected void loadData() {
        setData(I_.get("Type"), issueModel.getByType());
      }
    };    
    marker.put("typeChart", type);
    DWWebChart status = new DWWebChart(constructor) {
      @Override
      protected void onCreate(Data data, Object[] pars) {
        data.setLink(ElephantContext.getRootWebPath() + KnowledgeBaseDashboard.createLink("*", false, null, 
                (Set<IssueStatus>) EnumSet.of((IssueStatus) pars[0]), null, dossier.getId()));
      }      
      @Override
      protected void loadData() {
        setData(I_.get("Status"), issueModel.getByStatus());
      }
    };
    marker.put("statusChart", status);
    DWWebChart resolution = new DWWebChart(constructor) {
      @Override
      protected void onCreate(Data data, Object[] pars) {
        data.setLink(ElephantContext.getRootWebPath() + KnowledgeBaseDashboard.createLink("*", false, null, null, 
                (Set<IssueResolution>) EnumSet.of((IssueResolution) pars[0]), dossier.getId()));
      }      
      @Override
      protected void loadData() {
        setData(I_.get("Resolution"), issueModel.getByResolution());
      }
    };    
    marker.put("resolutionChart", resolution);
 
    marker.put("actions", new DossierAction());
    
    marker.put("files", new FileAttach(DossierPU.getObjectPath(dossier)));
    marker.put("projectContext", new ProjectContext());
    marker.put("dve", DossierVisualElements.load());
    
    /* Students */
    IEntityCtrl ec = Plugins.loadImplementation(IEntityCtrl.class, "students-ctrl");
    if(ec != null) {
      ec.setConstructor(constructor);
      ec.setEntityPath(DossierPU.getObjectPath(dossier));
      marker.put("students", ec);
    }
    
    /* Forum */
    IEntityCtrl ecf = Plugins.loadImplementation(IEntityCtrl.class, "forum-ctrl");
    if(ecf != null) {
      ecf.setConstructor(constructor);
      ecf.setEntityPath(DossierPU.getObjectPath(dossier));
      ecf.setTemplate("related");
      marker.put("forum", ecf);
    }
    
    marker.put("follow", getParticipationCtrl(dossier, ParticipationReason.REASON_FOLLOW));
    
    if(dw.getCanShowAllIssues()) {
      marker.put("createIssue", CreateIssueCtrl.linkToCreateIssue(link, dossier.getId() + "", null));
    }
  }
  
  private void prepareValues(Issue issue, int page, boolean asMail) {
    marker.put("wrapper", new IssueWrapper(issue));
    marker.put("iee", Entities.getController(issue));
    
    if(isAllowVotes()) {
      Dossier dossier = issue.getDossier();
      if(dossier.getType().isVotes()) {
        VoteItCtrl vic = new VoteItCtrl(constructor);
        vic.setEntityPath(DossierPU.getObjectPath(issue));
        vic.setForbiden(issue.getStatus().isFinished());
        if(dossier.getType().isSecret()) {
          vic.setForbid(true);
          vic.setAllowed((ContactList) dossier.getFullParticipants().getVoteIParticipants());
        }
        marker.put("vic", vic);
      }
    }
    if(isAllowInterest()) {
      StarItCtrl sic = new StarItCtrl(constructor);
      sic.setEntityPath(DossierPU.getObjectPath(issue));
      marker.put("sic", sic);
    }
    if(isAllowComments()) {
      CommentItCtrl cic = new CommentItCtrl(constructor);
      cic.setEntityPath(DossierPU.getObjectPath(issue));
      marker.put("cic", cic);
    }
    if(isAllowAttachments()) {
      AttachCtrl ac = new AttachCtrl(constructor);
      ac.setEntityPath(DossierPU.getObjectPath(issue));
      ac.setPublicOnly(true);
      IContact contact = Authentication.getIContact();
      ac.addRestrictedFolders(issue.getDossier().getFullParticipants().getParticipationStrings(contact));
      marker.put("ac", ac);
    }
    if(isAllowDescriptions()) {
      DescribeItCtrl dic = new DescribeItCtrl(constructor);
      dic.setEntityPath(DossierPU.getObjectPath(issue));
      marker.put("dic", dic);
    }
    marker.put("files", new FileAttach(DossierPU.getObjectPath(issue)));
  }
  
  private String getItemLink(Dossier dossier, int page) {
    if(pubPath == null) {
      String link = dossier.getDossierURL();
      if(link == null) {
        return null;
      } else {
        return ElephantContext.getRootWebPath() + link;
      }
    } else {
      String ewu = EntityWebUrls.getUrlFromEntity(dossier);
      if(ewu != null) {
        return pubPath + ewu;
      } else {
        return pubPath + "?" + MarkerHelper.setObfuscatedPars("item=" + dossier.getId());
      }
    }    
  }
 
  private String getPageLink(int page) {
    return pubPath + "?page=" + page;
  }
 
  @Override
  protected String title(Dossier e) {
    if(!Strings.isBlank(e.getFullDescription(showSubject))) {
      return e.getFullDescription(showSubject);
    }
    return null;
  }
 
  @Override
  protected Collection<String> metas(Dossier e) {
    ArrayList<RepositoryFile> files = new ArrayList<>();
    String path = getItemLink(e, 0);
    if(!SocialImageMap.hasImage(path)) {
      FileAttach fa = new FileAttach(DossierPU.getObjectPath(e));
      Repository repository = fa.getPublishableRepository(constructor);
      files.addAll(repository.getRepositoryFiles("*_social.png,*_social.jpg"));
      files.addAll(repository.getRepositoryFiles("*.png,*.jpg"));
    }
    SocialNet sn;
    if(e.getProject() != null) {
      sn = new SocialNet(path, e.getDescription(), e.getProject().getGoal(), files);
    } else {
      sn = new SocialNet(path, e.getDescription(), e.getFullDescription(), files);
    }
    return sn.getMetas();
  }
 
  private void addCategories(WhereClause wc) {
    if(direct) {
      IContact contact = Authentication.getIContact();
      if(contact == null || !contact.isValid()) {
        wc.addClause("where 1=2");
      } else {
        wc.addClause("where (");
        wc.addClause("participant.idContact = :idContact");
        wc.addNamedValue("idContact", contact.getId());
        wc.addClause("and (participant.role = :cpdrole1 or participant.role = :cpdrole2)");
        wc.addNamedValue("cpdrole1", ParticipantRole.PARTICIPANT_OWNER);
        wc.addNamedValue("cpdrole2", ParticipantRole.PARTICIPANT_ASSISTANT);
        wc.addClause(")");
      }
    } else if(related != null) {
      if(related.isEmpty()) {
        wc.addClause("where 1=2");
      } else {
        wc.addClause("where (");
        wc.addClause("participant.idContact in (:idContact)");
        wc.addNamedValue("idContact", new SetOf<IContact, String>(related, new ItemOf<IContact, String>() {
          @Override
          public String getFrom(IContact e) {
            return e.getId();
          }
        }));
        wc.addClause("and (participant.role = :cpdrole1 or participant.role = :cpdrole2)");
        wc.addNamedValue("cpdrole1", ParticipantRole.PARTICIPANT_OWNER);
        wc.addNamedValue("cpdrole2", ParticipantRole.PARTICIPANT_ASSISTANT);
        wc.addClause(")");
      }
    } else if(isRestricted() && !Application.getApplication().isInRole("dossier:all")) {
      IContact contact = Authentication.getIContact();
      if(contact == null || !contact.isValid()) {
        wc.addClause("where 1=2");
      } else {
        wc.addClause("where ((");
        wc.addClause("participant.idContact = :idContact");
        wc.addNamedValue("idContact", contact.getId());
        wc.addClause("and (participant.role = :cpdrole1 or participant.role = :cpdrole2)");
        wc.addNamedValue("cpdrole1", ParticipantRole.PARTICIPANT_OWNER);
        wc.addNamedValue("cpdrole2", ParticipantRole.PARTICIPANT_ASSISTANT);
        wc.addClause(")");
        CategoryResults.addParticipantAffiliance(wc, "or", contact.getId(), "dossier");
        wc.addClause(")");
      }
    } else {
      wc.addClause("where 1=1");
    }
  }
 
  private DossierType typeValue(String name) {
    return DossierType.valueOf(name);
  }
 
  private DossierStatus statusValue(String name) {
    return DossierStatus.valueOf(name);
  }
 
}