www/AttachTree.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2013 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.attach.www;
 
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import org.turro.string.Strings;
import org.turro.action.AcceptanceSingleStatus;
import org.turro.action.IAcceptances;
import org.turro.action.Plugins;
import org.turro.attach.db.AttachPU;
import org.turro.attach.entity.Attachment;
import org.turro.collections.Item;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.db.WhereClause;
import org.turro.html.FontAwesome;
import org.turro.http.HttpUtil;
import org.turro.jpa.iterator.DaoHtmlTree;
import org.turro.marker.ElephantMarker;
import org.turro.path.Path;
 
public class AttachTree extends DaoHtmlTree<Object, Object> {
 
  private boolean publicOnly, lastOnly;
  private final HashSet<String> restrictedFolders = new HashSet<>();
  
  public AttachTree(IConstructor constructor) {
    super(new AttachPU(), new ElephantMarker(constructor));
  }
 
  public boolean isPublicOnly() {
    return publicOnly;
  }
 
  public void setPublicOnly(boolean publicOnly) {
    this.publicOnly = publicOnly;
  }
 
  public boolean isLastOnly() {
    return lastOnly;
  }
 
  public void setLastOnly(boolean lastOnly) {
    this.lastOnly = lastOnly;
  }
 
  public HashSet<String> getRestrictedFolders() {
    return restrictedFolders;
  }
 
  public void addRestrictedFolder(String restrictedFolder) {
    if(!Strings.isBlank(restrictedFolder)) {
      restrictedFolders.add(restrictedFolder);
    }
  }
 
  public void addRestrictedFolders(HashSet<String> restrictedFolders) {
    if(restrictedFolders != null) {
      this.restrictedFolders.addAll(restrictedFolders);
    }
  }
 
  @Override
  protected Object getEntity(Object value) {
    return value instanceof Long ? getDao().find(Attachment.class, (Long) value) : value;
  }
 
  @Override
  protected void renderTree(ElephantMarker marker, List<Item<Object, Object>> items) {
    clean(items);
    marker.put("items", items);
    marker.process("attachment", getTreeTemplate());
  }
 
  @Override
  protected void renderItem(ElephantMarker marker, Object item) {
    marker.put("item", item);
    marker.process("attachment", getFullTemplate());
  }
 
  @Override
  protected String parseTree(ElephantMarker marker, List<Item<Object, Object>> items) {
    clean(items);
    marker.put("items", items);
    return marker.parse("attachment", getTreeTemplate());
  }
 
  @Override
  protected String parseItem(ElephantMarker marker, Object item) {
    marker.put("item", item);
    return marker.parse("attachment", getFullTemplate());
  }
 
  @Override
  protected WhereClause getChildrenClause(String currPath) {
    WhereClause wc = new WhereClause();
//    wc.addClause("select distinct a.path from Attachment as a");
    wc.addClause("select distinct case when locate('/', a.path, " + (currPath.length() + 2) + ") = 0 then a.path else substring(a.path, 1, locate('/', a.path, " + (currPath.length() + 2) + ") - 1) end from Attachment as a");
//    wc.addClause("select distinct substring(a.path, 1, locate('/', a.path, " + (currPath.length() + 2) + ") - 1) from Attachment as a");
    wc.addClause("where UCASE(a.path) like UCASE(:path)");
    wc.addNamedValue("path", currPath + "/_%");
//    wc.addClause("and UCASE(a.path) not like UCASE(:npath)");
//    wc.addNamedValue("npath", currPath + "/_%/%");
    if(publicOnly) {
      wc.addClause("and a.publishable = true");
    }
    wc.addClause("order by 1");
    return wc;
  }
 
  @Override
  protected WhereClause getLeafClause(String currPath) {
    WhereClause wc = new WhereClause();
    wc.addClause("select distinct a from Attachment as a");
    if(Strings.isBlank(currPath)) {
      wc.addClause("where a.path is null");
    } else {
      wc.addClause("where UCASE(a.path) = UCASE(:path)");
      wc.addNamedValue("path", currPath);
    }
    if(publicOnly) {
      wc.addClause("and a.publishable = true");
    }
    if(lastOnly) {
      wc.addClause("and a.modification = (select max(a2.modification) from Attachment as a2 where a2.path = a.path and a2.fileName = a.fileName)");
    }
    wc.addClause("order by a.fileName");
    return wc;
  }
 
  @Override
  protected Object getId(Object item) {
    return item instanceof Attachment ? ((Attachment) item).getId() : new Path((String) item).getLastNode();
  }
 
  @Override
  protected Object getParentId(Object item) {
    return null;
  }
  
  public String getImage(Item item) {
    Attachment attachment = (Attachment) item.getValue();
    return FontAwesome.getMimeIcon(attachment.getFileExtension());
//    if(!new File(ElephantContext.getRealPath("/_internal/system/mime/" + attachment.getFileExtension() + ".png")).exists()) {
//      return ElephantContext.getRootWebPath() + "/_internal/system/mime/empty.png";
//    } else {
//      return ElephantContext.getRootWebPath() + "/_internal/system/mime/" + attachment.getFileExtension() + ".png";
//    }
  }
 
  public String getFolderImage() {
    return FontAwesome.getMimeIcon("folder");
//    return ElephantContext.getRootWebPath() + "/_internal/system/mime/folder.png";
  }
 
  public String getShowURL(Item item) {
    Attachment attachment = (Attachment) item.getValue();
    return attachment.getShowURL(constructor);
  }
  
  public String getROShowURL(Item item) {
    Attachment attachment = (Attachment) item.getValue();
    return attachment.getROShowURL(constructor);
  }
  
  public String getByteString(Item item) {
    Attachment attachment = (Attachment) item.getValue();
    return attachment.getByteString();
  }
    
  public String getDateString(Item item) {
    Attachment attachment = (Attachment) item.getValue();
    return attachment.getDateString(constructor);
  }
   
  public String getDeleteLink(Item item) {
    Attachment attachment = (Attachment) item.getValue();
    return AttachAction.delAttachment(attachment, HttpUtil.getCurrentUrl(constructor.getRequest()));
  }
  
  public String createPetition(AcceptanceSingleStatus status, Item item) {
    if(AcceptanceSingleStatus.SINGLE_FORBIDDEN.equals(status)) {
      IAcceptances acceptances = Plugins.loadImplementation(IAcceptances.class);
      Attachment attachment = (Attachment) item.getValue();
      return acceptances.createPetition(AttachPU.getObjectPath(attachment), attachment.getIOwner(), 
              Application.getApplication().getConstructor().getRequest().getServletPath());
    }
    return "";
  }
  
  private void clean(List<Item<Object, Object>> items) {
    if(restrictedFolders.contains("*") || Application.getApplication().isInRole("attach-show:all")) return;
    Iterator<Item<Object, Object>> it = items.iterator();
    while(it.hasNext()) {
      Item<Object, Object> item = it.next();
      if(!item.isLeaf()) {
        Path p = new Path(item.getPath());
        String tmp = p.getLastNode();
        if(!Strings.isBlank(tmp) && tmp.startsWith("#")) {
          boolean allowed = false;
          for(String restrictedFolder : restrictedFolders) {
            if(("#" + restrictedFolder).equalsIgnoreCase(tmp)) {
              allowed = true;
              break;
            }
          }
          if(!allowed) {
            it.remove();
            continue;
          }
        }
        clean(item.getChildren());
      }
    }
  }
  
}