DirectoryContentIterator.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2021 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.contacts.content;
 
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.turro.string.Strings;
import org.turro.attach.www.AttachCtrl;
import org.turro.collections.ExpressionSet;
import org.turro.contacts.Contact;
import org.turro.contacts.ContactType;
import org.turro.contacts.db.ContactsPU;
import org.turro.contacts.profile.ProfileContext;
import org.turro.contacts.relation.FuzzyRelationTypes;
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.security.IUser;
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.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.plugin.contacts.IContact;
import org.turro.polls.PollsCtrl;
import org.turro.skills.tags.SkillCloud;
import org.turro.skills.tags.SkillSet;
import org.turro.skills.tags.SkillTags;
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 DirectoryContentIterator extends EntityDaoContentIterator<Contact, String>  {
  
  private Set<DirectoryType> types;
  private ExpressionSet syndications;
  private List<String> contactIds;
 
  public DirectoryContentIterator(IConstructor constructor, Writer writer, IContact contact, boolean mail, String contextPath) {
    super(new ContactsPU(), constructor, writer, contact, mail, contextPath);
  }
 
  public Set<DirectoryType> getTypes() {
    return types;
  }
 
  public void setTypes(Set<DirectoryType> types) {
    this.types = types;
  }
 
  public void setTypes(String types) {
    String type[] = types.split("\\s*,\\s*");
    Set<DirectoryType> set = new HashSet<>();
    for(int i = 0; i < type.length; i++) {
      if("typed".equals(type[i])) {
        set.addAll(EnumSet.complementOf(EnumSet.of(DirectoryType.DIRECTORY_SINGLETONS)));
      } else if("companies".equals(type[i])) {
        set.add(DirectoryType.DIRECTORY_COMPANIES);
      } else if("centers".equals(type[i])) {
        set.add(DirectoryType.DIRECTORY_CENTERS);
      } else if("professionals".equals(type[i])) {
        set.add(DirectoryType.DIRECTORY_PROFESSIONALS);
      } else if("educators".equals(type[i])) {
        set.add(DirectoryType.DIRECTORY_EDUCATORS);
      } else if("students".equals(type[i])) {
        set.add(DirectoryType.DIRECTORY_STUDENTS);
      } else if("singletons".equals(type[i])) {
        set.add(DirectoryType.DIRECTORY_SINGLETONS);
      }
    }
    setTypes(set);
  }
 
  public void setSyndications(List<String> syndications) {
    this.syndications = new ExpressionSet(syndications);
  }
 
  public void setSyndications(String syndications) {
    if(!Strings.isBlank(syndications)) {
      this.syndications = new ExpressionSet(Strings.csvToList(syndications));
    }
  }
 
  public void setContactIds(List<String> contactIds) {
    this.contactIds = contactIds;
  }
 
  public SkillSet getCloudSkills() {
    return canShowSkills() ? SkillCloud.getSkills(constructor, entityRoot(), isUserType()) : null;
  }
  
  public SkillSet getEntitySkills(Object entity) {
    return SkillTags.getSkills(entity);
  }
  
  @Override
  protected WhereClause getWhereClause() {
    WhereClause wc = new WhereClause();
    wc.addClause("select distinct contact from Contact contact");
    wc.addClause("left outer join contact.connectors connector on connector.description = :trade");
    wc.addClause("left outer join contact.businessRelations relation");
    wc.addClause("left outer join relation.business business");
    wc.addClause("left outer join business.connectors bconnector on bconnector.description = :trade");
    wc.addNamedValue("trade", IUser.CONNECTOR_TRADE);
    if(syndications != null && !syndications.isEmpty()) {
      wc.addClause("left outer join contact.syndications syndication");
    }
    return Statistics.load(constructor, "ContactRanking", "HomonymsMatching", wc)
          .allowMatching(isAllowMatching())
          .allowRanking(isAllowRanking())
          .doMatching(isDoMatching())
          .setContact(getContact())
          .setEntityFields("contact", "id")
          .setDefaultSorting("contact.name")
          .onCriteria(w -> addCriteria(w))
          .getClause();
  }
 
  @Override
  protected WhereClause getCountClause() {
    WhereClause wc = new WhereClause();
    wc.addClause("select count(distinct contact) from Contact contact");
    wc.addClause("left outer join contact.connectors connector on connector.description = :trade");
    wc.addClause("left outer join contact.businessRelations relation");
    wc.addClause("left outer join relation.business business");
    wc.addClause("left outer join business.connectors bconnector on bconnector.description = :trade");
    wc.addNamedValue("trade", IUser.CONNECTOR_TRADE);
    if(syndications != null && !syndications.isEmpty()) {
      wc.addClause("left outer join contact.syndications syndication");
    }
    addCriteria(wc);
    return wc;
  }
 
  @Override
  protected void renderSummary(ElephantMarker marker, Contact e, int page) {
    if(e != null) {
      marker.put("contact", e);
      prepareValues(e, page);
    }
    marker.process(getTemplateRoot(), getSummaryTemplate(), getWriter());
  }
 
  @Override
  protected void renderItem(ElephantMarker marker, Contact e, int page) {
    marker.put("contact", e);
    prepareValues(e, page);
    marker.process(getTemplateRoot(), getFullTemplate(), getWriter());
  }
 
  @Override
  protected String entityRoot() {
    return "contact";
  }
 
  @Override
  protected Contact entity(String value) {
    WhereClause wc = new WhereClause();
    wc.addClause("select distinct contact from Contact contact");
    wc.addClause("left outer join contact.connectors connector on connector.description = :trade");
    wc.addClause("left outer join contact.businessRelations relation");
    wc.addClause("left outer join relation.business business");
    wc.addClause("left outer join business.connectors bconnector on bconnector.description = :trade");
    wc.addNamedValue("trade", IUser.CONNECTOR_TRADE);
    if(syndications != null && !syndications.isEmpty()) {
      wc.addClause("left outer join contact.syndications syndication");
    }
    addCriteria(wc);
    wc.addClause("and contact.id = :id");
    wc.addNamedValue("id", value);
    return (Contact) dao.getSingleResultOrNull(wc);
  }
  
  private void addCriteria(WhereClause wc) {
    wc.addClause("where contact.type <> :type");
    wc.addClause("and (business is null or business.type <> :type)");
    wc.addNamedValue("type", ContactType.CONTACT_INTERNAL);
    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.asList(new String[] { 
            "contact.name", "business.name", "connector.value", "bconnector.value" }), false);
        }
      }
    }
    if(types != null && !types.isEmpty()) {
      String sep = "";
      Date now = new Date();
      wc.addClause("and (");
      if(isSingleton()) {
        FuzzyRelationTypes.isSingleton(wc, "", "contact", "relation");
      } else if(isTyped()) {
        FuzzyRelationTypes.isTyped(wc, "", "relation");
      } else {
        if(isJuridical()) {
          FuzzyRelationTypes.isJuridical(wc, "", "contact");
        } else {
          if(isCompanies()) {
            wc.addClause(sep + "contact.type = :ctype");
            wc.addNamedValue("ctype", ContactType.CONTACT_COMPANY);
            sep = "or ";
          }
          if(isCenters()) {
            wc.addClause(sep + "contact.type = :ltype");
            wc.addNamedValue("ltype", ContactType.CONTACT_LEARNINGCENTER);
            sep = "or ";
          }
        }
        if(isNatural()) {
          wc.addClause(sep + "(");
          FuzzyRelationTypes.isNatural(wc, "", "relation");
          wc.addClause("and (relation.startDate is null or relation.startDate <= :now)");
          wc.addClause("and (relation.endDate is null or relation.endDate >= :now))");
          wc.addNamedValue("now", now);
          sep = "or ";
        } else {
          if(isWorkers()) {
            wc.addClause(sep + "(");
            FuzzyRelationTypes.isWorker(wc, "", "relation");
            wc.addClause("and (relation.startDate is null or relation.startDate <= :now)");
            wc.addClause("and (relation.endDate is null or relation.endDate >= :now))");
            wc.addNamedValue("now", now);
            sep = "or ";
          } else {
            if(isProfessionals()) {
              wc.addClause(sep + "(");
              FuzzyRelationTypes.isProfessional(wc, "", "relation");
              wc.addClause("and (relation.startDate is null or relation.startDate <= :now)");
              wc.addClause("and (relation.endDate is null or relation.endDate >= :now))");
              wc.addNamedValue("now", now);
              sep = "or ";
            }
            if(isEducators()) {
              wc.addClause(sep + "(");
              FuzzyRelationTypes.isEducator(wc, "", "relation");
              wc.addClause("and (relation.startDate is null or relation.startDate <= :now)");
              wc.addClause("and (relation.endDate is null or relation.endDate >= :now))");
              wc.addNamedValue("now", now);
              sep = "or ";
            }
          }
          if(isStudents()) {
            wc.addClause(sep + "(");
            FuzzyRelationTypes.isStudent(wc, "", "relation");
            wc.addClause("and (relation.startDate is null or relation.startDate <= :now)");
            wc.addClause("and (relation.endDate is null or relation.endDate >= :now))");
            wc.addNamedValue("now", now);
            sep = "or ";
          }
        }
      }
      wc.addClause(")");
    }
    if(isOnlyStudents()) {
      if(syndications == null) {
        syndications = new ExpressionSet(loadNegativesFrom(ProfileContext.getNetworkingRoles()));
      } else {
        syndications.addAll(loadNegativesFrom(ProfileContext.getNetworkingRoles()));
      }
      syndications.add("!brightside_admin");
    }
    if(syndications != null && !syndications.isEmpty()) {
      if(syndications.hasPositives()) {
        wc.addIn("and", "syndication.name", syndications.getPositives());
      }
      if(syndications.hasNegatives()) {
        wc.addClause("and not exists (select s from Syndication s");
        wc.addIn("where", "s.name", syndications.getNegatives());
        wc.addClause("and s.contact = contact)");
      }
    }
    if(contactIds != null && !contactIds.isEmpty()) {
      wc.addIn("and", "contact.id", contactIds);
    }
    if(SkillCloud.hasSelected(constructor, "contact", isUserType())) {
      wc.addIn("and", "contact.id", SkillCloud.getIdentifiers(constructor, "contact", isUserType()));
    }
  }
 
  @Override
  protected boolean isValid(Contact e) {
    return super.isValid(e);
  }
 
  private void prepareValues(final Contact e, int page) {   
    prepareControls(e, page);
    marker.put("profile", e.getProfile());
  }
 
  @Override
  protected String title(Contact e) {
    if(!Strings.isBlank(e.getName())) {
      return e.getName();
    }
    return null;
  }
 
  @Override
  protected Collection<String> metas(Contact e) {
    ArrayList<RepositoryFile> files = new ArrayList<>();
    String path = getItemLink(e);
    if(!SocialImageMap.hasImage(path)) {
      FileAttach fa = new FileAttach(ContactsPU.getObjectPath(e));
      Repository repository = fa.getPublishableRepository(constructor);
      files.addAll(repository.getRepositoryFiles("*_social.png,*_social.jpg"));
      files.addAll(repository.getRepositoryFiles("*.png,*.jpg"));
    }
    SocialNet sn;
    sn = new SocialNet(path, e.getName(), e.getName(), files);
    return sn.getMetas();
  }
 
  @Override
  protected String getTemplateRoot() {
    return isMail() ? "content/newsletter/sections/directory" : "directory";
  }
 
  @Override
  protected Object doVotesCtrl(Contact e) {
    return Entities.getController(e).configureCtrl(
            new VoteItCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doInterestCtrl(Contact e) {
    return Entities.getController(e).configureCtrl(
            new StarItCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doCommentsCtrl(Contact e) {
    return Entities.getController(e).configureCtrl(
            new CommentItCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doAttachmentsCtrl(Contact e) {
    return Entities.getController(e).configureCtrl(
            new AttachCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doFilesCtrl(Contact e) {
    return Entities.getController(e).configureCtrl(
            new FileAttach(ContactsPU.getObjectPath(e)), getContact());
  }
 
  @Override
  protected Object doDescriptionsCtrl(Contact e) {
    return Entities.getController(e).configureCtrl(
            new DescribeItCtrl(constructor), getContact());
  }
 
  @Override
  protected Object doPollsCtrl(Contact e) {
    return Entities.getController(e).configureCtrl(
            new PollsCtrl(constructor), getContact());
  }
 
  @Override
  protected String getItemLink(Contact e) {
    return doItemLink(e, e.getId(), true);
  }
 
  @Override
  protected String getReadAllLink() {
    String path = getContextPath();
    if(Strings.isBlank(path)) {
      path = ElephantContext.getEntityWebContext("/directory");
    }
    if(Strings.isBlank(path)) {
      return getRestrictedLink();
    }
    return path;
  }
 
  @Override
  protected String getRestrictedLink() {
    return "/user/profile";
  }
  
  /* Types */
  
  private boolean isTyped() {
    return types.contains(DirectoryType.DIRECTORY_COMPANIES) &&
           types.contains(DirectoryType.DIRECTORY_PROFESSIONALS) &&
           types.contains(DirectoryType.DIRECTORY_CENTERS) &&
           types.contains(DirectoryType.DIRECTORY_EDUCATORS) &&
           types.contains(DirectoryType.DIRECTORY_STUDENTS);
  }
  
  private boolean isJuridical() {
    return types.contains(DirectoryType.DIRECTORY_COMPANIES) &&
           types.contains(DirectoryType.DIRECTORY_CENTERS);
  }
  
  private boolean isNatural() {
    return types.contains(DirectoryType.DIRECTORY_PROFESSIONALS) &&
           types.contains(DirectoryType.DIRECTORY_EDUCATORS) &&
           types.contains(DirectoryType.DIRECTORY_STUDENTS);
  }
  
  private boolean isCompanies() {
    return types.contains(DirectoryType.DIRECTORY_COMPANIES);
  }
  
  private boolean isCenters() {
    return types.contains(DirectoryType.DIRECTORY_CENTERS);
  }
  
  private boolean isWorkers() {
    return types.contains(DirectoryType.DIRECTORY_PROFESSIONALS) &&
           types.contains(DirectoryType.DIRECTORY_EDUCATORS);
  }
  
  private boolean isProfessionals() {
    return types.contains(DirectoryType.DIRECTORY_PROFESSIONALS);
  }
  
  private boolean isEducators() {
    return types.contains(DirectoryType.DIRECTORY_EDUCATORS);
  }
  
  private boolean isStudents() {
    return types.contains(DirectoryType.DIRECTORY_STUDENTS);
  }
  
  private boolean isOnlyStudents() {
    return EnumSet.of(DirectoryType.DIRECTORY_STUDENTS).equals(types);
  }
  
  private boolean isSingleton() {
    return types.contains(DirectoryType.DIRECTORY_SINGLETONS);
  }
 
  private boolean canShowSkills() {
    return isNatural() ^ isJuridical();
  }
  
  private boolean isUserType() {
    return types == null || isNatural();
  }
 
  private List<String> loadNegativesFrom(String networkingRoles) {
    return Strings.extractAll(networkingRoles, "\\@([a-zA-Z0-9]+):on")
            .stream().map(s -> "!" + s).collect(Collectors.toList());
  }
 
}