SkillTags.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.skills.tags;
 
import java.util.ArrayList;
import java.util.Collections;
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.elephant.db.ElephantPU;
import org.turro.elephant.db.WhereClause;
import org.turro.elephant.entities.db.SkillType;
import org.turro.entities.Entities;
import org.turro.jpa.Dao;
import org.turro.path.Path;
import org.turro.util.Arrays;
 
public class SkillTags {
 
  public static SkillSet getAvailables(String root) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.skills.tags.SkillItem(t.skill, t.type, count(t))");
    wc.addClause("from Skill t");
    wc.addIn("where", "t.type", Arrays.asList(SkillType.values()));
    if(!Strings.isBlank(root)) {
      wc.addClause("and t.entityPath like concat('/', :root, '/%')");
      wc.addNamedValue("root", root);
    }
    wc.addClause("group by t.skill, t.type");
    return new SkillSet(dao.getResultList(wc));
  }
  
  public static SkillSet getAvailables(String root, boolean user) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.skills.tags.SkillItem(t.skill, t.type, count(t))");
    wc.addClause("from Skill t");
    wc.addIn("where", "t.type", new ArrayList(user ? SkillType.getNaturals() : SkillType.getJuridicals()));
    if(!Strings.isBlank(root)) {
      wc.addClause("and t.entityPath like concat('/', :root, '/%')");
      wc.addNamedValue("root", root);
    }
    wc.addClause("group by t.skill, t.type");
    return new SkillSet(dao.getResultList(wc));
  }
  
  public static SkillSet getSiblings(String root, Set<String> skillNames) {
    Dao dao = new ElephantPU();
    SkillSet finalSet = null;
    for(String tag : skillNames) {
      SkillSet set = getSiblings(dao, root, tag);
      if(finalSet != null) {
        finalSet.retainAll(set);
      } else {
        finalSet = set;
      }
    }
    return Optional.ofNullable(finalSet).orElseGet(() -> SkillSet.empty());
  }
  
  private static SkillSet getSiblings(Dao dao, String root, String skillName) {
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.skills.tags.SkillItem(t.skill, t.type, count(t))");
    wc.addClause("from Skill t");
    wc.addClause("join Skill t1 on t.entityPath = t1.entityPath");
    wc.addClause("where t.skill <> :skill");
    wc.addClause("and t1.skill = :skill");
    wc.addNamedValue("skill", skillName);
    if(!Strings.isBlank(root)) {
      wc.addClause("and t.entityPath like concat('/', :root, '/%')");
      wc.addNamedValue("root", root);
    }
    wc.addClause("group by t.skill, t.type");
    return new SkillSet(dao.getResultList(wc));
  }
  
  public static List<String> getIdentifiers(String root, Set<SkillItem> set) {
    return getIdentifiers(new ElephantPU(), root, set);
  }
  
  public static List<String> getIdentifiers(Dao dao, String root, Set<SkillItem> set) {
    return getEntityPaths(dao, root, set).stream().map(s -> Path.getIdentifier(s)).collect(Collectors.toList());
  }
  
  public static List<String> getEntityPaths(String root, Set<SkillItem> set) {
    return getEntityPaths(new ElephantPU(), root, set);
  }
  
  public static List<String> getEntityPaths(Dao dao, String root, Set<SkillItem> set) {
    List<String> skills = set.stream().map(t -> t.getSkillName()).collect(Collectors.toList());
    if(!skills.isEmpty()) {
      WhereClause wc = new WhereClause();
      wc.addClause("select distinct t.entityPath from Skill 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 skill : skills) {
        wc.addClause("and exists (");
        wc.addClause("select t2.entityPath from Skill t2");
        wc.addClause("where t2.entityPath = t.entityPath");
        wc.addClause("and t2.skill = :skill" + count);
        wc.addNamedValue("skill" + count, skill);
        wc.addClause(")");
        count++;
      }
      return dao.getResultList(String.class, wc);
    }
    return Collections.EMPTY_LIST;
  }
  
  public static SkillSet getSkills(Object entity) {
    return getSkills(Entities.getController(entity).getPath());
  }
  
  public static SkillSet getSkills(String entityPath) {
    Dao dao = new ElephantPU();
    WhereClause wc = new WhereClause();
    wc.addClause("select new org.turro.skils.tags.SkillItem(t.skill, t.type, count(t))");
    wc.addClause("from Skill t");
    wc.addClause("where t.entityPath = :path");
    wc.addNamedValue("path", entityPath);
    wc.addClause("group by t.skill, t.type");
    return new SkillSet(dao.getResultList(wc));
  }
  
  private SkillTags() {}
  
}