DossierContentIterator.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2018 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.content;
 
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import org.turro.string.Strings;
import org.turro.attach.www.AttachCtrl;
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.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.IssueResolution;
import org.turro.dossier.entity.IssueStatus;
import org.turro.dossier.entity.IssueType;
import org.turro.dossier.entity.ParticipantRole;
import org.turro.dossier.search.CategoryResults;
import org.turro.dossier.www.CategoriesTree;
import org.turro.dossier.www.KnowledgeBaseDashboard;
import org.turro.dossier.www.PhaseHtmlFilter;
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.content.EntityDaoContentIterator;
import org.turro.jpa.search.DaoHtmlSearch;
import org.turro.jpa.search.DaoSearchKey;
import org.turro.marker.ElephantMarker;
import org.turro.phase.PhaseDefinitions;
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 DossierContentIterator extends EntityDaoContentIterator<Dossier, Long>  {
 
  private String 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 DossierContentIterator(IConstructor constructor, Writer writer, IContact contact, boolean mail, String pubPath) {
    super(new DossierPU(), constructor, writer, contact, mail, pubPath);
    this.all = contact.getPermissions().isInRole("dossier:all");
  }
 
  public void setCategoryId(long categoryId) {
    this.categoryId = categoryId;
  }
 
  public void setDossierId(long dossierId) {
    this.dossierId = dossierId;
  }
 
  public 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 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;
  }
 
  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;
  }
 
  @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(getContact())
          .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;
  }
 
  @Override
  protected void renderSummary(ElephantMarker marker, Dossier e, int page) {
    if(e != null) {
      marker.put("dossier", e);
      if(e.getCategory() != null) {
        marker.put("newCategory", e.getCategory().getId() != lastCategoryId);
        lastCategoryId = e.getCategory().getId();
      } else {
        lastCategoryId = 0;
      }
      prepareValues(e, page);
      marker.put("restricted", isRestricted());
    }
    marker.process(getTemplateRoot(), getSummaryTemplate(), getWriter());
  }
 
  @Override
  protected void renderItem(ElephantMarker marker, Dossier e, int page) {
    marker.put("dossier", e);
    prepareValues(e, page);
    marker.put("restricted", isRestricted());
    marker.process(getTemplateRoot(), getFullTemplate(), getWriter());
  }
 
  @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(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 = Integer.valueOf(phf.getPhase());
          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)) {
      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", getContact().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 (");
      String sep = "";
      for(String s : dossierTypes) {
        DossierType dt = DossierType.valueOf(s);
        if(dt != null) {
          String par = "type" + wc.getUniqueSuffix();
          wc.addClause(sep + "dossier.type = :" + par);
          wc.addNamedValue(par, dt);
          sep = " or ";
        }
      }
      wc.addClause(")");
    }
    if(dossierStatus != null && dossierStatus.size() > 0) {
      wc.addClause("and (");
      String sep = "";
      for(String s : dossierStatus) {
        DossierStatus ds = DossierStatus.valueOf(s);
        if(ds != null) {
          String par = "status" + wc.getUniqueSuffix();
          wc.addClause(sep + "dossier.status = :" + par);
          wc.addNamedValue(par, ds);
          sep = " or ";
        }
      }
      wc.addClause(")");
    }
    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 || e.getFullParticipants().isParticipant(getContact());
    } 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) {   
    prepareControls(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(dossier.getFullParticipants().isShowAllIssues(getContact())) {
      marker.put("issuePath", ElephantContext.getRootWebPath() + "/user/kbase");
    }
    
    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("projectContext", new ProjectContext());
    //marker.put("visual", new ProjectVisualElements(dossier));
    marker.put("dve", DossierVisualElements.load());
    
  }
  
  @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);
    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) {
      if(getContact() == null || !getContact().isValid()) {
        wc.addClause("where 1=2");
      } else {
        wc.addClause("where (");
        wc.addClause("participant.idContact = :idContact");
        wc.addNamedValue("idContact", getContact().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")) {
      if(getContact() == null || !getContact().isValid()) {
        wc.addClause("where 1=2");
      } else {
        wc.addClause("where ((");
        wc.addClause("participant.idContact = :idContact");
        wc.addNamedValue("idContact", getContact().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", getContact().getId(), "dossier");
        wc.addClause(")");
      }
    } else {
      wc.addClause("where 1=1");
    }
  }
 
  @Override
  protected String getTemplateRoot() {
    return isMail() ? "content/newsletter/sections/dossiers" : "dossier";
  }
 
  @Override
  protected Object doVotesCtrl(Dossier e) {
    return Entities.getController(e).configureCtrl(
            new VoteItCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doInterestCtrl(Dossier e) {
    return Entities.getController(e).configureCtrl(
            new StarItCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doCommentsCtrl(Dossier e) {
    return Entities.getController(e).configureCtrl(
            new CommentItCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doAttachmentsCtrl(Dossier e) {
    return Entities.getController(e).configureCtrl(
            new AttachCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doFilesCtrl(Dossier e) {
    return Entities.getController(e).configureCtrl(
            new FileAttach(DossierPU.getObjectPath(e)), getContact());
  }
 
  @Override
  protected Object doDescriptionsCtrl(Dossier e) {
    return Entities.getController(e).configureCtrl(
            new DescribeItCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doPollsCtrl(Dossier e) {
    return Entities.getController(e).configureCtrl(
            new PollsCtrl(constructor), getContact());
  }
 
  @Override
  protected String getItemLink(Dossier dossier) {
    if(getContextPath() == null) {
      String link = dossier.getDossierURL();
      if(link != null) {
        return ElephantContext.getRootWebPath() + link;
      }
    }    
    return doItemLink(dossier, dossier.getId(), true);
  }
 
  @Override
  protected String getReadAllLink() {
    String path = getContextPath();
    if(Strings.isBlank(path)) {
      path = ElephantContext.getEntityWebContext("/" + getTypePath());
    }
    if(Strings.isBlank(path)) {
      return getRestrictedLink();
    }
    return path;
  }
 
  @Override
  protected String getRestrictedLink() {
    return "/user/my" + getTypePath() + "s";
  }
 
  private String getTypePath() {
    if(dossierTypes != null && dossierTypes.size() == 1 && 
            dossierTypes.contains(DossierType.TYPE_PROJECT.toString())) {
      return "project";
    } else {
      return "dossier";
    }
  }
  
}