Tags.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.tags;
 
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import org.turro.string.Strings;
import org.turro.action.Plugins;
import org.turro.elephant.db.ElephantPU;
import org.turro.elephant.db.WhereClause;
import org.turro.elephant.entities.db.Tag;
import org.turro.elephant.entities.db.TagPK;
import org.turro.entities.Entities;
import org.turro.jpa.Dao;
import org.turro.path.Path;
import org.turro.sql.SqlClause;
import org.turro.util.PhraseBuilder;
 
public class Tags {
 
  public static TagSet search(String root, String value, int max) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.tags.TagItem(t.tagName, count(t))");
    wc.addClause("from Tag t");
    wc.addClause("where t.entityPath like '/contact/%'");
    if(!Strings.isBlank(root)) {
      wc.addClause("and t.entityPath like concat('/', :root, '/%')");
      wc.addNamedValue("root", root);
    }
    if(!Strings.isBlank(value)) {
      wc.addLikeFields(new String[]{ "t.tagName" }, value.toString());
    }
    wc.addClause("group by t.tagName");
    wc.addClause("order by t.tagName");
    return new TagSet(dao.getResultList(wc, max));
  }
  
  public static TagSet getAvailables() {
    return getAvailables(null);
  }
  
  public static TagSet getAvailables(String root) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.tags.TagItem(t.tagName, count(t))");
    wc.addClause("from Tag t");
    if(!Strings.isBlank(root)) {
      wc.addClause("where t.entityPath like concat('/', :root, '/%')");
      wc.addNamedValue("root", root);
    }
    wc.addClause("group by t.tagName");
    return new TagSet(dao.getResultList(wc));
  }
  
  public static TagSet getSiblings(Set<String> tagNames) {
    return getSiblings(null, tagNames);
  }
  
  public static TagSet getSiblings(String root, Set<String> tagNames) {
    Dao dao = new ElephantPU();
    TagSet finalSet = null;
    for(String tag : tagNames) {
      TagSet set = getSiblings(dao, root, tag);
      if(finalSet != null) {
        finalSet.retainAll(set);
      } else {
        finalSet = set;
      }
    }
    return Optional.ofNullable(finalSet).orElseGet(() -> TagSet.empty());
  }
  
  private static TagSet getSiblings(Dao dao, String root, String tagName) {
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.tags.TagItem(t.tagName, count(t))");
    wc.addClause("from Tag t");
    wc.addClause("join Tag t1 on t.entityPath = t1.entityPath");
    wc.addClause("where t.tagName <> :tag");
    wc.addClause("and t1.tagName = :tag");
    wc.addNamedValue("tag", tagName);
    if(!Strings.isBlank(root)) {
      wc.addClause("and t.entityPath like concat('/', :root, '/%')");
      wc.addNamedValue("root", root);
    }
    wc.addClause("group by t.tagName");
    return new TagSet(dao.getResultList(wc));
  }
  
  public static List<TagItem> getAsItemFrom(String entityPath) {
    return getFrom(entityPath).stream().map(s -> new TagItem(s.getTagName(), 0)).collect(Collectors.toList());
  }
  
  public static List<Tag> getFrom(String entityPath) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select t from Tag t");
    wc.addClause("where t.entityPath = :path");
    wc.addNamedValue("path", entityPath);
    wc.addClause("order by t.tagName");
    return dao.getResultList(wc);
  }
  
  public static List<Tag> getFromRoot(String root) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select t from Tag t");
    wc.addClause("where t.entityPath like :path");
    wc.addNamedValue("path", root + "%");
    wc.addClause("order by t.tagName");
    return dao.getResultList(wc);
  }
  
  public static boolean existsTag(String tagName) {
    Dao dao = new ElephantPU();
    return ((Long) dao.getSingleResult(
            " select count(*) from Tag " +
            " where tagName = ?",
            new Object[] { tagName }
            )) > 0;
  }
  
  public static void setTags(Object entity, String tags) {
    setTags(Entities.getController(entity).getPath(), tags);
  }
  
  public static void setTags(String entityPath, String tags) {
    if(Strings.isBlank(tags)) {
      removeTags(entityPath);
    } else {
      setTags(entityPath, Arrays.asList(tags.split("\\s*,\\s*")));
    }
  }
  
  public static void setTags(Object entity, Collection<String> tags) {
    setTags(Entities.getController(entity).getPath(), tags);
  }
  
  public static void setTags(String entityPath, Collection<String> tags) {
    if(tags == null || tags.isEmpty()) {
      removeTags(entityPath);
    } else {
      removeTags(entityPath);
      for(String tag : tags) {
        addTag(entityPath, tag);
      }
    }
  }
  
  public static boolean hasTag(Object entity, String tagName) {
    return hasTag(Entities.getController(entity).getPath(), tagName);
  } 
 
  public static boolean hasTag(String entityPath, String tagName) {
    return hasTag(new ElephantPU(), entityPath, tagName);
  }
  
  public static boolean hasTag(Dao dao, String entityPath, String tagName) {
    return getTag(dao, entityPath, tagName) != null;
  }
  
  public static void addTag(Object entity, String tagName) {
    addTag(Entities.getController(entity).getPath(), tagName);
  }
  
  public static void addTag(String entityPath, String tagName) {
    Dao dao = new ElephantPU();
    if(!hasTag(dao, entityPath, tagName)) {
      Tag tag = new Tag();
      tag.setEntityPath(entityPath);
      tag.setTagName(tagName);
      if(!tag.isEmpty()) dao.saveObject(tag);
    }
  }
  
  public static void changeTag(String entityPath, String oldName, String newName) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("update Tag");
    wc.addClause("set tagName = :newtag");
    wc.addNamedValue("newtag", newName);
    wc.addClause("where entityPath = :path");
    wc.addNamedValue("path", entityPath);
    wc.addClause("and tagName = :oldtag");
    wc.addNamedValue("oldtag", oldName);
    dao.executeUpdate(wc);
  }
  
  public static void removeTag(Object entity, String tagName) {
    removeTag(Entities.getController(entity).getPath(), tagName);
  }
  
  public static void removeTag(String entityPath, String tagName) {
    Dao dao = new ElephantPU();
    Tag tag = getTag(dao, entityPath, tagName);
    if(tag != null) {
      dao.deleteObject(tag);
    }
  }
  
  public static Tag getTag(Dao dao, String entityPath, String tagName) {
    TagPK tagPk = new TagPK();
    tagPk.setEntityPath(entityPath);
    tagPk.setTagName(tagName);
    return dao.find(Tag.class, tagPk);
  }
 
  public static List<String> getIdentifiers(String root, Set<TagItem> set) {
    return getIdentifiers(new ElephantPU(), root, set);
  }
  
  public static List<String> getIdentifiers(Dao dao, String root, Set<TagItem> set) {
    return getEntityPaths(dao, root, set).stream().map(s -> Path.getIdentifier(s)).collect(Collectors.toList());
  }
  
  public static List<String> getEntityPaths(String root, Set<TagItem> set) {
    return getEntityPaths(new ElephantPU(), root, set);
  }
  
  public static List<String> getEntityPaths(Dao dao, String root, Set<TagItem> set) {
    List<String> tags = set.stream().map(t -> t.getTagName()).collect(Collectors.toList());
    if(!tags.isEmpty()) {
      WhereClause wc = new WhereClause();
      wc.addClause("select distinct t.entityPath from Tag t");
      wc.addClause("where 1=1");
      if(!Strings.isBlank(root)) {
        wc.addClause("and t.entityPath like concat('/', :root, '/%')");
        wc.addNamedValue("root", root);
      }
      int count = 0;
      for(String tag : tags) {
        wc.addClause("and exists (");
        wc.addClause("select t2.entityPath from Tag t2");
        wc.addClause("where t2.entityPath = t.entityPath");
        wc.addClause("and t2.tagName = :tag" + count);
        wc.addNamedValue("tag" + count, tag);
        wc.addClause(")");
        count++;
      }
      return dao.getResultList(String.class, wc);
    }
    return Collections.EMPTY_LIST;
  }
  
  public static List<String> getIdentifiers(Dao dao, String root, List<TagSet> sets) {
    return getEntityPaths(dao, root, sets).stream().map(s -> Path.getIdentifier(s)).collect(Collectors.toList());
  }
 
  public static List<String> getEntityPaths(String root, List<TagSet> sets) {
    return getEntityPaths(new ElephantPU(), root, sets);
  }
  
  public static List<String> getEntityPaths(Dao dao, String root, List<TagSet> sets) {
    WhereClause wc = new WhereClause();
    wc.addClause("select distinct t.entityPath from Tag t");
    wc.addClause("where 1=1");
    if(!Strings.isBlank(root)) {
      wc.addClause("and t.entityPath like concat('/', :root, '/%')");
      wc.addNamedValue("root", root);
    }
    addResultCriteria(wc, sets);
    return dao.getResultList(String.class, wc);
  }
 
  public static void addResultCriteria(WhereClause wc, List<TagSet> sets) {
    wc.addClause("and (");
    String orSep = "";
    int count = 0;
    for(Set<TagItem> set : sets) {
      wc.addClause(orSep + "(");
      String andSep = "";
      List<String> tags = set.stream().map(t -> t.getTagName()).collect(Collectors.toList());
      if(!tags.isEmpty()) {
        for(String tag : tags) {
          wc.addClause(andSep + "exists (");
          wc.addClause("select t2.entityPath from Tag t2");
          wc.addClause("where t2.entityPath = t.entityPath");
          wc.addClause("and t2.tagName = :tag" + count);
          wc.addNamedValue("tag" + count, tag);
          wc.addClause(")");
          count++;
          andSep = "and ";
        }
      }
      wc.addClause(")");
      orSep = "or ";
    }
    wc.addClause(")");
  }
 
  public static List<String> getCommonIdentifiers(String source, String rootTarget) {
    return getCommonEntityPaths(source, rootTarget).stream().map(s -> Path.getIdentifier(s)).collect(Collectors.toList());
  }
 
  public static List<Long> getCommonLongIdentifiers(String source, String rootTarget) {
    return getCommonEntityPaths(source, rootTarget).stream().map(s -> Path.getLongIdentifier(s)).collect(Collectors.toList());
  }
 
  public static List<String> getCommonEntityPaths(String source, String rootTarget) {
    return getCommonEntityPaths(new ElephantPU(), source, rootTarget);
  }
  
  public static List<String> getCommonIdentifiers(Dao dao, String source, String rootTarget) {
    return getCommonEntityPaths(dao, source, rootTarget).stream().map(s -> Path.getIdentifier(s)).collect(Collectors.toList());
  }
 
  public static List<Long> getCommonLongIdentifiers(Dao dao, String source, String rootTarget) {
    return getCommonEntityPaths(dao, source, rootTarget).stream().map(s -> Path.getLongIdentifier(s)).collect(Collectors.toList());
  }
 
  public static List<String> getCommonEntityPaths(Dao dao, String source, String rootTarget) {
    WhereClause wc = new WhereClause();
    wc.addClause("select distinct t.entityPath from Tag t");
    wc.addClause("where t.entityPath like concat('/', :target, '/%')");
    wc.addNamedValue("target", rootTarget);
    wc.addClause("and exists (");
    wc.addClause("select t2.entityPath from Tag t2");
    wc.addClause("where t2.entityPath = :source");
    wc.addNamedValue("source", source);
    wc.addClause("and t2.tagName = t.tagName");
    wc.addClause(")");
    return dao.getResultList(String.class, wc);
  }
 
  public static TagSet getTags(Object entity) {
    return getTags(Entities.getController(entity).getPath());
  }
  
  public static TagSet getTags(String entityPath) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.tags.TagItem(t.tagName, count(t))");
    wc.addClause("from Tag t");
    wc.addClause("where t.entityPath = :path");
    wc.addNamedValue("path", entityPath);
    wc.addClause("group by t.tagName");
    return new TagSet(dao.getResultList(wc));
  }
  
  public static void removeTags(Object entity) {
    removeTags(Entities.getController(entity).getPath());
  }
  
  public static void removeTags(String entityPath) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("delete from Tag");
    wc.addClause("where entityPath = :path");
    wc.addNamedValue("path", entityPath);
    dao.executeUpdate(wc);
  }
  
  public static void removeTags(String root, List<String> tags) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("delete from Tag");
    wc.addClause("where entityPath like :path");
    wc.addIn("and", "tagName", tags);
    wc.addNamedValue("path", "/" + root + "/%");
    dao.executeUpdate(wc);
  }
  
  public static void removeMemberTags(long member) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("delete from Tag");
    wc.addClause("where entityPath like :path");
    wc.addNamedValue("path", "/%/%##" + member);
    dao.executeUpdate(wc);
  }
 
  public static Collection<String> tagChoices(Object entity) {
    return tagChoices(Entities.getController(entity).getPath());
  }
  
  public static Collection<String> tagChoices(String entityPath) {
    Dao dao = new ElephantPU();
    return dao.getResultList(
            " select distinct tagName from Tag " +
            " where entityPath <> ?",
            new Object[] { entityPath }
            );
  }
 
  public static ITagCtrl getControl(Object entity) {
    if(entity == null) return null;
    ITagCtrl ctrl = Plugins.loadImplementation(ITagCtrl.class, "tag-label");
    ctrl.setEntity(entity);
    ctrl.updateControls();
    return ctrl;
  }
 
  public static String tagsString(Object entity) {
    return tagsString(Entities.getController(entity).getPath());
  }
  
  public static String tagsString(String entityPath) {
    PhraseBuilder pb = new PhraseBuilder();
    for(String tag : getTags(entityPath).getTagNames()) {
      pb.addWord(tag);
      pb.addPendingSeparator(",");
    }
    return pb.toString();
  }
  
  /* Utils */
  
  public static Set<String> getAllPaths(String root) {
    return new HashSet<>(SqlClause.select("distinct t.entityPath").from("Tag t")
            .where().startsWith("t.entityPath", "/" + root + "/")
            .dao(new ElephantPU())
            .resultList(String.class));
  }
  
  private Tags() {}
  
}