Attachment.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 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.entity;
 
import com.lowagie.text.DocumentException;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.text.DateFormat;
import java.util.Date;
import java.util.HashSet;
import javax.persistence.*;
import org.amic.util.date.CheckDate;
import org.amic.util.date.DateFormats;
import org.turro.formatter.BytesFormatter;
import org.turro.string.Strings;
import org.turro.action.AcceptanceSingleStatus;
import org.turro.action.Contacts;
import org.turro.action.IAcceptances;
import org.turro.action.Plugins;
import org.turro.attach.db.AttachPU;
import org.turro.attach.www.AttachDownload;
import org.turro.attach.zul.AttachmentUtil;
import org.turro.auth.Authentication;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.IConstructor;
import org.turro.entities.Entities;
import org.turro.entities.IElephantEntity;
import org.turro.i18n.I_;
import org.turro.path.Path;
import org.turro.pdf.Watermark;
import org.turro.pdf.WatermarkCfg;
import org.turro.plugin.contacts.IContact;
 
@Entity
@NamedQueries({
  @NamedQuery(name="attachmentByPartialFileName", query="select a from Attachment a where UCASE(a.path) like UCASE(:path) and UCASE(a.fileName) like UCASE(:fileName) order by path, fileName, modification"),
  @NamedQuery(name="attachmentByPartialFileNameNV", query="select a from Attachment a where UCASE(a.path) like UCASE(:path) and UCASE(a.fileName) like UCASE(:fileName) and validated = false order by path, fileName, modification"),
  @NamedQuery(name="attachmentByPartialFileNameV", query="select a from Attachment a where UCASE(a.path) like UCASE(:path) and UCASE(a.fileName) like UCASE(:fileName) and validated = true order by path, fileName, modification"),
  @NamedQuery(name="attachmentByPartialPath", query="select a from Attachment a where UCASE(a.path) like UCASE(:path) order by path, fileName, modification"),
  @NamedQuery(name="attachmentByPath", query="select a from Attachment a where a.path = :path order by path, fileName, modification"),
  @NamedQuery(name="pathByRoot", query="select distinct a.path from Attachment a where UCASE(a.path) like UCASE(:root) order by a.path DESC"),
  @NamedQuery(name="pathByRootNV", query="select distinct a.path from Attachment a where UCASE(a.path) like UCASE(:root) and validated = false order by a.path DESC")
})
public class Attachment implements java.io.Serializable {
 
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  @Column(name="IDENTIFIER")
  private Long id;
  
  @Column(name="ATTACH_PATH")
  private String path;
  
  private String relatedPath;
  
  private String owner;
  
  private String showKey;
  
  private boolean validated;
 
  private boolean locked;
 
  private String locker;
  
  private boolean publishable;
 
  @Temporal(value = javax.persistence.TemporalType.TIMESTAMP)
  private java.util.Date lockDate;
 
  @Temporal(value = javax.persistence.TemporalType.TIMESTAMP)
  private java.util.Date lockCommit;
 
  @Lob
  @Column(length=4096)
  private String lockComment;
 
  private boolean onlyOwner;
  
  @Temporal(value = javax.persistence.TemporalType.TIMESTAMP)
  private java.util.Date modification;
 
  @Lob
  @Column(length=4096)
  private String comment;
 
  private String fileName;
  
  private String fileContentType;
  
  private long fileSize;
  
  private boolean requiresAcceptance;
  
  private boolean watermark;
 
  @OneToOne(fetch=FetchType.LAZY,cascade={CascadeType.MERGE,CascadeType.PERSIST,CascadeType.REMOVE}, orphanRemoval=true)
  private AttachContent attachContent;
 
  public AttachContent getAttachContent() {
    return attachContent;
  }
 
  public void setAttachContent(AttachContent attachContent) {
    this.attachContent = attachContent;
  }
  
  public Long getId() {
    return id;
  }
 
  public void setId(Long id) {
    this.id = id;
  }
 
  public String getOwner() {
    return owner;
  }
 
  public void setOwner(String owner) {
    this.owner = owner;
  }
 
