@saltcorn/server 0.7.4-beta.1 → 0.7.4-beta.2

package/routes/tables.js

@@ -56,6 +56,7 @@ const {
 } = require("@saltcorn/data/models/discovery");
 const { getState } = require("@saltcorn/data/db/state");
 const { cardHeaderTabs } = require("@saltcorn/markup/layout_utils");
+const { tablesList } = require("./common_lists");
 
 /**
  * @type {object}
@@ -129,7 +130,7 @@ const tableForm = async (table, req) => {
       {
         label: req.__("Minimum role to read"),
         sublabel: req.__(
-          "User must have this role or higher to read rows from the table"
+          "User must have this role or higher to read rows from the table, unless they are the owner"
         ),
         name: "min_role_read",
         input_type: "select",
@@ -143,7 +144,7 @@ const tableForm = async (table, req) => {
             name: "min_role_write",
             input_type: "select",
             sublabel: req.__(
-              "User must have this role or higher to edit or create new rows in the table"
+              "User must have this role or higher to edit or create new rows in the table, unless they are the owner"
             ),
             options: roleOptions,
           },
@@ -888,7 +889,6 @@ router.post(
       if (rest.ownership_field_id === "_formula") {
         rest.ownership_field_id = null;
         const fmlValidRes = expressionValidator(rest.ownership_formula);
-        console.log({ fmlValidRes });
         if (typeof fmlValidRes === "string") {
           req.flash(
             "error",
@@ -1011,42 +1011,7 @@ router.get(
     const rows = await Table.find_with_external({}, { orderBy: "name" });
     const roles = await User.get_roles();
     const getRole = (rid) => roles.find((r) => r.id === rid).role;
-    const mainCard =
-      rows.length > 0
-        ? mkTable(
-          [
-            {
-              label: req.__("Name"),
-              key: (r) => link(`/table/${r.id || r.name}`, text(r.name)),
-            },
-            {
-              label: "",
-              key: (r) => tableBadges(r, req),
-            },
-            {
-              label: req.__("Access Read/Write"),
-              key: (t) =>
-                t.external
-                  ? `${getRole(t.min_role_read)} (read only)`
-                  : `${getRole(t.min_role_read)}/${getRole(
-                    t.min_role_write
-                  )}`,
-            },
-            {
-              label: req.__("Delete"),
-              key: (r) =>
-                r.name === "users" || r.external
-                  ? ""
-                  : post_delete_btn(`/table/delete/${r.id}`, req, r.name),
-            },
-          ],
-          rows,
-          { hover: true }
-        )
-        : div(
-          h4(req.__("No tables defined")),
-          p(req.__("Tables hold collections of similar data"))
-        );
+    const mainCard = await tablesList(rows, req);
     const createCard = div(
       h5(req.__("Create table")),
       a(

package/routes/tag_entries.js

@@ -0,0 +1,173 @@
+const {
+  a,
+  div,
+  text,
+  button,
+  i,
+  form,
+  select,
+  option,
+  label,
+} = require("@saltcorn/markup/tags");
+
+const Tag = require("@saltcorn/data/models/tag");
+const TagEntry = require("@saltcorn/data/models/tag_entry");
+const Router = require("express-promise-router");
+
+const { isAdmin, error_catcher, csrfField } = require("./utils");
+
+const Table = require("@saltcorn/data/models/table");
+const View = require("@saltcorn/data/models/view");
+const Page = require("@saltcorn/data/models/page");
+const Trigger = require("@saltcorn/data/models/trigger");
+
+const router = new Router();
+module.exports = router;
+
+const buildFields = (entryType, formOptions, req) => {
+  return Object.entries(formOptions).map(([type, list]) => {
+    return div(
+      { class: "form-group row" },
+      div({ class: "col-sm-2" }, label("type")),
+      div(
+        { class: "col-sm-10" },
+        select(
+          { name: "ids", class: "form-control form-select", multiple: true },
+          list.map((entry) => {
+            return option({ value: entry.id, label: entry.name });
+          })
+        )
+      ),
+      div(
+        { class: "col-sm-12" },
+        button({ type: "submit", class: "btn btn-primary" }, req.__("Save"))
+      )
+    );
+  });
+};
+
+const buildForm = (entryType, tag_id, formOptions, req) => {
+  return form(
+    { action: `/tag-entries/add/${entryType}/${tag_id}`, method: "post" },
+    csrfField(req),
+    buildFields(entryType, formOptions, req)
+  );
+};
+
+const formOptions = async (type, tag_id) => {
+  const tag = await Tag.findOne({ id: tag_id });
+  switch (type) {
+    case "tables": {
+      const ids = await tag.getTableIds();
+      return {
+        tables: (await Table.find()).filter(
+          (value) => ids.indexOf(value.id) === -1
+        ),
+      };
+    }
+    case "views": {
+      const ids = await tag.getViewIds();
+      return {
+        views: (await View.find()).filter(
+          (value) => ids.indexOf(value.id) === -1
+        ),
+      };
+    }
+    case "pages": {
+      const ids = await tag.getPageIds();
+      return {
+        pages: (await Page.find()).filter(
+          (value) => ids.indexOf(value.id) === -1
+        ),
+      };
+    }
+    case "trigger": {
+      const ids = await tag.getTriggerIds();
+      return {
+        trigger: (await Trigger.find()).filter(
+          (value) => ids.indexOf(value.id) === -1
+        ),
+      };
+    }
+  }
+};
+
+router.get(
+  "/add/:entry_type/:tag_id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { entry_type, tag_id } = req.params;
+    res.sendWrap(req.__("Add %s to tag"), {
+      above: [
+        {
+          type: "breadcrumbs",
+          crumbs: [{ text: `Tag entry` }],
+        },
+        {
+          type: "card",
+          title: `Add entries to tag`,
+          contents: buildForm(
+            entry_type,
+            tag_id,
+            await formOptions(entry_type, tag_id),
+            req
+          ),
+        },
+      ],
+    });
+  })
+);
+
+const idField = (entryType) => {
+  switch (entryType) {
+    case "tables": {
+      return "table_id";
+    }
+    case "views": {
+      return "view_id";
+    }
+    case "pages": {
+      return "page_id";
+    }
+    case "trigger": {
+      return "trigger_id";
+    }
+  }
+  return null;
+};
+
+router.post(
+  "/add/:entry_type/:tag_id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { entry_type, tag_id } = req.params;
+    const { ids } = req.body;
+    if (!ids) {
+      req.flash("error", req.__("Please select at least on item"));
+      return res.redirect(`/tag-entries/add/${entry_type}/${tag_id}`);
+    }
+    const fieldName = idField(entry_type);
+    const tag = await Tag.findOne({ id: tag_id });
+    for (const id of ids) {
+      await tag.addEntry({ [fieldName]: id });
+    }
+    res.redirect(`/tag/${tag_id}?show_list=${entry_type}`);
+  })
+);
+
+router.post(
+  "/remove/:entry_type/:entry_id/:tag_id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { tag_id, entry_type, entry_id } = req.params;
+    const fieldName = idField(entry_type);
+    const entry = await TagEntry.findOne({ tag_id, [fieldName]: entry_id });
+    entry[fieldName] = undefined;
+    if (entry.isEmpty()) {
+      await entry.delete();
+    } else {
+      await TagEntry.update(entry.id, { [fieldName]: null });
+    }
+    res.redirect(`/tag/${tag_id}?show_list=${entry_type}`);
+  })
+);

package/routes/tags.js

@@ -0,0 +1,266 @@
+const { a, text } = require("@saltcorn/markup/tags");
+
+const Tag = require("@saltcorn/data/models/tag");
+const Router = require("express-promise-router");
+const Form = require("@saltcorn/data/models/form");
+const User = require("@saltcorn/data/models/user");
+
+const { isAdmin, error_catcher, csrfField } = require("./utils");
+const { send_admin_page } = require("../markup/admin");
+
+const {
+  mkTable,
+  post_delete_btn,
+  link,
+  renderForm,
+} = require("@saltcorn/markup");
+
+const {
+  tablesList,
+  setTableRefs,
+  viewsList,
+  getPageList,
+  getTriggerList,
+} = require("./common_lists");
+
+const router = new Router();
+module.exports = router;
+
+router.get(
+  "/",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const rows = await Tag.find();
+    send_admin_page({
+      res,
+      req,
+      active_sub: "Tags",
+      contents: [
+        mkTable(
+          [
+            {
+              label: req.__("Tagname"),
+              key: (r) =>
+                link(`/tag/${r.id || r.name}?show_list=tables`, text(r.name)),
+            },
+            {
+              label: req.__("Delete"),
+              key: (r) => post_delete_btn(`/tag/delete/${r.id}`, req, r.name),
+            },
+          ],
+          rows,
+          {}
+        ),
+        a(
+          {
+            href: `/tag/new`,
+            class: "btn btn-primary",
+          },
+          req.__("Create tag")
+        ),
+      ],
+    });
+  })
+);
+
+router.get(
+  "/new",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    res.sendWrap(req.__(`New tag`), {
+      above: [
+        {
+          type: "card",
+          title: req.__(`New tag`),
+          contents: renderForm(
+            new Form({
+              action: "/tag",
+              submitLabel: req.__("Create"),
+              fields: [
+                {
+                  label: req.__("Tag name"),
+                  name: "name",
+                  input_type: "text",
+                  required: true,
+                },
+              ],
+            }),
+            req.csrfToken()
+          ),
+        },
+      ],
+    });
+  })
+);
+
+const headerWithCollapser = (title, cardId, showList) =>
+  a(
+    {
+      class: `card-header-left-collapse ${!showList ? "collapsed" : ""} ps-3`,
+      "data-bs-toggle": "collapse",
+      href: `#${cardId}`,
+      "aria-expanded": "false",
+      "aria-controls": cardId,
+      role: "button",
+    },
+    title
+  );
+
+const isShowList = (showList, listType) => showList === listType;
+
+router.get(
+  "/:idorname",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { idorname } = req.params;
+    const { show_list } = req.query;
+    const id = parseInt(idorname);
+    const tag = await Tag.findOne(id ? { id } : { name: idorname });
+    if (!tag) {
+      req.flash("error", req.__("Tag not found"));
+      return res.redirect(`/tag`);
+    }
+    const tables = await tag.getTables();
+    const views = await tag.getViews();
+    await setTableRefs(views);
+    const pages = await tag.getPages();
+    const trigger = await tag.getTrigger();
+    const roles = await User.get_roles();
+
+    const tablesDomId = "tablesListId";
+    const viewsDomId = "viewsListId";
+    const pagesDomId = "pagesDomId";
+    const triggerDomId = "triggerDomId";
+    res.sendWrap(req.__("%s Tag", tag.name), {
+      above: [
+        {
+          type: "breadcrumbs",
+          crumbs: [{ text: `Tag: ${tag.name}` }],
+        },
+        {
+          type: "card",
+          title: headerWithCollapser(
+            req.__("Tables"),
+            tablesDomId,
+            isShowList(show_list, "tables")
+          ),
+          contents: [
+            await tablesList(tables, req, {
+              tagId: tag.id,
+              domId: tablesDomId,
+              showList: isShowList(show_list, "tables"),
+            }),
+            a(
+              {
+                href: `/tag-entries/add/tables/${tag.id}`,
+                class: "btn btn-primary",
+              },
+              req.__("Add tables")
+            ),
+          ],
+        },
+        {
+          type: "card",
+          title: headerWithCollapser(
+            req.__("Views"),
+            viewsDomId,
+            isShowList(show_list, "views")
+          ),
+          contents: [
+            await viewsList(views, req, {
+              tagId: tag.id,
+              domId: viewsDomId,
+              showList: isShowList(show_list, "views"),
+            }),
+            a(
+              {
+                href: `/tag-entries/add/views/${tag.id}`,
+                class: "btn btn-primary",
+              },
+              req.__("Add views")
+            ),
+          ],
+        },
+        {
+          type: "card",
+          title: headerWithCollapser(
+            req.__("Pages"),
+            pagesDomId,
+            isShowList(show_list, "pages")
+          ),
+          contents: [
+            getPageList(pages, roles, req, {
+              tagId: tag.id,
+              domId: pagesDomId,
+              showList: isShowList(show_list, "pages"),
+            }),
+            a(
+              {
+                href: `/tag-entries/add/pages/${tag.id}`,
+                class: "btn btn-primary",
+              },
+              req.__("Add tages")
+            ),
+          ],
+        },
+        {
+          type: "card",
+          bodyId: "collapseTriggerCard",
+          title: headerWithCollapser(
+            req.__("Trigger"),
+            triggerDomId,
+            isShowList(show_list, "trigger")
+          ),
+          contents: [
+            getTriggerList(trigger, req, {
+              tagId: tag.id,
+              domId: triggerDomId,
+              showList: isShowList(show_list, "trigger"),
+            }),
+            a(
+              {
+                href: `/tag-entries/add/trigger/${tag.id}`,
+                class: "btn btn-primary",
+              },
+              req.__("Add trigger")
+            ),
+          ],
+        },
+      ],
+    });
+  })
+);
+
+// create
+router.post(
+  "/",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { name } = req.body;
+    const tag = await Tag.create({ name });
+    req.flash("success", req.__(`Tag %s created`, name));
+    res.redirect(`/tag/${tag.id}?show_list=tables`);
+  })
+);
+
+// delete
+router.post(
+  "/delete/:id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+    const tag = await Tag.findOne({ id });
+    if (!tag) {
+      req.flash("error", req.__("Tag not found"));
+      return res.redirect("/tag");
+    }
+    try {
+      await tag.delete();
+      req.flash("success", req.__("Tag %s deleted", tag.name));
+      res.redirect(`/tag`);
+    } catch (error) {
+      req.flash("error", error.message);
+      res.redirect(`/tag`);
+    }
+  })
+);