npm - @saltcorn/mobile-app - Versions diffs - 0.7.2-beta.5 - Mend

@saltcorn/mobile-app 0.7.2-beta.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/config.xml +14 -0
package/index.js +1 -0
package/package.json +30 -0
package/www/index.html +138 -0
package/www/js/mocks/request.js +22 -0
package/www/js/mocks/response.js +27 -0
package/www/js/routes/delete.js +22 -0
package/www/js/routes/edit.js +21 -0
package/www/js/routes/init.js +34 -0
package/www/js/routes/page.js +17 -0
package/www/js/routes/view.js +102 -0
package/www/js/utils/file_helpers.js +73 -0
package/www/js/utils/global_utils.js +108 -0
package/www/js/utils/iframe_view_utils.js +281 -0
package/www/js/utils/login_form.js +40 -0
package/www/js/utils/table_utils.js +61 -0

package/config.xml ADDED Viewed

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<widget id="saltcorn.mobile.app" version="1.0.0" xmlns="http://www.w3.org/ns/widgets" xmlns:cdv="http://cordova.apache.org/ns/1.0" xmlns:android="http://schemas.android.com/apk/res/android">
+  <name>SaltcornMobileApp</name>
+  <description>Apache Cordova application with @saltcorn/markup</description>
+  <platform name="android">
+    <edit-config file="app/src/main/AndroidManifest.xml" target="/manifest/application" mode="merge">
+      <application android:usesCleartextTraffic="true"/>
+    </edit-config>
+    <preference name="Scheme" value="http"/>
+    <preference name="MixedContentMode" value="2"/>
+  </platform>
+  <content src="index.html"/>
+  <access origin="*"/>
+</widget>

package/index.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ module.exports = {};

package/package.json ADDED Viewed

@@ -0,0 +1,30 @@
+{
+  "name": "@saltcorn/mobile-app",
+  "displayName": "Saltcorn mobile app",
+  "version": "0.7.2-beta.5",
+  "description": "Apache Cordova application with @saltcorn/markup",
+  "main": "index.js",
+  "scripts": {
+    "add-platform": "cordova platform add",
+    "build-app": "cordova build"
+  },
+  "author": "Christian Hugo",
+  "license": "MIT",
+  "cordova": {
+    "platforms": [
+      "android"
+    ],
+    "plugins": {
+      "cordova-sqlite-ext": {},
+      "cordova-plugin-file": {}
+    }
+  },
+  "dependencies": {
+    "cordova": "^11.0.0",
+    "cordova-sqlite-ext": "^6.0.0"
+  },
+  "devDependencies": {
+    "cordova-android": "^10.1.2",
+    "cordova-plugin-file": "^6.0.2"
+  }
+}

package/www/index.html ADDED Viewed

