@capacitor-community/sqlite 3.3.3-1 → 3.3.3-2

package/ios/Plugin/Utils/UtilsFile.swift

@@ -12,6 +12,7 @@ import ZIPFoundation
 enum UtilsFileError: Error {
     case getFilePathFailed
     case copyFileFailed
+    case moveFileFailed
     case renameFileFailed
     case deleteFileFailed
     case getAssetsDatabasesPathFailed
@@ -25,6 +26,9 @@ enum UtilsFileError: Error {
     case copyFromAssetToDatabaseFailed(message: String)
     case unzipFromAssetToDatabaseFailed(message: String)
     case copyFromNamesFailed
+    case getFolderURLFailed(message: String)
+    case createDirFailed(message: String)
+    case moveAllDBSQLiteFailed(message: String)
 }
 // swiftlint:disable file_length
 // swiftlint:disable type_body_length
@@ -39,6 +43,70 @@ class UtilsFile {
         return exists && isDir.boolValue
     }
 
+    class func createDirCopyDB(url: URL) throws {
+        do {
+            var dirUrl = url
+            let dirPath: String = url.path
+            if !UtilsFile.isDirExist(dirPath: dirPath) {
+                // create the directory
+                try FileManager.default
+                    .createDirectory(at: dirUrl, withIntermediateDirectories: true)
+                // exclude the directory from iCloud Backup
+                try UtilsFile.setExcludeFromiCloudBackup(&dirUrl,
+                                                         isExcluded: true)
+                // move all SQLite database from Documents folder
+                // to this new directory
+                try UtilsFile.moveAllDBSQLite(dirUrl: dirUrl)
+            }
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            throw UtilsFileError.createDirFailed(message: message)
+        } catch UtilsFileError.moveAllDBSQLiteFailed(let message) {
+            throw UtilsFileError.createDirFailed(message: message)
+        } catch let error {
+            var msg: String = "createDir command failed :"
+            msg.append(" \(error.localizedDescription)")
+            throw UtilsFileError.createDirFailed(message: msg)
+        }
+
+    }
+
+    // MARK: - moveAllDBSQLite
+
+    class func moveAllDBSQLite(dirUrl: URL) throws {
+        // get the db list from Documents folder
+        do {
+            let databaseURL: URL = try UtilsFile
+                .getDatabasesUrl().absoluteURL
+            let fileList: [String] = try UtilsFile
+                .getFileList(path: databaseURL.path,
+                             ext: "SQLite.db")
+            for file in fileList {
+                let fromFileURL: URL = databaseURL
+                    .appendingPathComponent(file).absoluteURL
+                let toFileURL = dirUrl
+                    .appendingPathComponent(file).absoluteURL
+                let retB: Bool = try UtilsFile
+                    .moveFile(pathName: fromFileURL.path,
+                              toPathName: toFileURL.path, overwrite: true)
+                if !retB {
+                    let msg: String = "moveFile command failed :"
+                    throw UtilsFileError.moveAllDBSQLiteFailed(message: msg)
+                }
+            }
+
+        } catch UtilsFileError.getFileListFailed {
+            let msg: String = "getFileList command failed :"
+            throw UtilsFileError.moveAllDBSQLiteFailed(message: msg)
+        } catch UtilsFileError.moveFileFailed {
+            let msg: String = "moveFile command failed :"
+            throw UtilsFileError.moveAllDBSQLiteFailed(message: msg)
+        } catch let error {
+            var msg: String = "moveAllDBSQLite command failed :"
+            msg.append(" \(error.localizedDescription)")
+            throw UtilsFileError.moveAllDBSQLiteFailed(message: msg)
+        }
+
+    }
     // MARK: - IsFileExist
 
     class func isFileExist(filePath: String) -> Bool {
@@ -49,11 +117,12 @@ class UtilsFile {
         }
         return ret
     }
-    class func isFileExist(fileName: String) -> Bool {
+    class func isFileExist(databaseLocation: String, fileName: String) -> Bool {
         var ret: Bool = false
         do {
             let filePath: String =
                 try UtilsFile.getFilePath(
+                    databaseLocation: databaseLocation,
                     fileName: fileName)
             ret = UtilsFile.isFileExist(filePath: filePath)
             return ret
@@ -64,14 +133,58 @@ class UtilsFile {
         }
     }
 
-    // MARK: - GetFilePath
+    // MARK: - getFolderURL
 
-    class func getFilePath(fileName: String) throws -> String {
+    class func getFolderURL(folderPath: String) throws -> URL {
         do {
-            let url = try getDatabasesUrl()
-            return url.appendingPathComponent("\(fileName)").path
+            let databaseURL = try UtilsFile.getDatabasesUrl().absoluteURL
+            var dbPathURL: URL
+            let first = folderPath.split(separator: "/", maxSplits: 1)
+            if first[0] == "Applications" {
+                dbPathURL = try UtilsFile.getApplicationURL().absoluteURL
+            } else if first[0] == "Library" {
+                dbPathURL = try UtilsFile.getLibraryURL().absoluteURL
+            } else if first[0] == "Documents" || first[0] == "default" {
+                dbPathURL = databaseURL
+            } else {
+                var msg: String = "getFolderURL command failed :"
+                msg.append(" Folder '\(first[0])' not allowed")
+                throw UtilsFileError.getFolderURLFailed(message: msg)
+            }
+            if first.count > 1 {
+                dbPathURL = dbPathURL
+                    .appendingPathComponent(String(first[1])).absoluteURL
+            }
+            return dbPathURL
         } catch UtilsFileError.getDatabasesURLFailed {
-            print("Error: getDatabasesUrl Failed")
+            throw UtilsFileError.getFolderURLFailed(message: "getDatabasesURLFailed")
+        } catch UtilsFileError.getApplicationURLFailed {
+            throw UtilsFileError
+            .getFolderURLFailed(message: "getApplicationURLFailed")
+        } catch let error {
+            var msg: String = "getFolderURL command failed :"
+            msg.append(" \(error.localizedDescription)")
+            throw UtilsFileError.getFolderURLFailed(message: msg)
+        }
+    }
+
+    // MARK: - GetFilePath
+
+    class func getFilePath(databaseLocation: String,
+                           fileName: String) throws -> String {
+        do {
+            let url: URL = try UtilsFile
+                .getFolderURL(folderPath: databaseLocation)
+            if databaseLocation.prefix(9) != "Documents" &&
+                databaseLocation.prefix(7) != "default" {
+                // create the directories if they do not exists
+                try UtilsFile.createDirCopyDB(url: url)
+            }
+            let dbPath: String = url
+                .appendingPathComponent("\(fileName)").path
+            return dbPath
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            print("Error: getFilePath Failed \(message)")
             throw UtilsFileError.getFilePathFailed
         }
     }
@@ -157,7 +270,6 @@ class UtilsFile {
 
     class func getAssetsDatabasesPath() throws -> URL {
         if let appFolder = Bundle.main.resourceURL {
-            print("getAssetsDatabasesPath appFolder \(appFolder)")
             return appFolder.appendingPathComponent("public/assets/databases")
         } else {
             print("Error: getAssetsDatabasePath did not find app folder")
@@ -230,16 +342,16 @@ class UtilsFile {
 
     // MARK: - CopyFromAssetToDatabase
 
-    class func copyFromAssetToDatabase(fromDb: String, toDb: String,
-                                       overwrite: Bool) throws {
+    class func copyFromAssetToDatabase(databaseLocation: String, fromDb: String,
+                                       toDb: String, overwrite: Bool) throws {
         do {
             let uAsset: URL = try getAssetsDatabasesPath()
                 .appendingPathComponent(fromDb)
-            let pAsset: String = uAsset.path
-            let uDb: URL = try getDatabasesUrl()
+
+            let uDb: URL = try getFolderURL(folderPath: databaseLocation)
                 .appendingPathComponent(toDb)
-            let pDb: String = uDb.path
-            let bRet: Bool = try copyFile(pathName: pAsset, toPathName: pDb,
+            let bRet: Bool = try copyFile(pathName: uAsset.path,
+                                          toPathName: uDb.path,
                                           overwrite: overwrite)
             if bRet {
                 return
@@ -252,11 +364,9 @@ class UtilsFile {
             let msg = "Error: getAssetsDatabasesPath Failed"
             print("\(msg)")
             throw UtilsFileError.copyFromAssetToDatabaseFailed(message: msg)
-        } catch UtilsFileError.getDatabasesURLFailed {
-            let msg = "Error: getDatabasesUrl Failed"
-            print("\(msg)")
-
-            throw UtilsFileError.copyFromAssetToDatabaseFailed(message: msg)
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            print("Error: getFolderUrl Failed \(message)")
+            throw UtilsFileError.copyFromAssetToDatabaseFailed(message: message)
         } catch UtilsFileError.copyFileFailed {
             let msg = "Error: copyFile Failed"
             print("\(msg)")
@@ -270,7 +380,8 @@ class UtilsFile {
 
     }
 
-    class func unzipFromAssetToDatabase(zip: String, overwrite: Bool) throws {
+    class func unzipFromAssetToDatabase(databaseLocation: String, zip: String,
+                                        overwrite: Bool) throws {
         do {
             let zipAsset: URL = try getAssetsDatabasesPath()
                 .appendingPathComponent(zip)
@@ -279,10 +390,10 @@ class UtilsFile {
                 print("\(msg)")
                 throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
             }
+            let uDb: URL = try getFolderURL(folderPath: databaseLocation)
             for entry in archive {
                 let dbEntry = setPathSuffix(sDb: entry.path)
-                let zipCopy: URL = try getDatabasesUrl()
-                    .appendingPathComponent(dbEntry)
+                let zipCopy: URL = uDb.appendingPathComponent(dbEntry)
                 do {
                     let isExist: Bool = isFileExist(filePath: zipCopy.path)
                     if !isExist || overwrite {
@@ -302,10 +413,9 @@ class UtilsFile {
             let msg = "Error: getAssetsDatabasesPath Failed"
             print("\(msg)")
             throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
-        } catch UtilsFileError.getDatabasesURLFailed {
-            let msg = "Error: getDatabasesUrl Failed"
-            print("\(msg)")
-            throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: msg)
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            print("Error: getFolderUrl Failed \(message)")
+            throw UtilsFileError.unzipFromAssetToDatabaseFailed(message: message)
         } catch let error {
             let msg = "Error: \(error)"
             print("\(msg)")
@@ -313,6 +423,36 @@ class UtilsFile {
         }
     }
 
+    // MARK: - MoveFile
+
+    class func moveFile(pathName: String, toPathName: String, overwrite: Bool) throws -> Bool {
+        if pathName.count > 0 && toPathName.count > 0 {
+            let isPath = isFileExist(filePath: pathName)
+            if isPath {
+                do {
+                    let isExist: Bool = isFileExist(filePath: toPathName)
+                    if !isExist || overwrite {
+                        if overwrite && isExist {
+                            _ = try deleteFile(filePath: toPathName)
+                        }
+                        let fileManager = FileManager.default
+                        try fileManager.moveItem(atPath: pathName,
+                                                 toPath: toPathName)
+                    }
+                    return true
+                } catch let error {
+                    print("Error: \(error)")
+                    throw UtilsFileError.moveFileFailed
+                }
+            } else {
+                print("Error: MoveFile Failed pathName does not exist")
+                throw UtilsFileError.moveFileFailed
+            }
+        } else {
+            print("Error: MoveFile Failed paths count = 0")
+            throw UtilsFileError.moveFileFailed
+        }
+    }
     // MARK: - CopyFile
 
     class func copyFile(pathName: String, toPathName: String, overwrite: Bool) throws -> Bool {
@@ -346,12 +486,17 @@ class UtilsFile {
 
     // MARK: - CopyFile
 
-    class func copyFile(fileName: String, toFileName: String)
+    class func copyFile(fileName: String, toFileName: String,
+                        databaseLocation: String)
     throws -> Bool {
         var ret: Bool = false
         do {
-            let fromPath: String = try getFilePath(fileName: fileName)
-            let toPath: String = try getFilePath(fileName: toFileName)
+            let fromPath: String = try
+                getFilePath(databaseLocation: databaseLocation,
+                            fileName: fileName)
+            let toPath: String = try
+                getFilePath(databaseLocation: databaseLocation,
+                            fileName: toFileName)
             ret = try copyFile(pathName: fromPath, toPathName: toPath, overwrite: true)
             return ret
         } catch UtilsFileError.getFilePathFailed {
@@ -387,10 +532,13 @@ class UtilsFile {
 
     // MARK: - DeleteFile
 
-    class func deleteFile(fileName: String) throws -> Bool {
+    class func deleteFile(fileName: String,
+                          databaseLocation: String) throws -> Bool {
         var ret: Bool = false
         do {
-            let filePath: String = try getFilePath(fileName: fileName)
+            let filePath: String = try
+                getFilePath(databaseLocation: databaseLocation,
+                            fileName: fileName)
             ret = try deleteFile(filePath: filePath)
         } catch let error {
             print("Error: \(error)")
@@ -418,14 +566,15 @@ class UtilsFile {
 
     // MARK: - RenameFile
 
-    class func renameFile (filePath: String, toFilePath: String)
-    throws {
+    class func renameFile (filePath: String, toFilePath: String,
+                           databaseLocation: String) throws {
         let fileManager = FileManager.default
         do {
             if isFileExist(filePath: toFilePath) {
                 let fileName = URL(
                     fileURLWithPath: toFilePath).lastPathComponent
-                try  _ = deleteFile(fileName: fileName)
+                try  _ = deleteFile(fileName: fileName,
+                                    databaseLocation: databaseLocation)
             }
             try fileManager.moveItem(atPath: filePath,
                                      toPath: toFilePath)
@@ -434,6 +583,19 @@ class UtilsFile {
             throw UtilsFileError.renameFileFailed
         }
     }
+
+    class func setExcludeFromiCloudBackup(_ fileOrDirectoryURL: inout URL, isExcluded: Bool) throws {
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = isExcluded
+        try fileOrDirectoryURL.setResourceValues(values)
+    }
+
+    class func getExcludeFromiCloudBackup(_ fileOrDirectoryURL: URL) throws -> Bool {
+        let keySet: Set<URLResourceKey> = [.isExcludedFromBackupKey]
+
+        return try
+            fileOrDirectoryURL.resourceValues(forKeys: keySet).isExcludedFromBackup ?? false
+    }
 }
 // swiftlint:enable type_body_length
 // swiftlint:enable file_length

package/ios/Plugin/Utils/UtilsMigrate.swift

@@ -9,7 +9,6 @@ enum UtilsMigrateError: Error {
     case addSQLiteSuffix(message: String)
     case getMigratableList(message: String)
     case deleteOldDatabases(message: String)
-    case getFolderURL(message: String)
 }
 
 class UtilsMigrate {
@@ -19,7 +18,7 @@ class UtilsMigrate {
     class func getMigratableList(folderPath: String) throws -> [String] {
         var mDbList: [String] = []
         do {
-            let dbPathURL: URL = try UtilsMigrate
+            let dbPathURL: URL = try UtilsFile
                 .getFolderURL(folderPath: folderPath)
             var isDir = ObjCBool(true)
             if FileManager.default.fileExists(atPath: dbPathURL.relativePath,
@@ -34,9 +33,9 @@ class UtilsMigrate {
                 throw UtilsMigrateError.getMigratableList(message: msg)
             }
 
-        } catch UtilsFileError.getDatabasesURLFailed {
+        } catch UtilsFileError.getFolderURLFailed {
             throw UtilsMigrateError
-            .getMigratableList(message: "getDatabasesURLFailed")
+            .getMigratableList(message: "getFolderURLFailed")
         } catch UtilsFileError.getFileListFailed {
             throw UtilsMigrateError.getMigratableList(message: "getFileListFailed")
         } catch let error {
@@ -50,12 +49,14 @@ class UtilsMigrate {
 
     // swiftlint:disable function_body_length
     // swiftlint:disable cyclomatic_complexity
-    class func addSQLiteSuffix(folderPath: String, dbList: [String]) throws {
+    class func addSQLiteSuffix(databaseLocation: String, folderPath: String,
+                               dbList: [String]) throws {
         var fromFile: String = ""
         var toFile: String = ""
         do {
-            let databaseURL = try UtilsFile.getDatabasesUrl().absoluteURL
-            let dbPathURL: URL = try UtilsMigrate
+            let databaseURL: URL = try UtilsFile
+                .getFolderURL(folderPath: databaseLocation)
+            let dbPathURL: URL = try UtilsFile
                 .getFolderURL(folderPath: folderPath)
             var isDir = ObjCBool(true)
             if FileManager.default.fileExists(atPath: dbPathURL.relativePath,
@@ -106,7 +107,7 @@ class UtilsMigrate {
         } catch UtilsFileError.getDatabasesURLFailed {
             throw UtilsMigrateError
             .addSQLiteSuffix(message: "getDatabasesURLFailed")
-        } catch UtilsMigrateError.getFolderURL(let message) {
+        } catch UtilsFileError.getFolderURLFailed(let message) {
             throw UtilsMigrateError.addSQLiteSuffix(message: message)
         } catch UtilsFileError.getFileListFailed {
             throw UtilsMigrateError.addSQLiteSuffix(message: "getFileListFailed")
@@ -129,7 +130,7 @@ class UtilsMigrate {
     // swiftlint:disable cyclomatic_complexity
     class func deleteOldDatabases(folderPath: String, dbList: [String]) throws {
         do {
-            let dbPathURL: URL = try UtilsMigrate
+            let dbPathURL: URL = try UtilsFile
                 .getFolderURL(folderPath: folderPath)
             var isDir = ObjCBool(true)
             if FileManager.default.fileExists(atPath: dbPathURL.relativePath,
@@ -176,7 +177,7 @@ class UtilsMigrate {
         } catch UtilsFileError.getDatabasesURLFailed {
             throw UtilsMigrateError
             .addSQLiteSuffix(message: "getDatabasesURLFailed")
-        } catch UtilsMigrateError.getFolderURL(let message) {
+        } catch UtilsFileError.getFolderURLFailed(let message) {
             throw UtilsMigrateError.addSQLiteSuffix(message: message)
         } catch UtilsFileError.getFileListFailed {
             throw UtilsMigrateError.addSQLiteSuffix(message: "getFileListFailed")
@@ -191,38 +192,4 @@ class UtilsMigrate {
     // swiftlint:enable cyclomatic_complexity
     // swiftlint:enable function_body_length
 
-    // MARK: - getFolderURL
-    class func getFolderURL(folderPath: String) throws -> URL {
-        do {
-            let databaseURL = try UtilsFile.getDatabasesUrl().absoluteURL
-            var dbPathURL: URL
-            let first = folderPath.split(separator: "/", maxSplits: 1)
-            if first[0] == "Applications" {
-                dbPathURL = try UtilsFile.getApplicationURL().absoluteURL
-            } else if first[0] == "Library" {
-                dbPathURL = try UtilsFile.getLibraryURL().absoluteURL
-            } else if first[0] == "Documents" || first[0] == "default" {
-                dbPathURL = databaseURL
-            } else {
-                var msg: String = "addSQLiteSuffix command failed :"
-                msg.append(" Folder '\(first[0])' not allowed")
-                throw UtilsMigrateError.getFolderURL(message: msg)
-            }
-            if first.count > 1 {
-                dbPathURL = dbPathURL
-                    .appendingPathComponent(String(first[1])).absoluteURL
-            }
-            return dbPathURL
-        } catch UtilsFileError.getDatabasesURLFailed {
-            throw UtilsMigrateError.getFolderURL(message: "getDatabasesURLFailed")
-        } catch UtilsFileError.getApplicationURLFailed {
-            throw UtilsMigrateError
-            .getFolderURL(message: "getApplicationURLFailed")
-        } catch let error {
-            var msg: String = "getFolderURL command failed :"
-            msg.append(" \(error.localizedDescription)")
-            throw UtilsMigrateError.getFolderURL(message: msg)
-        }
-    }
-
 }

package/ios/Plugin/Utils/UtilsNCDatabase.swift

@@ -16,10 +16,10 @@ class UtilsNCDatabase {
 
     class func getNCDatabasePath(folderPath: String, database: String) throws -> String {
         do {
-            let dbPathURL: URL = try UtilsMigrate
+            let dbPathURL: URL = try UtilsFile
                 .getFolderURL(folderPath: folderPath)
             return dbPathURL.appendingPathComponent("\(database)").path
-        } catch UtilsMigrateError.getFolderURL(let message) {
+        } catch UtilsFileError.getFolderURLFailed(let message) {
             throw UtilsNCDatabaseError.getNCDatabasePath(message: message)
         } catch let error {
             var msg: String = "getNCDatabasePath command failed :"

package/ios/Plugin/Utils/UtilsSQLCipher.swift

@@ -43,9 +43,12 @@ enum State: String {
 // swiftlint:disable type_body_length
 class UtilsSQLCipher {
 
-    class func getDatabaseState(databaseName: String) -> State {
+    class func getDatabaseState(databaseLocation: String,
+                                databaseName: String) -> State {
         do {
-            let path: String  = try UtilsFile.getFilePath(fileName: databaseName)
+            let path: String  = try UtilsFile
+                .getFilePath(databaseLocation: databaseLocation,
+                             fileName: databaseName)
             if UtilsFile.isFileExist(filePath: path) {
                 do {
                     try openDBNoPassword(dBPath: path)
@@ -586,17 +589,17 @@ class UtilsSQLCipher {
 
     // MARK: - DeleteDB
 
-    class func deleteDB(databaseName: String) throws {
-        if let dir = FileManager.default.urls(
-            for: .documentDirectory,
-            in: .userDomainMask).first {
+    class func deleteDB(databaseLocation: String, databaseName: String) throws {
+        do {
+            let dir: URL = try UtilsFile
+                .getFolderURL(folderPath: databaseLocation)
+
             let fileURL = dir.appendingPathComponent(databaseName)
             let isFileExists = FileManager.default.fileExists(
                 atPath: fileURL.path)
             if isFileExists {
                 do {
                     try FileManager.default.removeItem(at: fileURL)
-                    print("Database \(databaseName) deleted")
                 } catch let error {
                     var msg: String = "Error: deleteDB: "
                     msg.append(" \(error.localizedDescription)")
@@ -604,6 +607,9 @@ class UtilsSQLCipher {
                         message: msg)
                 }
             }
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            let msg = "Error: deleteDB: \(message)"
+            throw UtilsSQLCipherError.deleteDB(message: msg)
         }
     }
 
@@ -663,10 +669,11 @@ class UtilsSQLCipher {
 
     // MARK: - RestoreDB
 
-    class func restoreDB(databaseName: String) throws {
-        if let dir = FileManager.default.urls(
-            for: .documentDirectory,
-            in: .userDomainMask).first {
+    class func restoreDB(databaseLocation: String, databaseName: String) throws {
+        do {
+            let dir: URL = try UtilsFile
+                .getFolderURL(folderPath: databaseLocation)
+
             let fileURL = dir.appendingPathComponent(databaseName)
             let backupURL = dir
                 .appendingPathComponent("backup-\(databaseName)")
@@ -678,13 +685,11 @@ class UtilsSQLCipher {
                 if isFileExists {
                     do {
                         try FileManager.default.removeItem(at: fileURL)
-                        print("Database \(databaseName) deleted")
                         try FileManager
                             .default.copyItem(atPath: backupURL.path,
                                               toPath: fileURL.path)
                         try FileManager.default
                             .removeItem(at: backupURL)
-                        print("Database backup-\(databaseName) deleted")
                     } catch {
                         var msg = "Error: restoreDB : \(databaseName)"
                         msg += " \(error)"
@@ -704,19 +709,20 @@ class UtilsSQLCipher {
                 throw UtilsSQLCipherError.restoreDB(
                     message: msg)
             }
-        } else {
-            let msg = "Error: restoreDB: FileManager.default.urls"
-            throw UtilsSQLCipherError.restoreDB(
-                message: msg)
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            let msg = "Error: restoreDB: \(message)"
+            throw UtilsSQLCipherError.restoreDB(message: msg)
         }
     }
 
     // MARK: - deleteBackupDB
 
-    class func deleteBackupDB(databaseName: String) throws {
-        if let dir = FileManager.default.urls(
-            for: .documentDirectory,
-            in: .userDomainMask).first {
+    class func deleteBackupDB(databaseLocation: String,
+                              databaseName: String) throws {
+
+        do {
+            let dir: URL = try UtilsFile
+                .getFolderURL(folderPath: databaseLocation)
             let backupURL = dir
                 .appendingPathComponent("backup-\(databaseName)")
             let isBackupExists = FileManager.default.fileExists(
@@ -725,7 +731,6 @@ class UtilsSQLCipher {
                 do {
                     try FileManager.default
                         .removeItem(at: backupURL)
-                    print("Database backup-\(databaseName) deleted")
                 } catch {
                     var msg = "Error: deleteBackupDB : \(databaseName)"
                     msg += " \(error)"
@@ -737,8 +742,8 @@ class UtilsSQLCipher {
                 msg.append("backup-\(databaseName) does not exist")
                 throw UtilsSQLCipherError.deleteBackupDB(message: msg)
             }
-        } else {
-            let msg = "Error: deleteBackupDB: FileManager.default.urls"
+        } catch UtilsFileError.getFolderURLFailed(let message) {
+            let msg = "Error: deleteBackupDB: \(message)"
             throw UtilsSQLCipherError.deleteBackupDB(
                 message: msg)
         }