@capacitor-community/sqlite 4.1.1 → 4.2.1

package/README.md

@@ -16,7 +16,7 @@
   <a href="https://www.npmjs.com/package/@capacitor-community/sqlite"><img src="https://img.shields.io/npm/dw/@capacitor-community/sqlite?style=flat-square" /></a>
   <a href="https://www.npmjs.com/package/@capacitor-community/sqlite"><img src="https://img.shields.io/npm/v/@capacitor-community/sqlite?style=flat-square" /></a>
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-<a href="#contributors-"><img src="https://img.shields.io/badge/all%20contributors-17-orange?style=flat-square" /></a>
+<a href="#contributors-"><img src="https://img.shields.io/badge/all%20contributors-22-orange?style=flat-square" /></a>
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 </p>
 
@@ -27,8 +27,21 @@
 | Quéau Jean Pierre | [jepiqueau](https://github.com/jepiqueau) |        |
 
 To install:
+
+```
+npm install --save @capacitor-community/sqlite
+npx cap sync
+```
+
+```
+yarn install --save @capacitor-community/sqlite
+npx cap sync
+```
+
 ```
-npm install @capacitor-community/sqlite
+pnpm install --save @capacitor-community/sqlite
+pnpm install --save @jeep-sqlite
+pnpm install --save sql.js
 npx cap sync
 ```
 
@@ -78,6 +91,7 @@ See [#301](https://github.com/capacitor-community/sqlite/issues/301) and [SO que
 cd electron
 npm install --save sqlite3
 npm install --save jszip
+npm install --save node-fetch
 npm install --save-dev @types/sqlite3
 ```
 
@@ -137,7 +151,7 @@ npm install --save-dev @types/sqlite3
 | closeNCConnection           | ✅      | ✅  | ❌        | ❌  |
 | isNCDatabase                | ✅      | ✅  | ❌        | ❌  |
 | transaction                 | ✅      | ✅  | ✅        | ✅  |
-| getFromHTTPRequest          | ❌      | ❌  | ✅        | ✅  | since 4.1.1
+| getFromHTTPRequest          | ✅      | ✅  | ✅        | ✅  | since 4.2.0
 
 
 ## Documentation & APIs
@@ -210,7 +224,7 @@ npm install --save-dev @types/sqlite3
 
 The iOS and Android codes are using `SQLCipher` allowing for database encryption.
 The iOS codes is using `ZIPFoundation` for unzipping assets files
-The Electron code is using `sqlite3`.
+The Electron code is using `sqlite3` and `node-fetch` from 4.2.0.
 The Web code is using the Stencil component `jeep-sqlite` based on `sql.js`, `localforage`. and `jszip`  
 
 ## Contributors ✨
@@ -242,6 +256,7 @@ Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/d
   <a href="https://github.com/antoniovlx" title="antoniovlx"><img src="https://github.com/antoniovlx.png?size=100" width="50" height="50" /></a>
   <a href="https://github.com/HarelM" title="HarelM"><img src="https://github.com/HarelM.png?size=100" width="50" height="50" /></a>
   <a href="https://github.com/rdlabo" title="rdlabo"><img src="https://github.com/rdlabo.png?size=100" width="50" height="50" /></a>
+  <a href="https://github.com/axkristiansen" title="rdlabo"><img src="https://github.com/axkristiansen.png?size=100" width="50" height="50" /></a>
 </p>
 
 <!-- markdownlint-enable -->

package/android/src/main/java/com/getcapacitor/community/database/sqlite/CapacitorSQLite.java

@@ -17,6 +17,7 @@ import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.JsonSQ
 import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.UtilsJson;
 import com.getcapacitor.community.database.sqlite.SQLite.SqliteConfig;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsBiometric;
+import com.getcapacitor.community.database.sqlite.SQLite.UtilsDownloadFromHTTP;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsFile;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsMigrate;
 import com.getcapacitor.community.database.sqlite.SQLite.UtilsNCDatabase;
@@ -46,6 +47,7 @@ public class CapacitorSQLite {
     private final UtilsJson uJson = new UtilsJson();
     private final UtilsMigrate uMigrate = new UtilsMigrate();
     private final UtilsNCDatabase uNCDatabase = new UtilsNCDatabase();
+    private final UtilsDownloadFromHTTP uHTTP = new UtilsDownloadFromHTTP();
     private UtilsSecret uSecret;
     private SharedPreferences sharedPreferences = null;
     private MasterKey masterKeyAlias;
@@ -537,6 +539,14 @@ public class CapacitorSQLite {
         }
     }
 
+    public void getFromHTTPRequest(String url) throws Exception {
+        try {
+            uHTTP.download(context, url);
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
     public Boolean checkConnectionsConsistency(JSArray dbNames, JSArray openModes) throws Exception {
         Set<String> keys = new HashSet<String>(Collections.list(dbDict.keys()));
         String msg = "All Native Connections released";

package/android/src/main/java/com/getcapacitor/community/database/sqlite/CapacitorSQLitePlugin.java

@@ -12,12 +12,10 @@ import com.getcapacitor.annotation.CapacitorPlugin;
 import com.getcapacitor.community.database.sqlite.SQLite.Database;
 import com.getcapacitor.community.database.sqlite.SQLite.ImportExportJson.JsonSQLite;
 import com.getcapacitor.community.database.sqlite.SQLite.SqliteConfig;
-
 import java.util.Collections;
 import java.util.Dictionary;
 import java.util.Hashtable;
 import java.util.List;
-
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
@@ -1225,9 +1223,9 @@ public class CapacitorSQLitePlugin extends Plugin {
             try {
                 Dictionary<Integer, JSONObject> upgDict = implementation.addUpgradeStatement(upgrade);
 
-                if (versionUpgrades.get(dbName) != null){
+                if (versionUpgrades.get(dbName) != null) {
                     List<Integer> keys = Collections.list(upgDict.keys());
-                        for (Integer versionKey : keys) {
+                    for (Integer versionKey : keys) {
                         JSONObject upgObj = upgDict.get(versionKey);
 
                         versionUpgrades.get(dbName).put(versionKey, upgObj);
@@ -1362,7 +1360,7 @@ public class CapacitorSQLitePlugin extends Plugin {
         JSObject retObj = new JSObject();
         JsonSQLite retJson = new JsonSQLite();
         if (!call.getData().has("database")) {
-            String msg = "ExportToJson: Must provide a database name";
+            String msg = "DeleteExportedRows: Must provide a database name";
             rHandler.retResult(call, null, msg);
             return;
         }
@@ -1418,7 +1416,62 @@ public class CapacitorSQLitePlugin extends Plugin {
      */
     @PluginMethod
     public void getFromHTTPRequest(PluginCall call) {
-        call.unimplemented("Not implemented on Android.");
+        if (!call.getData().has("url")) {
+            String msg = "GetFromHTTPRequest: Must provide a database url";
+            rHandler.retResult(call, null, msg);
+            return;
+        }
+        String url = call.getString("url");
+        if (implementation != null) {
+            Runnable setHTTPRunnable = new Runnable() {
+                @Override
+                public void run() {
+                    android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
+                    try {
+                        implementation.getFromHTTPRequest(url);
+                        getActivity()
+                            .runOnUiThread(
+                                new Runnable() {
+                                    @Override
+                                    public void run() {
+                                        rHandler.retResult(call, null, null);
+                                        return;
+                                    }
+                                }
+                            );
+                    } catch (Exception e) {
+                        getActivity()
+                            .runOnUiThread(
+                                new Runnable() {
+                                    @Override
+                                    public void run() {
+                                        String msg = "GetFromHTTPRequest: " + e.getMessage();
+                                        rHandler.retResult(call, null, msg);
+                                        return;
+                                    }
+                                }
+                            );
+                    }
+                }
+            };
+            Thread myHttpThread = new Thread(setHTTPRunnable);
+            myHttpThread.start();
+            while (myHttpThread.isAlive());
+            System.out.println("Thread Exiting!");
+            /*            try {
+                implementation.getFromHTTPRequest(url);
+                rHandler.retResult(call, null, null);
+                return;
+            } catch (Exception e) {
+                String msg = "GetFromHTTPRequest: " + e.getMessage();
+                rHandler.retResult(call, null, msg);
+                return;
+            }
+  */
+        } else {
+            rHandler.retResult(call, null, loadMessage);
+            return;
+        }
     }
 
     private void AddObserversToNotificationCenter() {

package/android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/UtilsDownloadFromHTTP.java

@@ -0,0 +1,116 @@
+package com.getcapacitor.community.database.sqlite.SQLite;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+public class UtilsDownloadFromHTTP {
+
+    private static final String TAG = UtilsDownloadFromHTTP.class.getName();
+    private static final int BUFFER_SIZE = 4096;
+    private final UtilsFile _uFile = new UtilsFile();
+
+    public void download(Context context, String fileUrl) throws Exception {
+        AssetManager assetManager = context.getAssets();
+        String fileName = fileUrl.substring(fileUrl.lastIndexOf('/') + 1);
+        String dbName = fileName;
+        Boolean isZip = false;
+        if (!fileName.contains("SQLite.db")) {
+            if (_uFile.getFileExtension((fileName)).equals("db")) {
+                dbName = fileName.substring(0, fileName.length() - 3) + "SQLite.db";
+            }
+            if (_uFile.isLast(fileName, ".zip")) {
+                isZip = true;
+            }
+        }
+        File cacheDir = context.getCacheDir();
+        String cachePath = cacheDir.getAbsolutePath();
+        String tmpFilePath = cachePath + File.separator + dbName;
+        String databasePath = _uFile.getDatabaseDirectoryPath(context);
+        File databaseDir = new File(databasePath);
+        try {
+            // delete file if exists in cache
+            Boolean isExists = _uFile.isPathExists(tmpFilePath);
+            if (isExists) {
+                _uFile.deleteFile(cachePath, dbName);
+            }
+            downloadFileToCache(fileUrl, cachePath);
+            if (isZip) {
+                _uFile.unzipCopyDatabase(cachePath, null, tmpFilePath, true);
+                // delete zip file from cache
+                _uFile.deleteFile(cachePath, dbName);
+            }
+            // move files to database folder
+            _uFile.moveAllDBs(cacheDir, databaseDir);
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    public static void downloadFileToCache(String fileURL, String cacheDir) throws Exception {
+        HttpURLConnection httpConn = null;
+        try {
+            URL url = new URL(fileURL);
+            httpConn = (HttpURLConnection) url.openConnection();
+            int responseCode = httpConn.getResponseCode();
+            if (responseCode == HttpURLConnection.HTTP_OK) {
+                String fileName = "";
+                String disposition = httpConn.getHeaderField("Content-Disposition");
+                //                String contentType = httpConn.getContentType();
+                int contentLength = httpConn.getContentLength();
+
+                if (disposition != null) {
+                    // extracts file name from header field
+                    int index = disposition.indexOf("filename=");
+                    if (index > 0) {
+                        fileName = disposition.substring(index + 10, disposition.length() - 1);
+                    }
+                } else {
+                    // extracts file name from URL
+                    fileName = fileURL.substring(fileURL.lastIndexOf("/") + 1);
+                }
+                String dbName = fileName;
+                if (!fileName.contains("SQLite.db")) {
+                    if (fileName.substring(fileName.length() - 3).equals(".db")) {
+                        dbName = fileName.substring(0, fileName.length() - 3) + "SQLite.db";
+                    }
+                }
+
+                //                System.out.println("Content-Type = " + contentType);
+                //                System.out.println("Content-Disposition = " + disposition);
+                //                System.out.println("Content-Length = " + contentLength);
+                //                System.out.println("fileName = " + fileName);
+                // opens input stream from the HTTP connection
+                InputStream inputStream = httpConn.getInputStream();
+                // create temporary file path
+                String tmpFilePath = cacheDir + File.separator + dbName;
+                // opens an output stream to save into file
+                FileOutputStream outputStream = new FileOutputStream(tmpFilePath);
+                int bytesRead = -1;
+                byte[] buffer = new byte[BUFFER_SIZE];
+                while ((bytesRead = inputStream.read(buffer)) != -1) {
+                    outputStream.write(buffer, 0, bytesRead);
+                }
+
+                outputStream.close();
+                inputStream.close();
+
+                System.out.println("File " + fileName + " downloaded (" + contentLength + ")");
+            } else {
+                String msg = "No file to download. Server replied HTTP code: " + responseCode;
+                throw new IOException(msg);
+            }
+        } catch (IOException e) {
+            throw new Exception(e);
+        } finally {
+            if (httpConn != null) {
+                httpConn.disconnect();
+            }
+        }
+    }
+}

package/android/src/main/java/com/getcapacitor/community/database/sqlite/SQLite/UtilsFile.java

@@ -2,7 +2,9 @@ package com.getcapacitor.community.database.sqlite.SQLite;
 
 import android.content.Context;
 import android.content.res.AssetManager;
+import android.os.Build;
 import android.util.Log;
+import androidx.annotation.RequiresApi;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
@@ -10,8 +12,16 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.channels.FileChannel;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 
@@ -33,6 +43,10 @@ public class UtilsFile {
         }
     }
 
+    public String getDatabaseDirectoryPath(Context context) {
+        return context != null && context.getDatabasePath("x") != null ? context.getDatabasePath("x").getParent() : "";
+    }
+
     public String[] getListOfFiles(Context context) {
         String[] files = context.databaseList();
         List<String> dbs = new ArrayList<>();
@@ -64,6 +78,10 @@ public class UtilsFile {
         return file.delete();
     }
 
+    public Boolean deleteFile(File file) {
+        return file.delete();
+    }
+
     public void copyFromAssetsToDatabase(Context context, Boolean overwrite) throws Exception {
         AssetManager assetManager = context.getAssets();
         String assetsDatabasePath = "public/assets/databases";
@@ -99,7 +117,8 @@ public class UtilsFile {
                     if (isLast(fileName, ".zip")) {
                         // unzip file and extract databases
                         String zipPathName = assetsDatabasePath + "/" + fileName;
-                        unzipCopyDatabase(context, assetManager, zipPathName, assetsDatabasePath, overwrite);
+                        String databasePath = getDatabaseDirectoryPath(context);
+                        unzipCopyDatabase(databasePath, assetManager, zipPathName, overwrite);
                     }
                 }
                 return;
@@ -109,26 +128,33 @@ public class UtilsFile {
         }
     }
 
-    public void unzipCopyDatabase(Context context, AssetManager asm, String zipPath, String assetsDatabasePath, Boolean overwrite)
-        throws IOException {
-        InputStream is;
+    public void unzipCopyDatabase(String databasePath, AssetManager asm, String zipPath, Boolean overwrite) throws IOException {
+        InputStream is = null;
+        FileInputStream isF = null;
+        ZipInputStream zis;
         byte[] buffer = new byte[1024];
-        try {
-            is = asm.open(zipPath);
-            ZipInputStream zis = new ZipInputStream(is);
 
+        try {
+            if (asm != null) {
+                is = asm.open(zipPath);
+                zis = new ZipInputStream(is);
+            } else {
+                File zipFile = new File(zipPath);
+                isF = new FileInputStream(zipFile);
+                zis = new ZipInputStream(isF);
+            }
             ZipEntry ze = zis.getNextEntry();
             while (ze != null) {
                 String fileName = ze.getName();
                 if (isLast(fileName, ".db")) {
                     String toFileName = addSQLiteSuffix(fileName);
-                    boolean isExist = isFileExists(context, toFileName);
+                    String dbPath = databasePath + File.separator + toFileName;
+                    boolean isExist = isPathExists(dbPath);
                     if (!isExist || overwrite) {
                         if (overwrite && isExist) {
-                            deleteDatabase(context, toFileName);
+                            deleteFile(databasePath, toFileName);
                         }
-                        String toPathName = context.getDatabasePath(toFileName).getAbsolutePath();
-                        File newFile = new File(toPathName);
+                        File newFile = new File(dbPath);
                         System.out.println("Unzipping to " + newFile.getAbsolutePath());
                         FileOutputStream fos = new FileOutputStream(newFile);
                         int len;
@@ -145,7 +171,11 @@ public class UtilsFile {
             //close last ZipEntry
             zis.closeEntry();
             zis.close();
-            is.close();
+            if (asm != null && is != null) {
+                is.close();
+            } else if (isF != null) {
+                isF.close();
+            }
         } catch (IOException e) {
             throw new IOException("in unzipCopyDatabase " + e.getLocalizedMessage());
         }
@@ -294,6 +324,53 @@ public class UtilsFile {
         }
     }
 
+    public void moveAllDBs(File fromDir, File toDir) throws Exception {
+        // get the file List from fromDir
+        List<String> fileList;
+        String fromDirPath = fromDir.getAbsolutePath();
+        String toDirPath = toDir.getAbsolutePath();
+
+        try {
+            fileList = listDatabases(fromDir);
+            for (String fileName : fileList) {
+                // Check if the file exists in toDir
+                File toFile = new File(toDirPath, fileName);
+                Boolean isPath = isPathExists(toFile.getAbsolutePath());
+                if (isPath) {
+                    deleteFile(toFile);
+                }
+                File fromFile = new File(fromDirPath, fileName);
+
+                Boolean success = fromFile.renameTo(toFile);
+                if (!success) {
+                    throw new Exception("moveAllDBs: move file " + fileName + " failed");
+                }
+            }
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    public List<String> listDatabases(File fileDir) throws Exception {
+        List<String> fileList = new ArrayList<>();
+        if (!fileDir.exists()) {
+            throw new Exception("File " + fileDir.getAbsolutePath() + " does not exist");
+        }
+        if (!fileDir.isDirectory()) {
+            throw new Exception("File " + fileDir.getAbsolutePath() + " is not a directory");
+        }
+        File[] fList = fileDir.listFiles();
+        for (File file : fList) {
+            if (file.isFile()) {
+                String fileName = file.getName();
+                if (getFileExtension((fileName)).equals("db")) {
+                    fileList.add(fileName);
+                }
+            }
+        }
+        return fileList;
+    }
+
     private static void copyFileFromFile(File sourceFile, File destFile) throws IOException {
         if (!destFile.getParentFile().exists()) destFile.getParentFile().mkdirs();
 

package/electron/dist/plugin.js

@@ -3,12 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var require$$0 = require('sqlite3');
-var require$$0$1 = require('path');
-var require$$1 = require('fs');
-var require$$2 = require('node-fetch');
-var require$$3 = require('os');
-var require$$4 = require('jszip');
-var require$$5 = require('electron');
+var require$$0$1 = require('node:fs/promises');
+var require$$1 = require('path');
+var require$$2 = require('fs');
+var require$$3 = require('node-fetch');
+var require$$4 = require('os');
+var require$$5 = require('jszip');
+var require$$6 = require('electron');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -19,6 +20,7 @@ var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
 var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
 var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 var require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
+var require$$6__default = /*#__PURE__*/_interopDefaultLegacy(require$$6);
 
 var src = {};
 
@@ -2673,6 +2675,7 @@ var utilsFile = {};
 
 Object.defineProperty(utilsFile, "__esModule", { value: true });
 utilsFile.UtilsFile = void 0;
+const promises_1 = require$$0__default$1["default"];
 class UtilsFile {
     constructor() {
         this.pathDB = 'Databases';
@@ -2685,12 +2688,12 @@ class UtilsFile {
         this.AppName = '';
         this.HomeDir = '';
         this.sep = '/';
-        this.Path = require$$0__default$1["default"];
-        this.NodeFs = require$$1__default["default"];
-        this.NodeFetch = require$$2__default["default"];
-        this.Os = require$$3__default["default"];
-        this.JSZip = require$$4__default["default"];
-        this.Electron = require$$5__default["default"];
+        this.Path = require$$1__default["default"];
+        this.NodeFs = require$$2__default["default"];
+        this.NodeFetch = require$$3__default["default"];
+        this.Os = require$$4__default["default"];
+        this.JSZip = require$$5__default["default"];
+        this.Electron = require$$6__default["default"];
         this.HomeDir = this.Os.homedir();
         const dir = __dirname;
         const idx = dir.indexOf('\\');
@@ -2996,6 +2999,7 @@ class UtilsFile {
             const isPath = this.isPathExists(filePath);
             if (isPath) {
                 try {
+                    await this.waitForFilePathLock(filePath);
                     this.NodeFs.unlinkSync(filePath);
                     return Promise.resolve();
                 }
@@ -3011,6 +3015,52 @@ class UtilsFile {
             return Promise.reject('DeleteFilePath: delete filePath' + 'failed');
         }
     }
+    async waitForFilePathLock(filePath, timeoutMS = 4000) {
+        let timeIsOver = false;
+        setTimeout(() => {
+            timeIsOver = true;
+        }, timeoutMS);
+        return new Promise((resolve, reject) => {
+            const check = async () => {
+                if (timeIsOver) {
+                    reject(new Error(`WaitForFilePathLock: The resource is still locked / busy after ${timeoutMS} milliseconds.`));
+                    return;
+                }
+                // check if path exists
+                const isPath = this.isPathExists(filePath);
+                // The file path does not exist. A non existant path cannot be locked.
+                if (!isPath) {
+                    resolve();
+                    return;
+                }
+                try {
+                    const stream = await promises_1.open(filePath, 'r+');
+                    // We need to close the stream afterwards, because otherwise, we're locking the file
+                    await stream.close();
+                    resolve();
+                }
+                catch (err) {
+                    if (err.code === 'EBUSY') {
+                        // The resource is busy. Retry in 100ms
+                        setTimeout(() => {
+                            check();
+                        }, 100);
+                        return;
+                    }
+                    else if (err.code === 'ENOENT') {
+                        // The file does not exist (anymore). So it cannot be locked.
+                        resolve();
+                        return;
+                    }
+                    else {
+                        // Something else went wrong.
+                        reject(new Error(`WaitForFilePathLock: Error while checking the file: ${err}`));
+                    }
+                }
+            };
+            check();
+        });
+    }
     /**
      * RenameFileName
      * @param fileName
@@ -3350,11 +3400,15 @@ class Database {
      */
     async close() {
         this.ensureDatabaseIsOpen();
-        this.database.close((err) => {
-            if (err) {
-                throw new Error('Close failed: ${this.dbName}  ${err}');
-            }
-            this._isDbOpen = false;
+        return new Promise((resolve, reject) => {
+            this.database.close((err) => {
+                if (err) {
+                    reject(new Error(`Close failed: ${this.dbName}  ${err}`));
+                    return;
+                }
+                this._isDbOpen = false;
+                resolve();
+            });
         });
     }
     /**