wip

Signed-off-by: alperozturk96 <alper_ozturk@proton.me>

Author: alperozturk96

app/src/main/java/com/nextcloud/utils/extensions/FileDataStorageManagerExtensions.kt

@@ -7,15 +7,20 @@
 
 package com.nextcloud.utils.extensions
 
+import com.nextcloud.client.database.dao.FileDao
 import com.nextcloud.client.database.entity.model.ShareeKey
 import com.nextcloud.client.database.entity.toOCCapability
 import com.owncloud.android.datamodel.FileDataStorageManager
 import com.owncloud.android.datamodel.OCFile
+import com.owncloud.android.lib.common.utils.Log_OC
 import com.owncloud.android.lib.resources.files.model.RemoteFile
 import com.owncloud.android.lib.resources.shares.OCShare
 import com.owncloud.android.lib.resources.status.OCCapability
+import com.owncloud.android.utils.FileStorageUtils
+import com.owncloud.android.utils.MimeTypeUtil
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import java.io.File
 
 private const val SHARE_PATH_QUERY_CHUNK_SIZE = 400
 
@@ -116,3 +121,132 @@ fun FileDataStorageManager.getNonEncryptedSubfolders(id: Long, accountName: Stri
 
 suspend fun FileDataStorageManager.getCapabilitiesByAccountName(accountName: String): OCCapability =
     capabilityDao.getByAccountName(accountName).toOCCapability()
+
+@Suppress("ReturnCount")
+fun FileDataStorageManager.moveFiles(ocFile: OCFile?, targetPath: String, targetParentPath: String) {
+    Log_OC.d(
+        FileDataStorageManager.TAG,
+        (
+            "moveLocalFile ==> ocFile: " +
+                (ocFile?.remotePath) +
+                " targetPath: " +
+                targetPath +
+                " targetParentPath: " +
+                targetParentPath
+            )
+    )
+
+    if (ocFile == null) {
+        Log_OC.e(FileDataStorageManager.TAG, "moveLocalFile: file is null, skipping")
+        return
+    }
+
+    if (!ocFile.fileExists()) {
+        Log_OC.e(FileDataStorageManager.TAG, "moveLocalFile: file does not exist, skipping")
+        return
+    }
+
+    if (OCFile.ROOT_PATH == ocFile.fileName) {
+        Log_OC.w(FileDataStorageManager.TAG, "moveLocalFile: cannot move root path")
+        return
+    }
+
+    if (ocFile.remotePath == targetPath) {
+        Log_OC.w(FileDataStorageManager.TAG, "moveLocalFile: source and target paths are identical, skipping")
+        return
+    }
+
+    val targetParent = getFileByPath(targetParentPath)
+    if (targetParent == null) {
+        Log_OC.e(FileDataStorageManager.TAG, "moveLocalFile: target parent folder not found: $targetParentPath")
+        return
+    }
+
+    if (!targetParent.isFolder) {
+        Log_OC.e(FileDataStorageManager.TAG, "moveLocalFile: target parent is not a folder: $targetParentPath")
+        return
+    }
+
+    val oldPath: String = ocFile.remotePath
+    val accountName = user.accountName
+    val defaultSavePath = FileStorageUtils.getSavePath(accountName)
+
+    val moved = moveLocalFiles(accountName, ocFile, defaultSavePath, targetPath)
+    if (!moved) return
+
+    val originalMediaPaths =
+        fileDao.moveFilesInDb(oldPath, targetPath, defaultSavePath, targetParent.fileId, accountName)
+
+    for (originalMediaPath in originalMediaPaths) {
+        deleteFileInMediaScan(originalMediaPath)
+        val newMediaPath = defaultSavePath + targetPath + originalMediaPath.substring(
+            (defaultSavePath + oldPath).length
+        )
+        FileDataStorageManager.triggerMediaScan(newMediaPath)
+    }
+}
+
+@Suppress("ReturnCount")
+private fun moveLocalFiles(accountName: String, ocFile: OCFile, defaultSavePath: String, targetPath: String): Boolean {
+    val localFile = File(FileStorageUtils.getDefaultSavePathFor(accountName, ocFile))
+    if (!localFile.exists()) {
+        Log_OC.d(FileDataStorageManager.TAG, "moveLocalFile: no local file to move at " + localFile.absolutePath)
+        return false
+    }
+
+    val targetFile = File(defaultSavePath + targetPath)
+    val targetFolder = targetFile.getParentFile()
+    if (targetFolder != null && !targetFolder.exists() && !targetFolder.mkdirs()) {
+        Log_OC.e(
+            FileDataStorageManager.TAG,
+            "moveLocalFile: failed to create parent folder " + targetFolder.absolutePath
+        )
+    }
+
+    if (!localFile.renameTo(targetFile)) {
+        Log_OC.e(
+            FileDataStorageManager.TAG,
+            (
+                "moveLocalFile: failed to rename " + localFile.absolutePath +
+                    " to " + targetFile.absolutePath
+                )
+        )
+        return false
+    }
+
+    return true
+}
+
+private fun FileDao.moveFilesInDb(
+    oldPath: String,
+    targetPath: String,
+    defaultSavePath: String,
+    targetParentId: Long,
+    accountName: String
+): List<String> {
+    val entities = getFolderWithDescendants("$oldPath%", accountName)
+    val oldStoragePrefix = defaultSavePath + oldPath
+    val newStoragePrefix = defaultSavePath + targetPath
+
+    val originalMediaPaths = entities
+        .filter { MimeTypeUtil.isMedia(it.contentType) && it.storagePath?.startsWith(oldStoragePrefix) == true }
+        .mapNotNull { it.storagePath }
+
+    val updated = entities.map { entity ->
+        val currentPath = entity.path.orEmpty()
+        val newPath = targetPath + currentPath.substring(oldPath.length)
+        entity.copy(
+            path = newPath,
+            pathDecrypted = if (entity.isEncrypted == 0) newPath else entity.pathDecrypted,
+            storagePath = if (entity.storagePath?.startsWith(oldStoragePrefix) == true) {
+                newStoragePrefix + entity.storagePath.substring(oldStoragePrefix.length)
+            } else {
+                entity.storagePath
+            },
+            parent = if (currentPath == oldPath) targetParentId else entity.parent
+        )
+    }
+
+    updateAll(updated)
+    return originalMediaPaths
+}