Relateds.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2022 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.related;
 
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.turro.elephant.db.ElephantPU;
import org.turro.elephant.entities.db.Related;
import org.turro.jpa.Dao;
import org.turro.sql.SqlClause;
import org.turro.util.Cached;
 
public class Relateds {
 
  public Related addOrigin(String origin, String description) {
    return add(origin, entityPath, description);
  }
 
  public Related addDestination(String destination, String description) {
    return add(entityPath, destination, description);
  }
 
  public Relateds removeOrigin(String origin) {
    return remove(origin, entityPath);
  }
 
  public Relateds removeDestination(String destination) {
    return remove(entityPath, destination);
  }
 
  public boolean existsOrigin(String origin) {
    return exists(origin, entityPath);
  }
  
  public boolean existsDestination(String destination) {
    return exists(entityPath, destination);
  }
  
  public List<Related> origins() {
    return SqlClause.select("p").from("Related p")
            .where().equal("destination", entityPath)
            .dao(dao.get())
            .resultList(Related.class);
  }
  
  public List<Related> destinations() {
    return SqlClause.select("p").from("Related p")
            .where().equal("origin", entityPath)
            .dao(dao.get())
            .resultList(Related.class);
  }
  
  /* Utils */
  
  public Related add(String origin, String destination, String description) {
    if(!exists(origin, destination)) {
      Related re = new Related();
      re.setOrigin(origin);
      re.setDestination(destination);
      re.setDescription(description);
      if(!re.isEmpty()) {
        re.setCreation(new Date());
        return dao.get().saveObject(re);
      }
    }
    return null;
  }
 
  public Relateds remove(String origin, String destination) {
    SqlClause.delete("Related")
            .where().equal("origin", origin)
            .and().equal("destination", destination)
            .dao(dao.get())
            .execute();
    return this;
  }
 
  public Relateds removeAny(String removePath) {
    SqlClause.delete("Related")
            .where().equal("origin", removePath)
            .or().equal("destination", removePath)
            .dao(dao.get())
            .execute();
    return this;
  }
  
  public boolean exists(String origin, String destination) {
    return SqlClause.count().from("Related")
            .where().equal("origin", origin)
            .and().equal("destination", destination)
            .dao(dao.get())
            .singleResult(Long.class) > 0;
  }
 
  public boolean existsAny(String existPath) {
    return SqlClause.count().from("Related")
            .where().equal("origin", existPath)
            .or().equal("destination", existPath)
            .dao(dao.get())
            .singleResult(Long.class) > 0;
  }
 
  public static Set<String> getAllPaths(String root) {
    Set<String> all = new HashSet<>(
            SqlClause.select("distinct origin").from("Related")
            .where().startsWith("origin", "/" + root + "/")
            .dao(new ElephantPU())
            .resultList(String.class));
    all.addAll(
            SqlClause.select("distinct destination").from("Related")
            .where().startsWith("destination", "/" + root + "/")
            .dao(new ElephantPU())
            .resultList(String.class));
    return all;
  }
 
  /* Dao */
  
  private Cached<Dao> dao = Cached.instance(() -> new ElephantPU());
  
  /* Factory */
  
  public static Relateds from(String entityPath) {
    return new Relateds(entityPath);
  }
  
  public static Relateds empty() {
    return new Relateds(null);
  }
  
  private final String entityPath;
 
  private Relateds(String entityPath) {
    this.entityPath = entityPath;
  }
  
}