elephant-attach/src/main/java/org/turro/documentation/DocumentDefinition.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.documentation;
 
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.turro.string.Strings;
import org.turro.attach.db.AttachPU;
import org.turro.elephant.context.ElephantContext;
import org.turro.file.Document;
import org.turro.file.Folder;
import org.turro.plugin.contacts.IContact;
import org.turro.sql.SqlClause;
import org.turro.util.CompareUtil;
 
public class DocumentDefinition implements Comparable<DocumentDefinition> {
 
  public final String name;
  public final DocumentType type;
  public String description, allowedRoot;
  public boolean allowMultiple, uploadControl;
  public int min, max;
 
  public DocumentDefinition(String name, DocumentType type) {
    this.name = name;
    this.type = type;
    this.min = 1;
    this.max = 1;
  }
 
  public DocumentDefinition allowedRoot(String root) {
    this.allowedRoot = root;
    return this;
  }
 
  public DocumentDefinition description(String text) {
    this.description = text;
    return this;
  }
 
  public DocumentDefinition allowMultiple() {
    this.allowMultiple = true;
    return this;
  }
 
  public DocumentDefinition uploadControl() {
    this.uploadControl = true;
    return this;
  }
 
  public DocumentDefinition min(int min) {
    this.min = min;
    return this;
  }
 
  public DocumentDefinition max(int max) {
    this.max = max;
    return this;
  }
 
  public String getName() {
    return name;
  }
 
  public DocumentType getType() {
    return type;
  }
 
  public void setAllowedRoot(String allowedRoot) {
    this.allowedRoot = allowedRoot;
  }
 
  public String getAllowedRoot() {
    return allowedRoot;
  }
 
  public void setDescription(String description) {
    this.description = description;
  }
 
  public String getDescription() {
    return description;
  }
 
  public boolean isAllowMultiple() {
    return allowMultiple;
  }
 
  public void setAllowMultiple(boolean allowMultiple) {
    this.allowMultiple = allowMultiple;
  }
 
  public boolean isUploadControl() {
    return uploadControl;
  }
 
  public void setUploadControl(boolean uploadControl) {
    this.uploadControl = uploadControl;
  }
 
  public void setMin(int min) {
    this.min = min;
  }
 
  public int getMin() {
    return min;
  }
 
  public void setMax(int max) {
    this.max = max;
  }
 
  public int getMax() {
    return max;
  }
 
  /* Utils */
  
  public boolean isInformation() {
    return !Strings.isBlank(description) || !getFolder().isEmpty();
  }
  
  public boolean isFiltered() {
    return !"*".equals(Strings.isBlank(allowedRoot, "*"));
  }
  
  public boolean matches(String root) {
    return !isFiltered() || (CompareUtil.compare(root, allowedRoot) == 0);
  }
 
  public Map<String, List<Document>> getDocumentsMap() {
    Map<String, List<Document>> docs = new TreeMap<>();
    Folder folder = getFolder();
    try {
      if(folder.exists()) docs.put("*", folder.documents());
      for(Folder child : folder.folders()) {
        docs.put(child.name(), child.documents());
      }
    } catch (IOException ex) {
      Logger.getLogger(DocumentDefinition.class.getName()).log(Level.SEVERE, null, ex);
    }
    return docs;
  }
  
  public List<Document> getDocumentsFor(IContact contact) {
    List<Document> docs = new ArrayList<>();
    Folder folder = getFolder();
    try {
      if(folder.exists()) docs.addAll(folder.documents());
      Folder selfDocs = folder.child(contact.getId());
      if(selfDocs.exists()) docs.addAll(selfDocs.documents());
      IContact parent = contact.getBusiness();
      if(parent != null) {
        Folder parentDocs = folder.child(parent.getId());
        if(parentDocs.exists()) docs.addAll(parentDocs.documents());
      }
    } catch (IOException ex) {
      Logger.getLogger(DocumentDefinition.class.getName()).log(Level.SEVERE, null, ex);
    }
    return docs;
  }
  
  public Folder getFolder() {
    return Folder.from(ElephantContext.getRealPath(getFolderString()));
  }
  
  public String getFolderString() {
    return "/WEB-INF/files/doc-references/" + getFolderName();
  }
  
  public String getFolderName() {
    return "hash-" + hashCode() + "-def";
  }
 
  public boolean canDelete() {
    return SqlClause.select("count(ed)")
            .from("EntityDocumentation ed")
            .where().equal("ed.documentation", name)
            .dao(new AttachPU())
            .singleResult(Long.class) == 0L;
  }
  
  @Override
  public int hashCode() {
    int hash = 7;
    hash = 73 * hash + Objects.hashCode(this.name);
    return hash;
  }
 
  @Override
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final DocumentDefinition other = (DocumentDefinition) obj;
    return Objects.equals(this.name, other.name);
  }
 
  @Override
  public int compareTo(DocumentDefinition o) {
    return CompareUtil.compare(name, o.name);
  }
 
}