@saltcorn/mobile-app 1.1.0-beta.9 → 1.1.1-beta.0

package/{www/js/utils/table_utils.js → src/helpers/db_schema.js}

@@ -1,13 +1,16 @@
-/*global readJSON, cordova, fileExists, writeJSON, saltcorn*/
+/*global saltcorn */
 
 const historyFile = "update_history";
 const jwtTableName = "jwt_table";
 
+import { readFile, fileExists, writeJSON } from "./file_system";
+import { Directory } from "@capacitor/filesystem";
+
 /**
  * drop tables that are no longer in the 'tables.json' file
  * the server db uses a serial (with postgres), so checking ids should suffice
  */
-async function dropDeletedTables(incomingTables) {
+export async function dropDeletedTables(incomingTables) {
   const existingTables = await saltcorn.data.models.Table.find();
   for (const table of existingTables) {
     if (
@@ -27,7 +30,7 @@ async function dropDeletedTables(incomingTables) {
  * @param {*} rows
  * @returns
  */
-async function safeRows(table, rows) {
+export async function safeRows(table, rows) {
   const existingFields = (
     await saltcorn.data.db.query(
       `PRAGMA table_info('${saltcorn.data.db.sqlsanitize(table)}')`
@@ -45,7 +48,7 @@ async function safeRows(table, rows) {
   });
 }
 
-async function updateScTables(tablesJSON, skipScPlugins = true) {
+export async function updateScTables(tablesJSON, skipScPlugins = true) {
   await saltcorn.data.db.query("PRAGMA foreign_keys = OFF;");
   for (const { table, rows } of tablesJSON.sc_tables) {
     if (skipScPlugins && table === "_sc_plugins") continue;
@@ -56,7 +59,7 @@ async function updateScTables(tablesJSON, skipScPlugins = true) {
   await saltcorn.data.db.query("PRAGMA foreign_keys = ON;");
 }
 
-async function updateScPlugins(tablesJSON) {
+export async function updateScPlugins(tablesJSON) {
   const { table, rows } = tablesJSON.sc_tables.find(
     ({ table }) => table === "_sc_plugins"
   );
@@ -66,7 +69,7 @@ async function updateScPlugins(tablesJSON) {
   }
 }
 
-async function updateUserDefinedTables() {
+export async function updateUserDefinedTables() {
   const existingTables = await saltcorn.data.db.listUserDefinedTables();
   const tables = await saltcorn.data.models.Table.find();
   for (const table of tables) {
@@ -92,7 +95,7 @@ async function updateUserDefinedTables() {
   }
 }
 
-async function createSyncInfoTables(synchTbls) {
+export async function createSyncInfoTables(synchTbls) {
   const infoTbls = (await saltcorn.data.db.listTables()).filter(({ name }) => {
     name.endsWith("_sync_info");
   });
@@ -139,11 +142,8 @@ async function createSyncInfoTables(synchTbls) {
   }
 }
 
-async function tablesUptodate(createdAt, historyFile) {
-  const { updated_at } = await readJSON(
-    historyFile,
-    cordova.file.dataDirectory
-  );
+export async function tablesUptodate(createdAt, historyFile) {
+  const { updated_at } = await readFile(historyFile, Directory.Data);
   if (!updated_at) {
     console.log("No updated_at in history file");
     return false;
@@ -155,52 +155,30 @@ async function tablesUptodate(createdAt, historyFile) {
  * Do a table update when the history file doesn't exist or is older than createdAt
  * @param {number} createdAt UTC Date number when the tables.json file was created on the server
  */
-async function dbUpdateNeeded(createdAt) {
+export async function dbUpdateNeeded(createdAt) {
   return (
-    !(await fileExists(`${cordova.file.dataDirectory}${historyFile}`)) ||
+    !(await fileExists(historyFile, Directory.Data)) ||
     !(await tablesUptodate(createdAt, historyFile))
   );
 }
 
-async function updateDb(tablesJSON) {
+export async function updateDb(tablesJSON) {
   await updateScTables(tablesJSON);
   await saltcorn.data.state.getState().refresh_tables();
   await updateUserDefinedTables();
-  await writeJSON(historyFile, cordova.file.dataDirectory, {
+  await writeJSON(historyFile, Directory.Data, {
     updated_at: new Date().valueOf(),
   });
 }
 
-async function getTableIds(tableNames) {
+export async function getTableIds(tableNames) {
   return (await saltcorn.data.models.Table.find())
     .filter((table) => tableNames.indexOf(table.name) > -1)
     .map((table) => table.id);
 }
 
-async function createJwtTable() {
+export async function createJwtTable() {
   await saltcorn.data.db.query(`CREATE TABLE IF NOT EXISTS ${jwtTableName} (
     jwt VARCHAR(500)
   )`);
 }
-
-async function getJwt() {
-  const rows = await saltcorn.data.db.select(jwtTableName);
-  return rows?.length > 0 ? rows[0].jwt : null;
-}
-
-async function removeJwt() {
-  await saltcorn.data.db.deleteWhere(jwtTableName);
-}
-
-async function setJwt(jwt) {
-  await removeJwt();
-  await saltcorn.data.db.insert(jwtTableName, { jwt: jwt });
-}
-
-async function insertUser({ id, email, role_id, language }) {
-  await saltcorn.data.db.insert(
-    "users",
-    { id, email, role_id, language },
-    { ignoreExisting: true }
-  );
-}

package/src/helpers/file_system.js

@@ -0,0 +1,102 @@
+import { Filesystem, Encoding, Directory } from "@capacitor/filesystem";
+
+export async function writeFile(name, directory, content) {
+  try {
+    await Filesystem.writeFile({
+      path: name,
+      data: content,
+      directory: directory,
+      encoding: Encoding.UTF8,
+    });
+  } catch (error) {
+    console.log("Unable to write file", error);
+    throw error;
+  }
+}
+
+export async function readFile(name, directory) {
+  try {
+    const contents = await Filesystem.readFile({
+      path: name,
+      directory: directory,
+      encoding: Encoding.UTF8,
+    });
+    return contents.data;
+  } catch (error) {
+    console.log("Unable to read file", error);
+    throw error;
+  }
+}
+
+export async function fileExists(name, directory) {
+  try {
+    await Filesystem.stat({ path: name, directory: directory });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+export async function writeJSON(name, directory, json) {
+  const contents = JSON.stringify(json);
+  await writeFile(name, directory, contents);
+}
+
+function getDirEntryCordova(directory) {
+  return new Promise((resolve, reject) => {
+    window.resolveLocalFileSystemURL(
+      directory,
+      function (fs) {
+        resolve(fs);
+      },
+      function (error) {
+        reject(error);
+      }
+    );
+  });
+}
+
+export async function readBinaryCordova(fileName, dirName) {
+  const dirEntry = await getDirEntryCordova(dirName);
+  return new Promise((resolve, reject) => {
+    dirEntry.getFile(
+      fileName,
+      { create: false, exclusive: false },
+      function (fileEntry) {
+        fileEntry.file(function (file) {
+          let reader = new FileReader();
+          reader.onloadend = function (e) {
+            resolve({ buffer: this.result, file: file });
+          };
+          reader.readAsArrayBuffer(file);
+        });
+      },
+      function (err) {
+        console.log(`unable to read  ${fileName}`);
+        console.log(err);
+        reject(err);
+      }
+    );
+  });
+}
+
+// TODO get this working
+// export function normalizeFilePath(filePath) {
+//   if (filePath.startsWith("file:///")) {
+//     return filePath.replace("file:///storage/emulated/0/", "");
+//   }
+//   return filePath;
+// }
+
+// export async function readBinary(name, directory) {
+//   try {
+//     const file = await Filesystem.readFile({
+//       path: normalizeFilePath(`${directory}/${name}`),
+//       directory: Directory.ExternalStorage,
+//     });
+//     return Uint8Array.from(file.data, (char) => char.charCodeAt(0));
+//   } catch (error) {
+//     console.log("Unable to read file", error);
+//     throw error;
+//   }
+// }