@@ -0,0 +1,138 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <script src="cordova.js"></script>
+    <script src="js/utils/global_utils.js"></script>
+    <script src="js/utils/iframe_view_utils.js"></script>
+    <script src="js/mocks/response.js"></script>
+    <script src="js/mocks/request.js"></script>
+    <script src="npm_packages/jwt-decode.js"></script>
+    <script src="https://unpkg.com/universal-router/universal-router.min.js"></script>
+    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
+    <script type="module">
+      import { initRoutes } from "./js/routes/init.js";
+      import { renderLoginForm } from "./js/utils/login_form.js";
+      import {
+        updateDbIfNecessary,
+        getTableIds,
+      } from "./js/utils/table_utils.js";
+      import { readJSON } from "./js/utils/file_helpers.js";
+      const staticPlugins = ["base", "sbadmin2"];
+      async function addScript(path) {
+        return new Promise((resolve, reject) => {
+          let script = document.createElement("script");
+          document.head.appendChild(script);
+          script.onload = () => {
+            resolve();
+          };
+          // TODO reject after some seconds
+          script.src = path;
+        });
+      }
+      async function loadPlugin(plugin) {
+        return addScript(`js/bundles/${plugin.name}.bundle.js`);
+      }
+      async function loadPlugins(state) {
+        let plugins = (await saltcorn.data.models.Plugin.find()).filter(
+          (plugin) => !staticPlugins.includes(plugin.name)
+        );
+        for (const plugin of plugins) {
+          await loadPlugin(plugin);
+          state.registerPlugin(plugin.name, saltcorn[plugin.name]);
+        }
+        return plugins;
+      }
+      async function addScripts(version_tag) {
+        const scripts = [
+          `static_assets/${version_tag}/jquery-3.6.0.min.js`,
+          "js/bundles/common_chunks.bundle.js",
+          "js/bundles/markup.bundle.js",
+          "js/bundles/data.bundle.js",
+          "js/bundles/base_plugin.bundle.js",
+          "js/bundles/sbadmin2.bundle.js",
+        ];
+        for (const script of scripts) {
+          await addScript(script);
+        }
+      }
+      const addPluginScriptTagsToCfg = (pluginRows) => {
+        window.config.pluginHeaders = [];
+        for (const row of pluginRows) {
+          const pluginHeaders = saltcorn[row.name].headers;
+          if (pluginHeaders) {
+            for (const header of pluginHeaders) {
+              window.config.pluginHeaders.push(header);
+            }
+          }
+        }
+      };
+      document.addEventListener("deviceready", async () => {
+        window.config = await readJSON(
+          "config",
+          `${cordova.file.applicationDirectory}www`
+        );
+        await addScripts(config.version_tag);
+        await saltcorn.data.db.init();
+        const state = saltcorn.data.state.getState();
+        state.registerPlugin("base", saltcorn.base_plugin);
+        state.registerPlugin("sbadmin2", saltcorn.sbadmin2);
+        addPluginScriptTagsToCfg(await loadPlugins(state));
+        await updateDbIfNecessary();
+        await state.refresh_tables();
+        await state.refresh_views();
+        await state.refresh_pages();
+        state.localTableIds = await getTableIds(config.localUserTables);
+        await initRoutes();
+        const entryView = config.entry_view;
+        const jwt = localStorage.getItem("auth_jwt");
+        if (jwt && jwt !== "undefined") {
+          const decodedJwt = jwt_decode(jwt);
+          saltcorn.data.state.getState().role_id = decodedJwt?.role_id
+            ? decodedJwt.role_id
+            : 10;
+          addRoute({ route: entryView, query: undefined });
+          const page = await router.resolve({
+            pathname: entryView,
+            fullWrap: true,
+          });
+          replaceIframe(page.content);
+        } else {
+          replaceIframe(renderLoginForm(entryView, config.version_tag));
+        }
+      });
+      document.addEventListener("backbutton", async () => {
+        await goBack(1, true);
+      });
+    </script>
+  </head>
+  <body>
+    <iframe
+      id="content-iframe"
+      style="
+        position: fixed;
+        top: 0;
+        left: 0;
+        bottom: 0;
+        right: 0;
+        width: 100%;
+        height: 100%;
+        border: none;
+        margin: 0;
+        padding: 0;
+        overflow: hidden;
+        z-index: 999999;
+      "
+    >
+      <p>Your browser does not support iframes.</p>
+    </iframe>
+  </body>
+</html>

package/www/js/mocks/request.js ADDED Viewed

@@ -0,0 +1,22 @@
+function MobileRequest(xhr = false) {
+  const roleId = saltcorn.data.state.getState().role_id
+    ? saltcorn.data.state.getState().role_id
+    : 10;
+  return {
+    __: (s) => s,
+    getLocale: () => "en",
+    user: {
+      role_id: roleId,
+    },
+    flash: (str) => {
+      console.log("flash ->->");
+      console.log(str);
+    },
+    get: (key) => {
+      return "";
+    },
+    csrfToken: () => "",
+    xhr,
+  };
+}

package/www/js/mocks/response.js ADDED Viewed

