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             newRemotePath = (new File(mFile.getRemotePath())).getParent() + mNewName;
  90
  91             // check if the new name is valid in the local file system
  92             if (!isValidNewName()) {
  93                 return new RemoteOperationResult(ResultCode.INVALID_LOCAL_FILE_NAME);
  94             }
  95
  96             // check if a file with the new name already exists
  97             if (client.existsFile(newRemotePath) ||                             // remote check could fail by network failure, or by indeterminate behavior of HEAD for folders ...
  98                     mStorageManager.getFileByPath(newRemotePath) != null) {     // ... so local check is convenient
  99                 return new RemoteOperationResult(ResultCode.INVALID_OVERWRITE);
 100             }
 101             move = new LocalMoveMethod( client.getBaseUri() + WebdavUtils.encodePath(mFile.getRemotePath()),
 102                                         client.getBaseUri() + WebdavUtils.encodePath(newRemotePath));
 103             int status = client.executeMethod(move, RENAME_READ_TIMEOUT, RENAME_CONNECTION_TIMEOUT);
 104             if (move.succeeded()) {
 105
 106                 // create new OCFile instance for the renamed file
 107                 /*OCFile newFile = new OCFile(mStorageManager.getFileById(mFile.getParentId()).getRemotePath() + mNewName;   // TODO - NOT CREATE NEW OCFILE; ADD setFileName METHOD
 108                 OCFile oldFile = mFile;
 109                 mFile = newFile; */
 110                 mFile.setFileName(mNewName);
 111
 112                 // try to rename the local copy of the file
 113                 if (mFile.isDown()) {
 114                     File f = new File(mFile.getStoragePath());
 115                     String newStoragePath = f.getParent() + mNewName;
 116                     if (f.renameTo(new File(newStoragePath))) {
 117                         mFile.setStoragePath(newStoragePath);
 118                     }
 119                     // else - NOTHING: the link to the local file is kept although the local name can't be updated
 120                     // TODO - study conditions when this could be a problem
 121                 }
 122
 123                 //mStorageManager.removeFile(oldFile, false);
 124                 mStorageManager.saveFile(mFile);
 125
 126             /*
 127              *} else if (mFile.isDirectory() && (status == 207 || status >= 500)) {
 128              *   // TODO
 129              *   // 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
 130              *   // stayed in the old folder;
 131              *   //
 132              *   // easiest and heaviest solution is synchronizing the parent folder (or the full account);
 133              *   //
 134              *   // a better solution is synchronizing the folders with the old and new names;
 135              *}
 136              */
 137
 138             }
 139
 140             move.getResponseBodyAsString(); // exhaust response, although not interesting
 141             result = new RemoteOperationResult(move.succeeded(), status);
 142             Log.i(TAG, "Rename " + mFile.getRemotePath() + " to " + newRemotePath + ": " + result.getLogMessage());
 143
 144         } catch (Exception e) {
 145             result = new RemoteOperationResult(e);
 146             Log.e(TAG, "Rename " + mFile.getRemotePath() + " to " + ((newRemotePath==null) ? mNewName : newRemotePath) + ": " + result.getLogMessage(), e);
 147
 148         } finally {
 149             if (move != null)
 150                 move.releaseConnection();
 151         }
 152         return result;
 153     }
 154
 155
 156     /**
 157      * Checks if the new name to set is valid in the file system
 158      *
 159      * The only way to be sure is trying to create a file with that name. It's made in the temporal directory
 160      * for downloads, out of any account, and then removed.
 161      *
 162      * IMPORTANT: The test must be made in the same file system where files are download. The internal storage
 163      * could be formatted with a different file system.
 164      *
 165      * TODO move this method, and maybe FileDownload.get***Path(), to a class with utilities specific for the interactions with the file system
 166      *
 167      * @return      'True' if a temporal file named with the name to set could be created in the file system where
 168      *              local files are stored.
 169      */
 170     private boolean isValidNewName() {
 171         // check tricky names
 172         if (mNewName == null || mNewName.length() <= 0 || mNewName.contains(File.separator) || mNewName.contains("%")) {
 173             return false;
 174         }
 175         // create a test file
 176         String tmpFolder = FileDownloader.getTemporalPath("");
 177         File testFile = new File(tmpFolder + mNewName);
 178         try {
 179             testFile.createNewFile();   // return value is ignored; it could be 'false' because the file already existed, that doesn't invalidate the name
 180         } catch (IOException e) {
 181             Log.i(TAG, "Test for validity of name " + mNewName + " in the file system failed");
 182             return false;
 183         }
 184         boolean result = (testFile.exists() && testFile.isFile());
 185
 186         // cleaning ; result is ignored, since there is not much we could do in case of failure, but repeat and repeat...
 187         testFile.delete();
 188
 189         return result;
 190     }
 191
 192
 193
 194     // move operation - TODO: find out why org.apache.jackrabbit.webdav.client.methods.MoveMethod is not used instead ¿?
 195     private class LocalMoveMethod extends DavMethodBase {
 196
 197         public LocalMoveMethod(String uri, String dest) {
 198             super(uri);
 199             addRequestHeader(new org.apache.commons.httpclient.Header("Destination", dest));
 200         }
 201
 202         @Override
 203         public String getName() {
 204             return "MOVE";
 205         }
 206
 207         @Override
 208         protected boolean isSuccess(int status) {
 209             return status == 201 || status == 204;
 210         }
 211
 212     }
 213
 214
 215 }