Attachments.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.attach.search;
 
import java.io.IOException;
import java.nio.file.Files;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Stream;
import org.turro.attach.db.AttachPU;
import org.turro.attach.entity.Attachment;
import org.turro.attach.zul.AttachmentUtil;
import org.turro.file.Folder;
import org.turro.path.Path;
import org.turro.path.PathObject;
import org.turro.path.PathTree;
import org.turro.sql.SqlClause;
 
public class Attachments {
 
  public void toFolder(Folder folder) {
    folder.ensure();
    get().forEach(a -> saveToFile(folder, a));
  }
  
  public void remove() {
    SqlClause.delete("Attachment")
            .where().group()
            .equal("path", path)
            .or().startsWith("path", path + "/")
            .endGroup()
            .startIf(onlyPublic)
            .and().isTrue("publishable")
            .endIf()
            .startIf(banRestricted)
            .and().not().contains("path", "#")
            .endIf()
            .dao(new AttachPU())
            .execute();
  }
  
  public List<Attachment> get() {
    return SqlClause.select("a").from("Attachment a")
            .where().group()
            .equal("a.path", path)
            .or().startsWith("a.path", path + "/")
            .endGroup()
            .startIf(onlyPublic)
            .and().isTrue("a.publishable")
            .endIf()
            .startIf(banRestricted)
            .and().not().contains("a.path", "#")
            .endIf()
            .orderBy("a.modification")
            .dao(new AttachPU())
            .resultList(Attachment.class);
  }
  
  public PathTree getTree() {
    return PathTree.fromObjects(SqlClause.select("a").from("Attachment a")
            .where().group()
            .equal("a.path", path)
            .or().startsWith("a.path", path + "/")
            .endGroup()
            .startIf(onlyPublic)
            .and().isTrue("a.publishable")
            .endIf()
            .startIf(banRestricted)
            .and().not().contains("a.path", "#")
            .and().isFalse("a.requiresAcceptance")
            .and().isFalse("a.watermark")
            .endIf()
            .orderBy("a.modification")
            .dao(new AttachPU())
            .stream(Attachment.class)
            .map(a -> {
              return PathObject.from(
                      a.getRelativePath(path) + "/" + a.getFileName(),
                      new AttachmentNode(a.getId(), a.getFileSize(), a.getModification(), a.getFileExtension()));
            })
            .toList(), new AttachmentNode(null, 0, null, null));
  }
  
  /* IO */
  
  private void saveToFile(Folder folder, Attachment attachment) {
    attachment = AttachmentUtil.withContent(attachment);
    try {
      Files.write(folder.path().resolve(attachment.getFileName()),
              attachment.getAttachContent().getFileContent());
    } catch (IOException ex) {
      Logger.getLogger(Attachments.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
  
  /* Utils */
  
  public static Set<String> getAllPaths(String root) {
    try(Stream<String> stream = SqlClause.select("distinct a.path").from("Attachment a")
            .where().startsWith("a.path", "/" + root + "/")
            .dao(new AttachPU())
            .stream(String.class)) {
      return new HashSet<>(
              stream.map(path -> Path.pathFrom(path).getTill(2))
              .toList());
    }
  }
  
  /* Attibutes */
  
  private boolean onlyPublic, banRestricted;
  
  public Attachments onlyPublic() {
    onlyPublic = true;
    return this;
  }
  
  public Attachments banRestricted() {
    banRestricted = true;
    return this;
  }
  
  /* Factory */
  
  public static Attachments from(String path) {
    return new Attachments(path);
  }
  
  private final String path;
  
  private Attachments(String path) {
    this.path = path;
  }
  
}