@@ -0,0 +1,27 @@
+function MobileResponse() {
+  let jsonData = null;
+  let sendData = null;
+  function json(data) {
+    jsonData = data;
+  }
+  function send(data) {
+    sendData = data;
+  }
+  function getJson() {
+    return jsonData;
+  }
+  function getSendData() {
+    return getSendData;
+  }
+  return {
+    json,
+    send,
+    getJson,
+    getSendData,
+  };
+}

package/www/js/routes/delete.js ADDED Viewed

@@ -0,0 +1,22 @@
+// post/delete/:name/:id
+export const deleteRows = async (context) => {
+  const { name, id } = context.params;
+  try {
+    const table = await saltcorn.data.models.Table.findOne({ name });
+    const state = saltcorn.data.state.getState();
+    if (state.localTableIds.indexOf(table.id) >= 0) {
+      await table.deleteRows({ id });
+    } else {
+      await apiCall({ method: "POST", path: `/delete/${name}/${id}` });
+    }
+    const redirect = context.data?.after_delete_url
+      ? context.data.after_delete_url === "/"
+        ? "/"
+        : `get${new URL(context.data?.after_delete_url).pathname}`
+      : new URLSearchParams(context.query).get("redirect");
+    return { redirect };
+  } catch (error) {
+    // TODO ch message?
+    return null;
+  }
+};

package/www/js/routes/edit.js ADDED Viewed

@@ -0,0 +1,21 @@
+// /toggle/:name/:id/:field_name
+export const postToggleField = async (context) => {
+  const { name, id, field_name } = context.params;
+  try {
+    const table = await saltcorn.data.models.Table.findOne({ name });
+    const state = saltcorn.data.state.getState();
+    if (state.localTableIds.indexOf(table.id) >= 0) {
+      await table.toggleBool(+id, field_name);
+    } else {
+      await apiCall({
+        method: "POST",
+        path: `/edit/toggle/${name}/${id}/${field_name}`,
+      });
+    }
+    const redirect = new URLSearchParams(context.query).get("redirect");
+    return { redirect };
+  } catch (error) {
+    // TODO ch message?
+    return null;
+  }
+};

package/www/js/routes/init.js ADDED Viewed

@@ -0,0 +1,34 @@
+import { deleteRows } from "./delete.js";
+import { getView, postView, postViewRoute } from "./view.js";
+import { postToggleField } from "./edit.js";
+import { postPageAction } from "./page.js";
+export const initRoutes = async () => {
+  const routes = [
+    {
+      path: "post/view/:viewname",
+      action: postView,
+    },
+    {
+      path: "post/view/:viewname/:route",
+      action: postViewRoute,
+    },
+    {
+      path: "get/view/:viewname",
+      action: getView,
+    },
+    {
+      path: "post/edit/toggle/:name/:id/:field_name",
+      action: postToggleField,
+    },
+    {
+      path: "post/delete/:name/:id",
+      action: deleteRows,
+    },
+    {
+      path: "post/page/:pagename/action/:rndid",
+      action: postPageAction,
+    },
+  ];
+  window.router = new window.UniversalRouter(routes);
+};

package/www/js/routes/page.js ADDED Viewed

@@ -0,0 +1,17 @@
+// post/page/:pagename/action/:rndid
+export const postPageAction = async (context) => {
+  const { pagename, rndid } = context.params;
+  const db_page = await saltcorn.data.models.Page.findOne({ name: pagename });
+  let col;
+  saltcorn.data.models.layout.traverseSync(db_page.layout, {
+    action(segment) {
+      if (segment.rndid === rndid) col = segment;
+    },
+  });
+  const result = await saltcorn.data.plugin_helper.run_action_column({
+    col,
+    referrer: "",
+    req: new MobileRequest(context.xhr),
+  });
+  return result || {};
+};

package/www/js/routes/view.js ADDED Viewed