  public boolean isOnlyOwner() {
    return onlyOwner;
  }
 
  public void setOnlyOwner(boolean onlyOwner) {
    this.onlyOwner = onlyOwner;
  }
 
  public String getLockComment() {
    return lockComment;
  }
 
  public void setLockComment(String lockComment) {
    this.lockComment = lockComment;
  }
 
  public Date getLockCommit() {
    return lockCommit;
  }
 
  public void setLockCommit(Date lockCommit) {
    this.lockCommit = lockCommit;
  }
 
  public Date getLockDate() {
    return lockDate;
  }
 
  public void setLockDate(Date lockDate) {
    this.lockDate = lockDate;
  }
 
  public boolean isLocked() {
    return locked;
  }
 
  public void setLocked(boolean locked) {
    this.locked = locked;
  }
 
  public String getLocker() {
    return locker;
  }
 
  public void setLocker(String locker) {
    this.locker = locker;
  }
 
  public String getPath() {
    return path;
  }
 
  public void setPath(String path) {
    if(path != null) {
      while(path.indexOf("//") > -1) {
        path = path.replaceAll("//", "/");
      }
      if(path.endsWith("/")) {
        path = path.substring(0, path.length() - 1);
      }
      if(!path.startsWith("/")) {
        path = "/" + path;
      }
    }
    this.path = path;
  }
 
  public String getRelatedPath() {
    return relatedPath;
  }
 
  public void setRelatedPath(String relatedPath) {
    this.relatedPath = relatedPath;
  }
 
  public Date getModification() {
    return modification;
  }
 
  public void setModification(Date modification) {
    this.modification = modification;
  }
 
  public String getComment() {
    return comment;
  }
 
  public void setComment(String comment) {
    this.comment = comment;
  }
 
  public String getFileContentType() {
    return fileContentType;
  }
 
  public void setFileContentType(String fileContentType) {
    this.fileContentType = fileContentType;
  }
 
  public String getFileName() {
    return fileName;
  }
 
  public void setFileName(String fileName) {
    this.fileName = fileName;
  }
 
  public long getFileSize() {
    return fileSize;
  }
 
  public void setFileSize(long fileSize) {
    this.fileSize = fileSize;
  }
 
  public String getShowKey() {
    return showKey;
  }
 
  public void setShowKey(String showKey) {
    this.showKey = showKey;
  }
 
  public boolean isValidated() {
    return validated;
  }
 
  public void setValidated(boolean validated) {
    this.validated = validated;
  }
 
  public boolean isPublishable() {
    return publishable;
  }
 
  public void setPublishable(boolean publishable) {
    this.publishable = publishable;
  }
 
  public boolean isRequiresAcceptance() {
    return requiresAcceptance;
  }
 
  public void setRequiresAcceptance(boolean requiresAcceptance) {
    this.requiresAcceptance = requiresAcceptance;
  }
 
  public boolean isWatermark() {
    return watermark;
  }
 
  public void setWatermark(boolean watermark) {
    this.watermark = watermark;
  }
 
  /* Helpers */
  
  public String getFileExtension() {
    if(fileName != null) {
      int p = fileName.lastIndexOf(".");
      if(p > 0) {
        return fileName.substring(p + 1).toLowerCase();
      }
    }
    return "bin";
  }
  
  public String getRelativePath(String root) {
    if(root == null) {
      return path;
    }
    if(path.toUpperCase().startsWith(root.toUpperCase())) {
      return path.substring(root.length());
    }
    return "";
  }
  
  public Attachment cloneEntity() {
    Attachment a = AttachmentUtil.withContent(this);
    Attachment na = new Attachment();
    na.setComment(a.comment);
    na.setFileContentType(a.fileContentType);
    na.setFileName(a.fileName);
    na.setFileSize(a.fileSize);
    na.setLockComment(a.lockComment);
    na.setLockCommit(a.lockCommit);
    na.setLockDate(a.lockDate);
    na.setLocked(a.locked);
    na.setLocker(a.locker);
    na.setModification(a.modification);
    na.setOnlyOwner(a.onlyOwner);
    na.setOwner(a.owner);
    na.setPath(a.path);
    na.setShowKey(a.showKey);
    na.setValidated(a.validated);
    AttachContent nac = new AttachContent();
    nac.setFileContent(a.attachContent.getFileContent());
    na.setAttachContent(nac);
    return na;
  }
 
