src/com/owncloud/android/operations/RenameFileOperation.java

   1 /* ownCloud Android client application
   2  *   Copyright (C) 2012 Bartek Przybylski
   3  *
   4  *   This program is free software: you can redistribute it and/or modify
   5  *   it under the terms of the GNU General Public License as published by
   6  *   the Free Software Foundation, either version 3 of the License, or
   7  *   (at your option) any later version.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details.
  13  *
  14  *   You should have received a copy of the GNU General Public License
  15  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  */
  18
  19 package com.owncloud.android.operations;
  20
  21 import java.io.File;
  22 import java.io.IOException;
  23
  24 import org.apache.jackrabbit.webdav.client.methods.DavMethodBase;
  25 //import org.apache.jackrabbit.webdav.client.methods.MoveMethod;
  26
  27 import android.util.Log;
  28
  29 import com.owncloud.android.datamodel.DataStorageManager;
  30 import com.owncloud.android.datamodel.OCFile;
  31 import com.owncloud.android.files.services.FileDownloader;
  32 import com.owncloud.android.operations.RemoteOperationResult.ResultCode;
  33
  34 import eu.alefzero.webdav.WebdavClient;
  35 import eu.alefzero.webdav.WebdavUtils;
  36
  37 /**
  38  * Remote operation performing the rename of a remote file (or folder?) in the ownCloud server.
  39  *
  40  * @author David A. Velasco
  41  */
  42 public class RenameFileOperation extends RemoteOperation {
  43
  44     private static final String TAG = RemoveFileOperation.class.getSimpleName();
  45
  46     private static final int RENAME_READ_TIMEOUT = 10000;
  47     private static final int RENAME_CONNECTION_TIMEOUT = 5000;
  48
  49
  50     private OCFile mFile;
  51     private String mNewName;
  52     private DataStorageManager mStorageManager;
  53
  54
  55     /**
  56      * Constructor
  57      *
  58      * @param file                  OCFile instance describing the remote file or folder to rename
  59      * @param newName               New name to set as the name of file.
  60      * @param storageManager        Reference to the local database corresponding to the account where the file is contained.
  61      */
  62     public RenameFileOperation(OCFile file, String newName, DataStorageManager storageManager) {
  63         mFile = file;
  64         mNewName = newName;
  65         mStorageManager = storageManager;
  66     }
  67
  68     public OCFile getFile() {
  69         return mFile;
  70     }
  71
  72
  73     /**
  74      * Performs the rename operation.
  75      *
  76      * @param   client      Client object to communicate with the remote ownCloud server.
  77      */
  78     @Override
  79     protected RemoteOperationResult run(WebdavClient client) {
  80         RemoteOperationResult result = null;
  81
  82         LocalMoveMethod move = null;
  83         String newRemotePath = null;
  84         try {
  85             if (mNewName.equals(mFile.getFileName())) {
  86                 return new RemoteOperationResult(ResultCode.OK);
  87             }
  88
  89             String parent = (new File(mFile.getRemotePath())).getParent();
  90             parent = (parent.endsWith(OCFile.PATH_SEPARATOR)) ? parent : parent + OCFile.PATH_SEPARATOR;
  91             newRemotePath =  parent + mNewName;
  92
  93             // check if the new name is valid in the local file system
  94             if (!isValidNewName()) {
  95                 return new RemoteOperationResult(ResultCode.INVALID_LOCAL_FILE_NAME);
  96             }
  97
  98             // check if a file with the new name already exists
  99             if (client.existsFile(newRemotePath) ||                             // remote check could fail by network failure, or by indeterminate behavior of HEAD for folders ...
 100                     mStorageManager.getFileByPath(newRemotePath) != null) {     // ... so local check is convenient
 101                 return new RemoteOperationResult(ResultCode.INVALID_OVERWRITE);
 102             }
 103             move = new LocalMoveMethod( client.getBaseUri() + WebdavUtils.encodePath(mFile.getRemotePath()),
 104                                         client.getBaseUri() + WebdavUtils.encodePath(newRemotePath));
 105             int status = client.executeMethod(move, RENAME_READ_TIMEOUT, RENAME_CONNECTION_TIMEOUT);
 106             if (move.succeeded()) {
 107
 108                 // create new OCFile instance for the renamed file
 109                 /*OCFile newFile = new OCFile(mStorageManager.getFileById(mFile.getParentId()).getRemotePath() + mNewName;   // TODO - NOT CREATE NEW OCFILE; ADD setFileName METHOD
 110                 OCFile oldFile = mFile;
 111                 mFile = newFile; */
 112                 mFile.setFileName(mNewName);
 113
 114                 // try to rename the local copy of the file
 115                 if (mFile.isDown()) {
 116                     File f = new File(mFile.getStoragePath());
 117                     String newStoragePath = f.getParent() + mNewName;
 118                     if (f.renameTo(new File(newStoragePath))) {
 119                         mFile.setStoragePath(newStoragePath);
 120                     }
 121                     // else - NOTHING: the link to the local file is kept although the local name can't be updated
 122                     // TODO - study conditions when this could be a problem
 123                 }
 124
 125                 //mStorageManager.removeFile(oldFile, false);
 126                 mStorageManager.saveFile(mFile);
 127
 128             /*
 129              *} else if (mFile.isDirectory() && (status == 207 || status >= 500)) {
 130              *   // TODO
 131              *   // if server fails in the rename of a folder, some children files could have been moved to a folder with the new name while some others
 132              *   // stayed in the old folder;
 133              *   //
 134              *   // easiest and heaviest solution is synchronizing the parent folder (or the full account);
 135              *   //
 136              *   // a better solution is synchronizing the folders with the old and new names;
 137              *}
 138              */
 139
 140             }
 141
 142             move.getResponseBodyAsString(); // exhaust response, although not interesting
 143             result = new RemoteOperationResult(move.succeeded(), status);
 144             Log.i(TAG, "Rename " + mFile.getRemotePath() + " to " + newRemotePath + ": " + result.getLogMessage());
 145
 146         } catch (Exception e) {
 147             result = new RemoteOperationResult(e);
 148             Log.e(TAG, "Rename " + mFile.getRemotePath() + " to " + ((newRemotePath==null) ? mNewName : newRemotePath) + ": " + result.getLogMessage(), e);
 149
 150         } finally {
 151             if (move != null)
 152                 move.releaseConnection();
 153         }
 154         return result;
 155     }
 156
 157
 158     /**
 159      * Checks if the new name to set is valid in the file system
 160      *
 161      * The only way to be sure is trying to create a file with that name. It's made in the temporal directory
 162      * for downloads, out of any account, and then removed.
 163      *
 164      * IMPORTANT: The test must be made in the same file system where files are download. The internal storage
 165      * could be formatted with a different file system.
 166      *
 167      * TODO move this method, and maybe FileDownload.get***Path(), to a class with utilities specific for the interactions with the file system
 168      *
 169      * @return      'True' if a temporal file named with the name to set could be created in the file system where
 170      *              local files are stored.
 171      */
 172     private boolean isValidNewName() {
 173         // check tricky names
 174         if (mNewName == null || mNewName.length() <= 0 || mNewName.contains(File.separator) || mNewName.contains("%")) {
 175             return false;
 176         }
 177         // create a test file
 178         String tmpFolder = FileDownloader.getTemporalPath("");
 179         File testFile = new File(tmpFolder + mNewName);
 180         try {
 181             testFile.createNewFile();   // return value is ignored; it could be 'false' because the file already existed, that doesn't invalidate the name
 182         } catch (IOException e) {
 183             Log.i(TAG, "Test for validity of name " + mNewName + " in the file system failed");
 184             return false;
 185         }
 186         boolean result = (testFile.exists() && testFile.isFile());
 187
 188         // cleaning ; result is ignored, since there is not much we could do in case of failure, but repeat and repeat...
 189         testFile.delete();
 190
 191         return result;
 192     }
 193
 194
 195
 196     // move operation - TODO: find out why org.apache.jackrabbit.webdav.client.methods.MoveMethod is not used instead ¿?
 197     private class LocalMoveMethod extends DavMethodBase {
 198
 199         public LocalMoveMethod(String uri, String dest) {
 200             super(uri);
 201             addRequestHeader(new org.apache.commons.httpclient.Header("Destination", dest));
 202         }
 203
 204         @Override
 205         public String getName() {
 206             return "MOVE";
 207         }
 208
 209         @Override
 210         protected boolean isSuccess(int status) {
 211             return status == 201 || status == 204;
 212         }
 213
 214     }
 215
 216
 217 }