@@ -0,0 +1,102 @@
+const getHeaders = (versionTag) => {
+  const stdHeaders = [
+    { css: `static_assets/${versionTag}/saltcorn.css` },
+    { script: `static_assets/${versionTag}/saltcorn-common.js` },
+    { script: "js/utils/iframe_view_utils.js" },
+  ];
+  return [...stdHeaders, ...window.config.pluginHeaders];
+};
+/**
+ *
+ * @param {*} context
+ * @returns
+ */
+export const postView = async (context) => {
+  let body = {};
+  let redirect = undefined;
+  for (const [k, v] of new URLSearchParams(context.query).entries()) {
+    body[k] = v;
+    if (k === "redirect") redirect = v;
+  }
+  const view = await saltcorn.data.models.View.findOne({
+    name: context.params.viewname,
+  });
+  const response = new MobileResponse();
+  await view.runPost(
+    {},
+    body,
+    {
+      req: new MobileRequest(context.xhr),
+      res: response,
+      redirect,
+    },
+    view.isRemoteTable()
+  );
+  return response.getJson();
+};
+/**
+ *
+ * @param {*} context
+ */
+export const postViewRoute = async (context) => {
+  const view = await saltcorn.data.models.View.findOne({
+    name: context.params.viewname,
+  });
+  const response = new MobileResponse();
+  const request = new MobileRequest(context.xhr);
+  await view.runRoute(
+    context.params.route,
+    context.data,
+    response,
+    { req: request, res: response },
+    view.isRemoteTable()
+  );
+  return response.getJson();
+};
+/**
+ *
+ * @param {*} context
+ * @returns
+ */
+export const getView = async (context) => {
+  let query = {};
+  const parsedQuery =
+    typeof context.query === "string"
+      ? new URLSearchParams(context.query)
+      : undefined;
+  if (parsedQuery) {
+    for (let [key, value] of parsedQuery) {
+      query[key] = value;
+    }
+  }
+  const viewname = context.params.viewname;
+  const view = saltcorn.data.models.View.findOne({ name: viewname });
+  const viewContent = await view.run_possibly_on_page(
+    query,
+    new MobileRequest(context.xhr),
+    new MobileResponse(),
+    view.isRemoteTable()
+  );
+  const state = saltcorn.data.state.getState();
+  const layout = state.getLayout({ role_id: state.role_id });
+  const wrappedContent = context.fullWrap
+    ? layout.wrap({
+        title: viewname,
+        body: { above: [viewContent] },
+        alerts: [],
+        role: state.role_id,
+        headers: getHeaders(window.config.version_tag),
+        bodyClass: "",
+        brand: {},
+      })
+    : layout.renderBody({
+        title: viewname,
+        body: { above: [viewContent] },
+        alerts: [],
+        role: state.role_id,
+      });
+  return { content: wrappedContent, title: viewname };
+};

package/www/js/utils/file_helpers.js ADDED Viewed

@@ -0,0 +1,73 @@
+export async function fileExists(path) {
+  try {
+    await getDirEntry(path);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+export function getDirEntry(directory) {
+  return new Promise((resolve, reject) => {
+    window.resolveLocalFileSystemURL(
+      directory,
+      function (fs) {
+        resolve(fs);
+      },
+      function (error) {
+        reject(error);
+      }
+    );
+  });
+}
+export async function readJSON(fileName, dirName) {
+  const dirEntry = await getDirEntry(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(JSON.parse(this.result));
+          };
+          reader.readAsText(file);
+        });
+      },
+      function (err) {
+        console.log(`unable to read  ${fileName}`);
+        console.log(err);
+        reject(err);
+      }
+    );
+  });
+}
+export async function writeJSON(fileName, dirName, content) {
+  const dirEntry = await getDirEntry(dirName);
+  return new Promise((resolve, reject) => {
+    dirEntry.getFile(
+      fileName,
+      { create: true, exclusive: false },
+      function (fileEntry) {
+        fileEntry.createWriter(function (fileWriter) {
+          fileWriter.onwriteend = function () {
+            resolve();
+          };
+          fileWriter.onerror = function (e) {
+            console.log("Failed file write: " + e.toString());
+            reject(e);
+          };
+          fileWriter.write(JSON.stringify(content));
+        });
+      },
+      function (err) {
+        console.log(`unable to get ${fileName}`);
+        console.log(err);
+        reject(err);
+      }
+    );
+  });
+}

