@saltcorn/server 0.9.3-beta.4 → 0.9.3-beta.6

package/routes/page.js

@@ -5,11 +5,12 @@
  */
 
 const Router = require("express-promise-router");
+const { UAParser } = require("ua-parser-js");
 
 const Page = require("@saltcorn/data/models/page");
+const PageGroup = require("@saltcorn/data/models/page_group");
 const Trigger = require("@saltcorn/data/models/trigger");
-const File = require("@saltcorn/data/models/file");
-const { getState } = require("@saltcorn/data/db/state");
+const { getState, features } = require("@saltcorn/data/db/state");
 const {
   error_catcher,
   scan_for_page_title,
@@ -18,6 +19,7 @@ const {
 } = require("../routes/utils.js");
 const { isTest } = require("@saltcorn/data/utils");
 const { add_edit_bar } = require("../markup/admin.js");
+const { script, domReady } = require("@saltcorn/markup/tags");
 const { traverseSync } = require("@saltcorn/data/models/layout");
 const { run_action_column } = require("@saltcorn/data/plugin-helper");
 const db = require("@saltcorn/data/db");
@@ -32,56 +34,134 @@ const db = require("@saltcorn/data/db");
 const router = new Router();
 module.exports = router;
 
-/**
- * @name get/:pagename
- * @function
- * @memberof module:routes/page~pageRouter
- * @function
- */
+const findPageOrGroup = (pagename) => {
+  const page = Page.findOne({ name: pagename });
+  if (page) return { page, pageGroup: null };
+  else {
+    const pageGroup = PageGroup.findOne({ name: pagename });
+    if (pageGroup) return { page: null, pageGroup };
+    else return { page: null, pageGroup: null };
+  }
+};
+
+const runPage = async (page, req, res, tic) => {
+  const role = req.user && req.user.id ? req.user.role_id : 100;
+  if (role <= page.min_role) {
+    const contents = await page.run(req.query, { res, req });
+    const title = scan_for_page_title(contents, page.title);
+    const tock = new Date();
+    const ms = tock.getTime() - tic.getTime();
+    if (!isTest())
+      Trigger.emitEvent("PageLoad", null, req.user, {
+        text: req.__("Page '%s' was loaded", page.name),
+        type: "page",
+        name: page.name,
+        render_time: ms,
+      });
+    if (contents.html_file) await sendHtmlFile(req, res, contents.html_file);
+    else
+      res.sendWrap(
+        {
+          title,
+          description: page.description,
+          bodyClass: "page_" + db.sqlsanitize(page.name),
+          no_menu: page.attributes?.no_menu,
+        } || `${page.name} page`,
+        add_edit_bar({
+          role,
+          title: page.name,
+          what: req.__("Page"),
+          url: `/pageedit/edit/${encodeURIComponent(page.name)}`,
+          contents,
+        })
+      );
+  } else {
+    getState().log(2, `Page ${page.name} not authorized`);
+    res.status(404).sendWrap(` page`, req.__("Page %s not found", page.name));
+  }
+};
+
+const uaDevice = (req) => {
+  const uaParser = new UAParser(req.headers["user-agent"]);
+  const device = uaParser.getDevice();
+  if (!device.type) return "web";
+  else return device.type;
+};
+
+const screenInfoFromCfg = (req) => {
+  const device = uaDevice(req);
+  const uaScreenInfos = getState().getConfig("user_agent_screen_infos", {});
+  return { device, ...uaScreenInfos[device] };
+};
+
+const runPageGroup = async (pageGroup, req, res, tic) => {
+  const role = req.user && req.user.id ? req.user.role_id : 100;
+  if (role <= pageGroup.min_role) {
+    if (pageGroup.members.length === 0) {
+      getState().log(2, `Pagegroup ${pageGroup.name} has no members`);
+      res
+        .status(400)
+        .sendWrap(
+          ` page`,
+          req.__("Pagegroup %s has no members", pageGroup.name)
+        );
+    } else {
+      let screenInfos = null;
+      if (req.cookies["_sc_screen_info_"]) {
+        screenInfos = JSON.parse(req.cookies["_sc_screen_info_"]);
+        screenInfos.device = uaDevice(req);
+      } else {
+        const strategy = getState().getConfig(
+          "missing_screen_info_strategy",
+          "guess_from_user_agent"
+        );
+        if (strategy === "guess_from_user_agent")
+          screenInfos = screenInfoFromCfg(req);
+        else if (strategy === "reload" && req.query.is_reload !== "true") {
+          return res.sendWrap(
+            script(
+              domReady(`
+                setScreenInfoCookie();
+                window.location = updateQueryStringParameter(window.location.href, "is_reload", true);`)
+            )
+          );
+        }
+      }
+      const eligiblePage = await pageGroup.getEligiblePage(
+        screenInfos,
+        req.user ? req.user : { role_id: features.public_user_role },
+        req.getLocale()
+      );
+      if (eligiblePage) await runPage(eligiblePage, req, res, tic);
+      else {
+        getState().log(2, `Pagegroup ${pageGroup.name} has no eligible page`);
+        res
+          .status(404)
+          .sendWrap(` page`, req.__("%s has no eligible page", pageGroup.name));
+      }
+    }
+  } else {
+    getState().log(2, `Pagegroup ${pageGroup.name} not authorized`);
+    res
+      .status(404)
+      .sendWrap(` page`, req.__("Pagegroup %s not found", pageGroup.name));
+  }
+};
+
 router.get(
   "/:pagename",
   error_catcher(async (req, res) => {
     const { pagename } = req.params;
-    const state = getState();
-    state.log(3, `Route /page/${pagename} user=${req.user?.id}`);
+    getState().log(3, `Route /page/${pagename} user=${req.user?.id}`);
     const tic = new Date();
-
-    const role = req.user && req.user.id ? req.user.role_id : 100;
-    const db_page = await Page.findOne({ name: pagename });
-    if (db_page && role <= db_page.min_role) {
-      const contents = await db_page.run(req.query, { res, req });
-      const title = scan_for_page_title(contents, db_page.title);
-      const tock = new Date();
-      const ms = tock.getTime() - tic.getTime();
-      if (!isTest())
-        Trigger.emitEvent("PageLoad", null, req.user, {
-          text: req.__("Page '%s' was loaded", pagename),
-          type: "page",
-          name: pagename,
-          render_time: ms,
-        });
-      if (contents.html_file) await sendHtmlFile(req, res, contents.html_file);
-      else
-        res.sendWrap(
-          {
-            title,
-            description: db_page.description,
-            bodyClass: "page_" + db.sqlsanitize(pagename),
-            no_menu: db_page.attributes?.no_menu,
-          } || `${pagename} page`,
-          add_edit_bar({
-            role,
-            title: db_page.name,
-            what: req.__("Page"),
-            url: `/pageedit/edit/${encodeURIComponent(db_page.name)}`,
-            contents,
-          })
-        );
-    } else {
-      if (db_page && !req.user) {
+    const { page, pageGroup } = findPageOrGroup(pagename);
+    if (page) await runPage(page, req, res, tic);
+    else if (pageGroup) await runPageGroup(pageGroup, req, res, tic);
+    else {
+      if ((page || pageGroup) && !req.user) {
         res.redirect(`/auth/login?dest=${encodeURIComponent(req.originalUrl)}`);
       } else {
-        state.log(2, `Page $pagename} not found or not authorized`);
+        getState().log(2, `Page ${pagename} not found or not authorized`);
         res
           .status(404)
           .sendWrap(`${pagename} page`, req.__("Page %s not found", pagename));
@@ -105,12 +185,6 @@ router.post(
   })
 );
 
-/**
- * @name post/:pagename/action/:rndid
- * @function
- * @memberof module:routes/page~pageRouter
- * @function
- */
 router.post(
   "/:pagename/action/:rndid",
   error_catcher(async (req, res) => {

package/routes/page_group.js

@@ -0,0 +1,378 @@
+const Router = require("express-promise-router");
+
+const Form = require("@saltcorn/data/models/form");
+const { error_catcher, isAdmin } = require("./utils.js");
+const { send_infoarch_page } = require("../markup/admin.js");
+const { getState } = require("@saltcorn/data/db/state");
+const { a, div, i, p } = require("@saltcorn/markup/tags");
+const {
+  renderForm,
+  link,
+  post_delete_btn,
+  mkTable,
+} = require("@saltcorn/markup");
+
+const router = new Router();
+module.exports = router;
+
+const deviceTypes = [
+  "mobile",
+  "tablet",
+  "console",
+  "smarttv",
+  "wearable",
+  "web",
+];
+
+const deviceForm = (req, deviceValidator, device) => {
+  const sizeValidator = (v) => {
+    const n = +v;
+    if (isNaN(n)) return req.__("Not a number");
+    if (n < 0) return req.__("Must be positive");
+  };
+  return new Form({
+    action: `/page_group/settings/${
+      !device ? "add-device" : `edit-device/${device}`
+    }`,
+    fields: [
+      {
+        name: "device",
+        input_type: "select",
+        type: "String",
+        options: ["mobile", "tablet", "console", "smarttv", "wearable", "web"],
+        required: true,
+        validator: deviceValidator,
+      },
+      {
+        name: "width",
+        label: req.__("width"),
+        type: "String",
+        required: true,
+        validator: sizeValidator,
+      },
+      {
+        name: "height",
+        label: req.__("height"),
+        type: "String",
+        required: true,
+        validator: sizeValidator,
+      },
+      {
+        name: "innerWidth",
+        label: req.__("innerWidth"),
+        type: "String",
+        required: true,
+        validator: sizeValidator,
+      },
+      {
+        name: "innerHeight",
+        label: req.__("innerHeight"),
+        type: "String",
+        required: true,
+        validator: sizeValidator,
+      },
+    ],
+    additionalButtons: [
+      {
+        label: device ? req.__("Close") : req.__("Cancel"),
+        class: "btn btn-primary",
+        onclick: "location.href='/page_group/settings'",
+      },
+    ],
+  });
+};
+
+const loadDeviceConfigs = () => {
+  const cfg = getState().getConfig("user_agent_screen_infos", {});
+  const deviceConfigs = deviceTypes
+    .filter((device) => cfg[device])
+    .map((device) => ({
+      device,
+      ...cfg[device],
+    }));
+  return deviceConfigs;
+};
+
+const pageGroupSettingsForm = (req) => {
+  return new Form({
+    action: "/page_group/settings/config",
+    noSubmitButton: true,
+    onChange: `saveAndContinue(this)`,
+    fields: [
+      {
+        name: "missing_screen_info_strategy",
+        label: req.__("Missing screen info"),
+        sublabel: req.__(
+          "What to do if no screen info is given. Reload with parmeters or guess it from the user-agent."
+        ),
+        type: "String",
+        input_type: "select",
+        options: [
+          {
+            label: req.__("Guess from user agent"),
+            value: "guess_from_user_agent",
+          },
+          { label: req.__("Reload"), value: "reload" },
+        ],
+        required: true,
+      },
+    ],
+  });
+};
+
+/**
+ * load the screen-info table
+ */
+router.get(
+  "/settings",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const deviceConfigs = loadDeviceConfigs();
+    const pgForm = pageGroupSettingsForm(req);
+    pgForm.values.missing_screen_info_strategy = getState().getConfig(
+      "missing_screen_info_strategy",
+      "guess_from_user_agent"
+    );
+    send_infoarch_page({
+      res,
+      req,
+      active_sub: "Pagegroups",
+      contents: [
+        {
+          type: "card",
+          title: req.__("User Agent screen infos"),
+          contents: [
+            p(
+              req.__(
+                "This screen infos are used when the browser does not send them. " +
+                  "With 'Missing screen info' set to 'Guess from user agent', the user agent gets mapped to a device with the following values."
+              )
+            ),
+            mkTable(
+              [
+                {
+                  label: "Device",
+                  key: (r) =>
+                    link(
+                      `/page_group/settings/edit-device/${r.device}`,
+                      r.device
+                    ),
+                },
+                { label: "width", key: (r) => r.width },
+                { label: "height", key: (r) => r.height },
+                { label: "innerWidth", key: (r) => r.innerWidth },
+                { label: "innerHeight", key: (r) => r.innerHeight },
+                {
+                  label: req.__("Delete"),
+                  key: (r) =>
+                    post_delete_btn(
+                      `/page_group/settings/remove-device/${r.device}`,
+                      req,
+                      r.device
+                    ),
+                },
+              ],
+              deviceConfigs,
+              {}
+            ),
+            div(
+              a(
+                {
+                  href: "settings/add-device",
+                  class: "btn btn-primary mt-1 me-3",
+                },
+                i({ class: "fas fa-plus-square me-1" }),
+                req.__("Add screen info")
+              )
+            ),
+          ],
+        },
+
+        {
+          type: "card",
+          title: req.__("Page Group settings"),
+          contents: [renderForm(pgForm, req.csrfToken())],
+        },
+      ],
+    });
+  })
+);
+/**
+ * load a form to add a screen-info to the config
+ */
+router.get(
+  "/settings/add-device",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    send_infoarch_page({
+      res,
+      req,
+      active_sub: "Pagegroups",
+      contents: {
+        type: "card",
+        title: req.__("Add screen info"),
+        contents: [
+          renderForm(
+            deviceForm(req, () => {}),
+            req.csrfToken()
+          ),
+        ],
+      },
+    });
+  })
+);
+
+/**
+ * add a screen-info to the config
+ */
+router.post(
+  "/settings/add-device",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const cfg = getState().getConfig("user_agent_screen_infos", {});
+    const validator = (v) => {
+      if (cfg[v]) return req.__("Device already exists");
+    };
+    const form = deviceForm(req, validator);
+    form.validate(req.body);
+    if (form.hasErrors) {
+      send_infoarch_page({
+        res,
+        req,
+        active_sub: "Pagegroups",
+        contents: {
+          type: "card",
+          title: req.__("Add screen info"),
+          contents: [renderForm(form, req.csrfToken())],
+        },
+      });
+    } else {
+      const { device, width, height, innerWidth, innerHeight } = form.values;
+      const newCfg = {
+        ...cfg,
+        [device]: { width, height, innerWidth, innerHeight },
+      };
+      await getState().setConfig("user_agent_screen_infos", newCfg);
+      req.flash("success", req.__("Screen info added"));
+      res.redirect("/page_group/settings");
+    }
+  })
+);
+
+/**
+ * remove a screen-info from the config
+ */
+router.post(
+  "/settings/remove-device/:device",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { device } = req.params;
+    const cfg = getState().getConfig("user_agent_screen_infos", {});
+    const newCfg = { ...cfg };
+    delete newCfg[device];
+    await getState().setConfig("user_agent_screen_infos", newCfg);
+    req.flash("success", req.__("Screen info removed"));
+    res.redirect("/page_group/settings");
+  })
+);
+
+/**
+ * load a form to edit a screen-info
+ */
+router.get(
+  "/settings/edit-device/:device",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { device } = req.params;
+    const cfg = getState().getConfig("user_agent_screen_infos", {});
+    const deviceCfg = cfg[device];
+    const form = deviceForm(req, () => {}, device);
+    form.values = { device, ...deviceCfg };
+    send_infoarch_page({
+      res,
+      req,
+      active_sub: "Pagegroups",
+      contents: {
+        type: "card",
+        title: req.__("Edit screen info"),
+        contents: [renderForm(form, req.csrfToken())],
+      },
+    });
+  })
+);
+
+/**
+ * edit a screen-info
+ */
+router.post(
+  "/settings/edit-device/:device",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { device } = req.params;
+    const cfg = getState().getConfig("user_agent_screen_infos", {});
+    const validator = (v) => {
+      if (cfg[v] && v !== device) return req.__("Device already exists");
+    };
+    const form = deviceForm(req, validator, device);
+    const deviceCfg = cfg[device];
+    form.values = { device, ...deviceCfg };
+    form.validate(req.body);
+    if (form.hasErrors) {
+      send_infoarch_page({
+        res,
+        req,
+        active_sub: "Pagegroups",
+        contents: {
+          type: "card",
+          title: req.__("Edit device"),
+          contents: [renderForm(form, req.csrfToken())],
+        },
+      });
+    } else {
+      const { width, height, innerWidth, innerHeight } = form.values;
+      const newCfg = {
+        ...cfg,
+        [form.values.device]: { width, height, innerWidth, innerHeight },
+      };
+      if (device !== form.values.device) delete newCfg[device];
+      await getState().setConfig("user_agent_screen_infos", newCfg);
+      req.flash("success", req.__("Screen info saved"));
+      res.redirect("/page_group/settings");
+    }
+  })
+);
+
+/**
+ * save the missing_screen_info_strategy
+ * This configures what to do if no screen info is given (reload or guess from user-agent)
+ */
+router.post(
+  "/settings/config",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const form = pageGroupSettingsForm(req);
+    form.validate(req.body);
+    if (form.hasErrors) {
+      send_infoarch_page({
+        res,
+        req,
+        active_sub: "Pagegroups",
+        contents: {
+          type: "card",
+          title: req.__("Page Group settings"),
+          contents: [renderForm(form, req.csrfToken())],
+        },
+      });
+    } else {
+      const { missing_screen_info_strategy } = form.values;
+      await getState().setConfig(
+        "missing_screen_info_strategy",
+        missing_screen_info_strategy
+      );
+      req.flash("success", req.__("Settings saved"));
+      res.redirect("/page_group/settings");
+    }
+  })
+);
+
+// perhaps another service to omit endless reload loops here