GroupIt.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2014 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;
 
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import org.turro.string.Strings;
import org.turro.contacts.db.ContactsPU;
import org.turro.fieldit.FieldItSet;
import org.turro.fieldit.FieldItUtil;
import org.turro.jpa.Dao;
 
@Entity
@org.hibernate.annotations.GenericGenerator(name = "hibernate-uuid", strategy = "uuid")
public class GroupIt implements Serializable {
 
  @Id
  @GeneratedValue(generator = "hibernate-uuid")
  @Column(name="IDENTIFIER")
  private String id;
 
  private String category;
 
  @Column(name="GROUPIT_NAME")
  private String name;
  
  private String pathName;
 
  @ManyToOne
  private GroupIt parent;
 
  private boolean publishable;
 
  public String getId() {
    return id;
  }
 
  public void setId(String id) {
    this.id = id;
  }
 
  public String getCategory() {
    return category;
  }
 
  public void setCategory(String category) {
    this.category = category;
  }
 
  public String getName() {
    return name;
  }
 
  public void setName(String name) {
    this.name = name;
  }
 
  public String getPathName() {
    return pathName;
  }
 
  public void setPathName(String pathName) {
    this.pathName = pathName;
  }
 
  public GroupIt getParent() {
    return parent;
  }
 
  public void setParent(GroupIt parent) {
    this.parent = parent;
  }
 
  public boolean isPublishable() {
    return publishable;
  }
 
  public void setPublishable(boolean publishable) {
    this.publishable = publishable;
  }
 
  /* Helpers */
  
  public boolean isValid() {
    return !Strings.isBlank(name) &&
           !name.contains("/");
  }
  
  public static Collection<String> categories() {
    Dao dao = new ContactsPU();
    return dao.getResultList(
            " select distinct g.category from GroupIt g"
            );
  }
  
  public static Collection<GroupIt> roots(String category) {
    Dao dao = new ContactsPU();
    return dao.getResultList(
            " select g from GroupIt g " +
            " where g.category = ? " +
            " and g.parent is null",
            new Object[] { category }
            );
  }
  
  public static Collection<GroupIt> roots(String category, String entityPath) {
    Dao dao = new ContactsPU();
    return dao.getResultList(
            " select g from GroupIt g " +
            " where g.category = ? " +
            " and g.parent is null " +
            " and exists ( " +
            "   select gd from Grouped gd " +
            "   where (gd.parent.pathName like concat(g.pathName, '/%') " +
            "   or gd.parent.pathName = g.pathName) " +
            "   and gd.path like ? " +
            " ) ",
            new Object[] { category, entityPath + "/%" }
            );
  }
  
  public Collection<GroupIt> children() {
    Dao dao = new ContactsPU();
    return dao.getResultList(
            " select g from GroupIt g " +
            " where g.category = ? " +
            " and g.parent = ?",
            new Object[] { this.getCategory(), this }
            );
  }
  
  public Collection<GroupIt> children(String entityPath) {
    Dao dao = new ContactsPU();
    return dao.getResultList(
            " select g from GroupIt g " +
            " where g.category = ? " +
            " and g.parent = ? " +
            " and exists ( " +
            "   select gd from Grouped gd " +
            "   where (gd.parent.pathName like concat(g.pathName, '/%') " +
            "   or gd.parent.pathName = g.pathName) " +
            "   and gd.path like ? " +
            " ) ",
            new Object[] { this.getCategory(), this, entityPath + "/%" }
            );
  }
  
  public Collection<Grouped> entities() {
    Dao dao = new ContactsPU();
    return dao.getResultList(
            " select g from Grouped g " +
            " where g.parent.category = ? " +
            " and g.parent = ?",
            new Object[] { this.getCategory(), this }
            );
  }
  
  public Collection<Grouped> fullEntities() {
    Dao dao = new ContactsPU();
    return dao.getResultList(
            " select g from Grouped g " +
            " where g.parent.category = ? " +
            " and (g.parent = ? or g.parent.path like ?)",
            new Object[] { this.getCategory(), this, this.getPathName() + "/%" }
            );
  }
  
  public Collection<Grouped> fullEntities(String entityRoot) {
    Dao dao = new ContactsPU();
    return dao.getResultList(
            " select g from Grouped g " +
            " where g.parent.category = ? " +
            " and (g.parent = ? or g.parent.path like ?) " +
            " and g.path like ? ",
            new Object[] { this.getCategory(), this, 
              this.getPathName() + "/%", entityRoot + "/%" }
            );
  }
  
  public static GroupIt normalizePaths(GroupIt group) {
    Dao dao = new ContactsPU();
    String d = "/" + group.getName();
    GroupIt g = group.getParent();
    while(g != null) {
      d = "/" + g.getName() + d;
      g = g.getParent();
    }
    group.setPathName(d);
    return dao.saveObject(group);
  }
 
  public static void normalizePaths(String oldPath) {
    Dao dao = new ContactsPU();
    for(GroupIt group : (List<GroupIt>) dao.getResultList(
            "select g from GroupIt g where g.pathName like ?",
            new Object[] { oldPath + "/%" })) {
      String d = "/" + group.getName();
      GroupIt g = group.getParent();
      while(g != null) {
        d = "/" + g.getName() + d;
        g = g.getParent();
      }
      group.setPathName(d);
      dao.saveObject(group);
    }
  }
 
  public static void delete(String path) {
    Dao dao = new ContactsPU();
    dao.executeUpdate(
            "delete from Grouped where parent in (select gi from GroupIt gi where gi.pathName = ? or gi.pathName like ?)",
            new Object[] { path, path + "/%" });
    dao.executeUpdate(
            "delete from GroupIt where pathName = ? or pathName like ?",
            new Object[] { path, path + "/%" });
  }
  
  public static GroupIt getOrCreate(String category, String node, GroupIt parent) {
    Dao dao = new ContactsPU();
    String parentPath = parent != null ? parent.getPathName() + "/" : "/";
    GroupIt gi = (GroupIt) dao.getSingleResultOrNull(
            "select g from GroupIt g where g.category = ? and g.pathName = ?",
            new Object[] { category,  parentPath + node });
    if(gi == null) {
      gi = new GroupIt();
      gi.setCategory(category);
      gi.setName(node);
      gi.setParent(parent);
      gi.setPublishable(true);
      gi = gi.normalizePaths(gi);
    }
    return gi;
  }
  
  /* Fields */
  
  public FieldItSet fields() {
    FieldItSet fiu = FieldItUtil.fields(ContactsPU.getObjectPath(this));
    GroupIt gi = getParent();
    while(gi != null) {
      fiu.addAll(FieldItUtil.fields(ContactsPU.getObjectPath(gi)));
      gi = gi.getParent();
    }
    return fiu;
  }
 
}