package/www/js/utils/global_utils.js ADDED Viewed

@@ -0,0 +1,108 @@
+let routingHistory = [];
+function currentLocation() {
+  if (routingHistory.length == 0) return undefined;
+  return routingHistory[routingHistory.length - 1].route;
+}
+function currentQuery() {
+  if (routingHistory.length == 0) return undefined;
+  return routingHistory[routingHistory.length - 1].query;
+}
+function addRoute(routeEntry) {
+  routingHistory.push(routeEntry);
+}
+async function apiCall({ method, path, params, body }) {
+  const serverPath = config.server_path;
+  const token = localStorage.getItem("auth_jwt");
+  const url = `${serverPath}${path}`;
+  try {
+    return await axios({
+      url: url,
+      method: method,
+      params: params,
+      headers: {
+        Authorization: `jwt ${token}`,
+        "X-Requested-With": "XMLHttpRequest",
+        "X-Saltcorn-Client": "mobile-app",
+      },
+      data: body,
+    });
+  } catch (error) {
+    console.log(`error while calling: ${method} ${url}`);
+    console.log(JSON.stringify(error));
+    throw error;
+  }
+}
+function splitPathQuery(url) {
+  let path = url;
+  let query = undefined;
+  const queryStart = url.indexOf("?");
+  if (queryStart > 0) {
+    path = url.substring(0, queryStart);
+    query = url.substring(queryStart);
+  }
+  return { path, query };
+}
+function replaceIframe(content) {
+  let iframe = document.getElementById("content-iframe");
+  iframe.contentWindow.document.open();
+  iframe.contentWindow.document.write(content);
+  iframe.contentWindow.document.close();
+}
+function replaceIframeInnerContent(content) {
+  const iframe = document.getElementById("content-iframe");
+  const iframeDocument = iframe.contentWindow.document;
+  let innerContentDiv = iframeDocument.getElementById("page-inner-content");
+  innerContentDiv.innerHTML = content;
+  let scripts = innerContentDiv.getElementsByTagName("script");
+  for (let script of scripts) {
+    iframe.contentWindow.eval(script.innerHTML);
+  }
+  const scmodal = iframe.contentWindow.$("#scmodal");
+  if (scmodal) {
+    scmodal.modal("hide");
+  }
+}
+async function gotoEntryView() {
+  const entryPath = config.entry_view;
+  const page = await router.resolve({
+    pathname: entryPath,
+  });
+  addRoute({ entryPath, query: undefined });
+  replaceIframeInnerContent(page.content);
+}
+async function handleRoute(route, query) {
+  if (route === "/") return await gotoEntryView();
+  addRoute({ route, query });
+  const page = await router.resolve({
+    pathname: route,
+    query: query,
+  });
+  if (page.redirect) {
+    const { path, query } = splitPathQuery(page.redirect);
+    await handleRoute(path, query);
+  } else if (page.content) {
+    replaceIframeInnerContent(page.content);
+  }
+}
+async function goBack(steps = 1, exitOnFirstPage = false) {
+  if (exitOnFirstPage && routingHistory.length === 1) {
+    navigator.app.exitApp();
+  } else if (routingHistory.length <= steps) {
+    routingHistory = [];
+    await gotoEntryView();
+  } else {
+    routingHistory = routingHistory.slice(0, routingHistory.length - steps);
+    const newCurrent = routingHistory.pop();
+    await handleRoute(newCurrent.route, newCurrent.query);
+  }
+}

package/www/js/utils/iframe_view_utils.js ADDED Viewed

