WorkFile.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.wd.files;
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.ParseException;
import java.util.Date;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.pivot.io.FileSerializer;
import org.apache.pivot.serialization.BinarySerializer;
import org.apache.pivot.serialization.SerializationException;
import org.apache.pivot.web.GetQuery;
import org.apache.pivot.web.PostQuery;
import org.apache.pivot.web.QueryException;
import org.jdom.Element;
import org.turro.wd.entities.WdFormats;
import org.turro.wd.tree.SyncTask;
 
public class WorkFile implements Comparable<WorkFile> {
 
  private Directory parent;
  private String name, serverOwner, serverOwnerName, serverLocker;
  private Date downModification;
  private long serverSize;
  private File file;
  private boolean serverLocked = false;
 
  public Date getDownModification() {
    return downModification;
  }
 
  public void setDownModification(Date downModification) {
    this.downModification = downModification;
  }
 
public File getFile() {
    return file;
  }
 
  public void setFile(File file) {
    this.file = file;
  }
 
  public String getName() {
    return name;
  }
 
  public void setName(String name) {
    this.name = name;
  }
 
  public Directory getParent() {
    return parent;
  }
 
  public void setParent(Directory parent) {
    this.parent = parent;
  }
 
  public boolean isServerLocked() {
    return serverLocked;
  }
 
  public void setServerLocked(boolean serverLocked) {
    this.serverLocked = serverLocked;
  }
 
  public String getServerLocker() {
    return serverLocker;
  }
 
  public void setServerLocker(String serverLocker) {
    this.serverLocker = serverLocker;
  }
 
  public String getServerOwner() {
    return serverOwner;
  }
 
  public void setServerOwner(String serverOwner) {
    this.serverOwner = serverOwner;
  }
 
  public String getServerOwnerName() {
    return serverOwnerName;
  }
 
  public void setServerOwnerName(String serverOwnerName) {
    this.serverOwnerName = serverOwnerName;
  }
 
  public long getServerSize() {
    return serverSize;
  }
 
  public void setServerSize(long serverSize) {
    this.serverSize = serverSize;
  }
 
  public String getSystemPath() {
    return parent.getSystemPath() + "/" + getSystemName();
  }
 
  public String getSystemName() {
    return getName();
  }
 
  public File getSystemFile() {
    return new File(getSystemPath());
  }
 
  public boolean isExistsOnServer() {
    return getDownModification() != null;
  }
 
  public boolean isDownloadable() throws ParseException {
    return (file == null || (getDownModification() != null &&
            WdFormats.before(downModification, file.lastModified()))) &&
            parent.isUpdatable();
  }
 
  public boolean isUploadable() throws ParseException {
    return (file != null && (getDownModification() == null ||
            WdFormats.after(downModification, file.lastModified()))) &&
            parent.isUpdatable();
  }
 
  public void readXML(Element root) throws ParseException {
    if(root.getAttributeValue("name") != null)
      setName(root.getAttributeValue("name"));
  }
 
  public void writeXML(Element root) {
    Element el = new Element("wfile");
    el.setAttribute("name", getName());
    root.addContent(el);
  }
 
  public boolean checkExisting() {
    return getSystemFile().exists();
  }
 
  public int compareTo(WorkFile o) {
    if(getName() == null || o.getName() == null) {
      return 0;
    }
    return getName().compareTo(o.getName());
  }
 
  public void doUpload(String comment, int commitAction) {
    try {
      if((commitAction == SyncTask.COMMIT_DO_NOTHING) || !isUploadable()) return;
      PostQuery postQuery = new PostQuery(
              parent.getHost(), parent.getPort(), 
              parent.getContext() + "/pservice/upload", false);
      postQuery.getParameters().put("user", parent.getUser());
      postQuery.getParameters().put("path", parent.getAbsolutePath());
      postQuery.getParameters().put("fileName", getName());
      postQuery.getParameters().put("fileDate", WdFormats.format(file.lastModified()));
      postQuery.getParameters().put("comment", comment);
      postQuery.getParameters().put("lock",
              (((commitAction == SyncTask.COMMIT_KEEP_LOCK) && isServerLocked()) ? "true" : "false"));
      postQuery.setSerializer(new FileSerializer());
      postQuery.setValue(file);
      postQuery.execute();
    } catch (ParseException ex) {
      Logger.getLogger(WorkFile.class.getName()).log(Level.SEVERE, null, ex);
    } catch (QueryException ex) {
      Logger.getLogger(WorkFile.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
 
  public void doDownload(int updateAction) {
    try {
      if((updateAction == SyncTask.UPDATE_DO_NOTHING) || 
              (!isDownloadable()) && !(updateAction == SyncTask.UPDATE_UPDATE_FOR_EDITING)) return;
      GetQuery getQuery = new GetQuery(
              parent.getHost(), parent.getPort(),
              parent.getContext() + "/pservice/download", false);
      getQuery.getParameters().put("user", parent.getUser());
      getQuery.getParameters().put("forEditing", 
              (updateAction == SyncTask.UPDATE_UPDATE_FOR_EDITING) ? "true" : "false");
      getQuery.getParameters().put("path", parent.getAbsolutePath());
      getQuery.getParameters().put("fileName", getName());
      getQuery.setSerializer(new FileSerializer());
      File receivedFile = (File) getQuery.execute();
      new File(parent.getSystemPath()).mkdirs();
      File saveFile = getSystemFile();
      OutputStream os = new FileOutputStream(saveFile);
      ((FileSerializer) getQuery.getSerializer())
              .writeObject(receivedFile, os);
      os.close();
      saveFile.setLastModified(downModification.getTime());
    } catch (ParseException ex) {
      Logger.getLogger(WorkFile.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IOException ex) {
      Logger.getLogger(WorkFile.class.getName()).log(Level.SEVERE, null, ex);
    } catch (SerializationException ex) {
      Logger.getLogger(WorkFile.class.getName()).log(Level.SEVERE, null, ex);
    } catch (QueryException ex) {
      Logger.getLogger(WorkFile.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
 
  public void doUnlock() {
    try {
      GetQuery getQuery = new GetQuery(
              parent.getHost(), parent.getPort(),
              parent.getContext() + "/pservice/unlock", false);
      getQuery.getParameters().put("user", parent.getUser());
      getQuery.getParameters().put("path", parent.getAbsolutePath());
      getQuery.getParameters().put("fileName", getName());
      getQuery.setSerializer(new BinarySerializer());
      getQuery.execute();
    } catch (QueryException ex) {
      Logger.getLogger(Directory.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
}