  public void setDateModification(Date value) {
    modification = new CheckDate(modification).setDayMonthYear(value).getDate();
  }
 
  public void setTimeModification(Date value) {
    modification = new CheckDate(modification).setHourMinute(value).getDate();
  }
 
  /* Content help */
  
  public Attachment getWithContent() {
    return AttachmentUtil.withContent(this);
  }
  
  public byte[] getContentModified(IContact contact) throws IOException, DocumentException {
    AttachContent ac = getWithContent().getAttachContent();
    if(isWatermark() && isPDF()) {
      if(contact != null && contact.isValid()) {
        WatermarkCfg cfg = new WatermarkCfg(getContactName(contact), 45.0F);
        Watermark mark = new Watermark();
        ByteArrayOutputStream output = new ByteArrayOutputStream((int) getFileSize());
        mark.addWatermark(
                new ByteArrayInputStream(ac.getFileContent()), 
                output, cfg);
        return output.toByteArray();
      } else {
        return new byte[] {};
      }
    }
    return ac.getFileContent();
  }
  
  public boolean isPDF() {
    return fileName.toLowerCase().endsWith(".pdf");
  }
  
  private String getContactName(IContact contact) {
    String name = contact.getName();
    IContact business = contact.getBusiness();
    if(business != null && business.isValid()) {
      name = name + "\n" + business.getName();
    }
    return name;
  }
  
  /* Contact help */
  
  public IContact getIOwner() {
    if(!Strings.isBlank(owner)) {
      IContact contact = Contacts.getContactById(owner);
      if(!contact.isValid()) {
        contact.loadByLogin(owner);
      }
      if(contact.isValid()) {
        return contact;
      }
    }
    return null;
  }
 
  /* Entity help */
  
  public IElephantEntity getOwnerEntity() {
    return Entities.getController(new Path(path).getTill(2));
  }
  
  /* Restricted folders */
  
  public boolean canShow(HashSet<String> restrictedFolders) {
    return canShow(restrictedFolders, Application.getApplication().isInRole("attach-show:all"));
  }
  
  public boolean canShowTo(IContact contact, HashSet<String> restrictedFolders) {
    return canShow(restrictedFolders, contact.getPermissions().isInRole("attach-show:all"));
  }
  
  private boolean canShow(HashSet<String> restrictedFolders, boolean allPermission) {
    if((restrictedFolders != null && restrictedFolders.contains("*")) || allPermission) return true;
    Path p = new Path(getPath());
    for(String node : p.getNodes()) {
      if(!Strings.isBlank(node) && node.startsWith("#")) {
        boolean allowed = false;
        for(String restrictedFolder : restrictedFolders) {
          if(("#" + restrictedFolder).equalsIgnoreCase(node)) {
            allowed = true;
            break;
          }
        }
        if(!allowed) {
          return false;
        }
      }
    }
    return true;
  }
  
  /* WWW */
  
  public String getShowURL(IConstructor constructor) {
    return AttachDownload.createURL(constructor, this);
  }
 
  public String getROShowURL(IConstructor constructor) {
    return AttachDownload.createROURL(constructor, this);
  }
    
  public String getByteString() {
    return new BytesFormatter(getFileSize()).toString();
  }
    
  public String getDateString(IConstructor constructor) {
    return DateFormats.format(getModification(), 
            DateFormat.SHORT, I_.api().used());
  }
  
  /* Requires acceptation */
  
  public AcceptanceSingleStatus getSingleStatus() {
    return getSingleStatus(Authentication.getIContact());
  }
 
  public AcceptanceSingleStatus getSingleStatus(IContact contact) {
    IAcceptances acceptances = Plugins.loadImplementation(IAcceptances.class);
    return acceptances.getStatusFor(AttachPU.getObjectPath(this), contact, getIOwner());
  }
 
}