@@ -0,0 +1,281 @@
+function combineFormAndQuery(form, query) {
+  let paramsList = [];
+  const formData = new FormData(form[0]);
+  for (const [k, v] of formData.entries()) {
+    paramsList.push(`${k}=${v}`);
+  }
+  let sp = new URLSearchParams(query);
+  for (let [k, v] of sp.entries()) {
+    if (k === "redirect") v = `get${v}`;
+    paramsList.push(`${k}=${v}`);
+  }
+  return paramsList.length > 0 ? `?${paramsList.join("&")}` : undefined;
+}
+/**
+ *
+ * @param {*} url
+ */
+async function execLink(url) {
+  const { path, query } = parent.splitPathQuery(url);
+  await parent.handleRoute(`get${path}`, query);
+}
+/**
+ *
+ * @param {*} e
+ * @param {*} urlSuffix
+ * @returns
+ */
+async function formSubmit(e, urlSuffix, viewname) {
+  e.submit();
+  const queryStr = new URLSearchParams(new FormData(e)).toString();
+  await parent.handleRoute(`post${urlSuffix}${viewname}`, queryStr);
+}
+async function saveAndContinue(e, action, k) {
+  const form = $(e).closest("form");
+  submitWithEmptyAction(form[0]);
+  const queryStr = new URLSearchParams(new FormData(form[0])).toString();
+  const res = await parent.router.resolve({
+    pathname: `post${action}`,
+    query: queryStr,
+    xhr: true,
+  });
+  if (res.id && form.find("input[name=id")) {
+    form.append(
+      `<input type="hidden" class="form-control  " name="id" value="${res.id}">`
+    );
+  }
+  if (k) await k();
+  // TODO ch error (request.responseText?)
+}
+async function login(email, password) {
+  try {
+    const response = await parent.apiCall({
+      method: "GET",
+      path: "/auth/login-with/jwt",
+      params: {
+        email,
+        password,
+      },
+    });
+    return response.data;
+  } catch (error) {
+    // TODO ch message
+    return null;
+  }
+}
+async function loginFormSubmit(e, entryView) {
+  let formData = new FormData(e);
+  const token = await login(formData.get("email"), formData.get("password"));
+  if (token) {
+    parent.localStorage.setItem("auth_jwt", token);
+    const decodedJwt = parent.jwt_decode(token);
+    parent.saltcorn.data.state.getState().role_id = decodedJwt?.role_id
+      ? decodedJwt.role_id
+      : 10;
+    parent.addRoute({ route: entryView, query: undefined });
+    const page = await parent.router.resolve({
+      pathname: entryView,
+      fullWrap: true,
+    });
+    parent.replaceIframe(page.content);
+  }
+}
+async function local_post_btn(e) {
+  const form = $(e).closest("form");
+  const url = form.attr("action");
+  const method = form.attr("method");
+  const { path, query } = parent.splitPathQuery(url);
+  await parent.handleRoute(
+    `${method}${path}`,
+    combineFormAndQuery(form, query)
+  );
+}
+/**
+ *
+ * @param {*} e
+ * @param {*} path
+ */
+async function stateFormSubmit(e, path) {
+  const formQuery = new URLSearchParams(new FormData(e)).toString();
+  await parent.handleRoute(path, formQuery);
+}
+function removeQueryStringParameter(queryStr, key) {
+  let params = [];
+  for (const [k, v] of new URLSearchParams(queryStr).entries()) {
+    if (k !== key) {
+      params.push(`${k}=${v}`);
+    }
+  }
+  return params.join("&");
+}
+function updateQueryStringParameter(queryStr, key, value) {
+  if (!queryStr) {
+    return `${key}=${value}`;
+  }
+  let params = [];
+  let updated = false;
+  for (const [k, v] of new URLSearchParams(queryStr).entries()) {
+    if (k === key) {
+      params.push(`${key}=${value}`);
+      updated = true;
+    } else {
+      params.push(`${k}=${v}`);
+    }
+  }
+  if (!updated) {
+    params.push(`${key}=${value}`);
+  }
+  return params.join("&");
+}
+async function set_state_fields(kvs, href) {
+  let queryParams = [];
+  let currentQuery = parent.currentQuery();
+  Object.entries(kvs).forEach((kv) => {
+    if (kv[1].unset && kv[1].unset === true) {
+      currentQuery = removeQueryStringParameter(currentQuery, kv[0]);
+    } else {
+      currentQuery = updateQueryStringParameter(currentQuery, kv[0], kv[1]);
+    }
+  });
+  for (const [k, v] of new URLSearchParams(currentQuery).entries()) {
+    queryParams.push(`${k}=${v}`);
+  }
+  await parent.handleRoute(href, queryParams.join("&"));
+}
+async function set_state_field(key, value) {
+  const query = updateQueryStringParameter(parent.currentQuery(), key, value);
+  await parent.handleRoute(parent.currentLocation(), query);
+}
+async function unset_state_field(key) {
+  const href = parent.currentLocation();
+  const query = removeQueryStringParameter(parent.currentLocation(), key);
+  await parent.handleRoute(href, query);
+}
+async function sortby(k, desc, viewname) {
+  await set_state_fields(
+    { _sortby: k, _sortdesc: desc ? "on" : { unset: true } },
+    `get/view/${viewname}`
+  );
+}
+async function gopage(n, pagesize, extra) {
+  await set_state_fields(
+    { ...extra, _page: n, _pagesize: pagesize },
+    parent.currentLocation()
+  );
+}
+function mobile_modal(url, opts = {}) {
+  if ($("#scmodal").length === 0) {
+    $("body").append(`<div id="scmodal", class="modal">
+    <div class="modal-dialog">
+      <div class="modal-content">
+        <div class="modal-header">
+          <h5 class="modal-title">Modal title</h5>
+          <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close">
+          </button>
+        </div>
+        <div class="modal-body">
+          <p>Modal body text goes here.</p>
+        </div>
+      </div>
+    </div>
+  </div>`);
+  } else if ($("#scmodal").hasClass("show")) {
+    var myModalEl = document.getElementById("scmodal");
+    var modal = bootstrap.Modal.getInstance(myModalEl);
+    modal.dispose();
+  }
+  const { path, query } = parent.splitPathQuery(url);
+  // submitReload ?
+  parent.router
+    .resolve({ pathname: `get${path}`, query: query })
+    .then((page) => {
+      const modalContent = page.content;
+      const title = page.title;
+      if (title) $("#scmodal .modal-title").html(title);
+      $("#scmodal .modal-body").html(modalContent);
+      new bootstrap.Modal($("#scmodal")).show();
+      // onOpen onClose initialize_page?
+    });
+}
+async function view_post(viewname, route, data, onDone) {
+  const result = await parent.router.resolve({
+    pathname: `post/view/${viewname}/${route}`,
+    data,
+  });
+  common_done(result);
+}
+async function local_post(url, args) {
+  const result = await parent.router.resolve({
+    pathname: `post${url}`,
+    data: args,
+  });
+  if (result.redirect) await parent.handleRoute(result.redirect);
+  else common_done(result);
+}
+async function local_post_json(url) {
+  const result = await parent.router.resolve({
+    pathname: `post${url}`,
+  });
+  if (result.redirect) await parent.handleRoute(result.redirect);
+  else common_done(result);
+}
+async function make_unique_field(
+  id,
+  table_id,
+  field_name,
+  elem,
+  space,
+  start,
+  always_append,
+  char_type
+) {
+  const value = $(elem).val();
+  if (!value) return;
+  const path = `/api/${table_id}?approximate=true&${encodeURIComponent(
+    field_name
+  )}=${encodeURIComponent(value)}&fields=${encodeURIComponent(field_name)}`;
+  try {
+    // TODO ch support local tables
+    const response = await parent.apiCall({
+      method: "GET",
+      path,
+    });
+    if (response.data.success) {
+      unique_field_from_rows(
+        response.data.success,
+        id,
+        field_name,
+        space,
+        start,
+        always_append,
+        char_type,
+        value
+      );
+    }
+  } catch (error) {
+    console.log("unable to 'make_unique_field'");
+  }
+}
+function reload_on_init() {
+  console.log("not yet supported");
+}

package/www/js/utils/login_form.js ADDED Viewed

@@ -0,0 +1,40 @@
+const buildForm = (entryView) => {
+  return new saltcorn.data.models.Form({
+    class: "login",
+    fields: [
+      new saltcorn.data.models.Field({
+        label: "E-mail",
+        name: "email",
+        type: "String",
+        attributes: {
+          input_type: "email",
+        },
+        validator: (s) => s.length < 128,
+      }),
+      new saltcorn.data.models.Field({
+        label: "Password",
+        name: "password",
+        input_type: "password",
+      }),
+    ],
+    action: "javascript:void(0);",
+    onSubmit: `javascript:loginFormSubmit(this, '${entryView}')`,
+    submitLabel: "Login",
+  });
+};
+export const renderLoginForm = (entryView, version_tag) => {
+  const loginForm = buildForm(entryView);
+  const layout = saltcorn.data.state.getState().layouts["sbadmin2"];
+  return layout.authWrap({
+    title: "login",
+    form: loginForm,
+    authLinks: { signup: "/auth/signup" }, // TODO ch '/auth/signup' link
+    alerts: [],
+    headers: [
+      { css: `static_assets/${version_tag}/saltcorn.css` },
+      { script: "js/utils/iframe_view_utils.js" },
+    ],
+    csrfToken: false,
+  });
+};

package/www/js/utils/table_utils.js ADDED Viewed

@@ -0,0 +1,61 @@
+import { fileExists, readJSON, writeJSON } from "./file_helpers.js";
+async function updateScTables(tablesJSON) {
+  saltcorn.data.db.query("PRAGMA foreign_keys = OFF;");
+  for (const { table, rows } of tablesJSON.sc_tables) {
+    await saltcorn.data.db.deleteWhere(table);
+    for (const row of rows) {
+      await saltcorn.data.db.insert(table, row);
+    }
+  }
+  saltcorn.data.db.query("PRAGMA foreign_keys = ON;");
+}
+async function handleUserDefinedTables() {
+  const tables = await saltcorn.data.models.Table.find();
+  const existingTables = await saltcorn.data.db.listUserDefinedTables();
+  const skipIds = [1]; // skip user table
+  for (const table of tables) {
+    if (existingTables.find((row) => row.name === table.name)) {
+      skipIds.push(table.id);
+    } else if (table.name !== "users") {
+      // CREATE TABLE without inserting into _sc_tables
+      await saltcorn.data.models.Table.create(table.name, {}, table.id);
+    }
+  }
+  const fields = await saltcorn.data.models.Field.find();
+  for (const field of fields) {
+    if (skipIds.indexOf(field.table_id) < 0 && field.name !== "id")
+      await saltcorn.data.models.Field.create(field, false, field.id);
+  }
+}
+async function tablesUptodate(tables, historyFile) {
+  const history = await readJSON(historyFile, cordova.file.dataDirectory);
+  return tables.created_at.valueOf() < history.updated_at.valueOf();
+}
+export async function updateDbIfNecessary() {
+  const historyFile = "update_history";
+  const tablesJSON = await readJSON(
+    "tables.json",
+    `${cordova.file.applicationDirectory}${"www"}`
+  );
+  if (
+    !(await fileExists(`${cordova.file.dataDirectory}${historyFile}`)) ||
+    !(await tablesUptodate(tablesJSON, historyFile))
+  ) {
+    await updateScTables(tablesJSON);
+    await saltcorn.data.state.getState().refresh_tables();
+    await handleUserDefinedTables();
+    await writeJSON(historyFile, cordova.file.dataDirectory, {
+      updated_at: new Date(),
+    });
+  }
+}
+export async function getTableIds(tableNames) {
+  return (await saltcorn.data.models.Table.find())
+    .filter((table) => tableNames.indexOf(table.name) > -1)
+    .map((table) => table.id);
+}