@saltcorn/reservable 0.1.1 → 0.1.3

package/README.md

@@ -2,36 +2,34 @@
 
 To use this Plugin, you should create a table for reservations. This table should have the following fields:
 
-* A Date field for the time of the start of the reservation
-* An integer field for the duration After reservation in minutes
-* Any other fields for the reservation, for instance the email of the person reserving the slot
+- A Date field for the time of the start of the reservation
+- An integer field for the duration of the reservation in minutes
+- Any other fields for the reservation, for instance the email of the person reserving the slot
 
 This table also needs to have two views
 
-* A view to create, typically an Edit view obtain the information required for the booking. 
+- A view to create, typically an Edit view obtain the information required for the booking.
   This Edit view does not need to have fields for the date or the duration.
-* A confirmation view, typically a Show view, which is displayed to the user on a successful reservation. 
+- A confirmation view, typically a Show view, which is displayed to the user on a successful reservation.
   This may or may not contain Date and duration
 
 There may be another table indicating reservable resources. This is optional. If you are building a reservation system
-for a single resource, you can leave this out. On the other hand, if you are building a system where multiple resources 
-need to be tracked for whether they are available, use this to denote the resources that can be taken/available. 
+for a single resource, you can leave this out. On the other hand, if you are building a system where multiple resources
+need to be tracked for whether they are available, use this to denote the resources that can be taken/available.
 To do this, create a foreign key field on your reservations Table to the reservable resource table.
 
 You should then create a Reserve view on the reservations table. In the configuration, you specify the fields
 As explained above. You will also need to configure:
 
-* What services are available. Each service has a name and a duration.
-* What the availability is, your opening hours. You specify these in blocks of time and the day of the week.
+- What services are available. Each service has a name and a duration.
+- What the availability is, your opening hours. You specify these in blocks of time and the day of the week.
 
 ### Example
 
-Goldilocks and Rapunzel together run the successful GoldiRap Hair Salon. In fact they are so successful that 
-they must now implement an online booking system. Their opening hours are Monday to Friday 9-12 and 13-17 
-(they close for lunch) and Saturday 10-13. They offer two services: A haircut taking 30 minutes 
+Goldilocks and Rapunzel together run the successful GoldiRap Hair Salon. In fact they are so successful that
+they must now implement an online booking system. Their opening hours are Monday to Friday 9-12 and 13-17
+(they close for lunch) and Saturday 10-13. They offer two services: A haircut taking 30 minutes
 and a full restyle taking 45 minutes. You can book either Goldilocks or Rapunzel for each of the services.
 
-Here, the reservable resource is the hairdresser with two rows: Goldilocks and Rapunzel. They have two services, 
+Here, the reservable resource is the hairdresser with two rows: Goldilocks and Rapunzel. They have two services,
 haircut and full restyle. The availability can be specified as: Mon-Fri 9-12, Mon-Fri 13-17 and Saturday 10-13.
-
-

package/available-feed.js

@@ -0,0 +1,277 @@
+const {
+  input,
+  div,
+  text,
+  script,
+  domReady,
+  style,
+  button,
+  h3,
+  ul,
+  li,
+  form,
+  a,
+  b,
+} = require("@saltcorn/markup/tags");
+
+const View = require("@saltcorn/data/models/view");
+const Workflow = require("@saltcorn/data/models/workflow");
+const Table = require("@saltcorn/data/models/table");
+const Form = require("@saltcorn/data/models/form");
+const Field = require("@saltcorn/data/models/field");
+const {
+  InvalidConfiguration,
+  isNode,
+  isWeb,
+  mergeConnectedObjects,
+  hashState,
+} = require("@saltcorn/data/utils");
+const {
+  link_view,
+  stateToQueryString,
+  stateFieldsToWhere,
+  stateFieldsToQuery,
+  readState,
+} = require("@saltcorn/data/plugin-helper");
+const get_state_fields = async (table_id, viewname, { show_view }) => {
+  const table = Table.findOne(table_id);
+  const table_fields = table.fields;
+  return table_fields
+    .filter((f) => !f.primary_key)
+    .map((f) => {
+      const sf = new Field(f);
+      sf.required = false;
+      return sf;
+    });
+};
+
+const configuration_workflow = (req) =>
+  new Workflow({
+    steps: [
+      {
+        name: req.__("Views"),
+        form: async (context) => {
+          const table = Table.findOne(context.table_id);
+          const fields = table.fields;
+
+          const reservable_entity_fields = fields.filter((f) => f.is_fkey);
+          const show_view_opts = {};
+          const slots_available_field = {};
+          const distinct_slot_fields = new Set();
+          for (const rfield of reservable_entity_fields) {
+            const retable = Table.findOne(rfield.reftable_name);
+            const show_views = await View.find_table_views_where(
+              retable.id,
+              ({ state_fields, viewtemplate, viewrow }) =>
+                viewtemplate.runMany &&
+                viewrow.name !== context.viewname &&
+                state_fields.some((sf) => sf.name === "id")
+            );
+            show_view_opts[rfield.name] = show_views.map((v) => v.name);
+            slots_available_field[rfield.name] = retable.fields
+              .filter((f) => f.type?.name === "Integer")
+              .map((f) => f.name);
+            slots_available_field[rfield.name].forEach((v) =>
+              distinct_slot_fields.add(v)
+            );
+            slots_available_field[rfield.name].unshift("");
+          }
+          return new Form({
+            fields: [
+              {
+                name: "reservable_entity_key",
+                label: "Key to reservable entity",
+                type: "String",
+                required: true,
+                attributes: {
+                  options: reservable_entity_fields.map((f) => f.name),
+                },
+              },
+              {
+                name: "valid_field",
+                label: "Valid reservation field",
+                sublabel: "Only consider reservations with this field valid",
+                type: "String",
+                attributes: {
+                  options: fields
+                    .filter((f) => f.type.name === "Bool")
+                    .map((f) => f.name),
+                },
+              },
+              {
+                name: "start_field",
+                label: "Start date field",
+                type: "String",
+                required: true,
+                attributes: {
+                  options: fields
+                    .filter((f) => f.type.name === "Date")
+                    .map((f) => f.name),
+                },
+              },
+              {
+                name: "end_field",
+                label: "End date field",
+                type: "String",
+                required: true,
+                attributes: {
+                  options: fields
+                    .filter((f) => f.type.name === "Date")
+                    .map((f) => f.name),
+                },
+              },
+              /*{
+                name: "duration_field",
+                label: "Duration field",
+                sublabel: "Integer field holding booked duration in minutes",
+                type: "String",
+                attributes: {
+                  options: fields
+                    .filter((f) => f.type.name === "Integer")
+                    .map((f) => f.name),
+                },
+              }, */
+              {
+                name: "show_view",
+                label: req.__("Single item view"),
+                type: "String",
+                sublabel:
+                  req.__("The underlying individual view of each table row") +
+                  ". " +
+                  a(
+                    {
+                      "data-dyn-href": `\`/viewedit/config/\${show_view}\``,
+                      target: "_blank",
+                    },
+                    req.__("Configure")
+                  ),
+                required: true,
+                attributes: {
+                  calcOptions: ["reservable_entity_key", show_view_opts],
+                },
+              },
+              {
+                name: "slots_available_field",
+                label: "Slots available field",
+                sublabel:
+                  "Field with a number of available instances of the reservable entity. If blank, treat as one per entity.",
+                type: "String",
+                attributes: {
+                  calcOptions: ["reservable_entity_key", slots_available_field],
+                },
+              },
+              {
+                name: "slot_count_field",
+                label: "Slots taken field",
+                sublabel:
+                  "Field with the number of entities reserved. If blank, treat as one per entity.",
+                type: "String",
+                showIf: { slots_available_field: [...distinct_slot_fields] },
+                attributes: {
+                  options: fields
+                    .filter((f) => f.type.name === "Integer")
+                    .map((f) => f.name),
+                },
+              },
+            ],
+          });
+        },
+      },
+    ],
+  });
+
+const first = (xs) => (Array.isArray(xs) ? xs[0] : xs);
+
+const run = async (
+  table_id,
+  viewname,
+  {
+    reservable_entity_key,
+    valid_field,
+    slot_count_field,
+    slots_available_field,
+    show_view,
+    start_field,
+    end_field,
+  },
+  state,
+  extraArgs
+) => {
+  const restable = Table.findOne({ id: table_id });
+  const resfields = restable.getFields();
+
+  const refield = restable.getField(reservable_entity_key);
+  const retable = Table.findOne(refield.reftable_name);
+
+  const state_res = { ...state };
+
+  readState(state_res, restable.fields);
+
+  //get reservations
+  const reswhere = await stateFieldsToWhere({
+    fields: resfields,
+    state: state_res,
+    table: restable,
+  });
+
+  if (valid_field) reswhere[valid_field] = true;
+  const reservations = await restable.getRows(reswhere);
+  const use_slots = slot_count_field || slots_available_field;
+  const sview = await View.findOne({ name: show_view });
+  if (!sview)
+    throw new InvalidConfiguration(
+      `View ${viewname} incorrectly configured: cannot find view ${show_view}`
+    );
+  const srespAll = await sview.runMany(state, extraArgs);
+  const srespsAvailable = [];
+
+  if (!use_slots) {
+    const resEnts = new Set(reservations.map((r) => r[reservable_entity_key]));
+    for (const sresp of srespAll) {
+      if (!resEnts.has(sresp.row[retable.pk_name])) srespsAvailable.push(sresp);
+    }
+  } else {
+    //console.log("state_res", state_res);
+    //console.log("reswhere", reswhere);
+    const to = new Date(first(reswhere[start_field])?.lt);
+    const from = new Date(first(reswhere[end_field])?.gt);
+    if (!from || !to) srespsAvailable.push(...srespAll);
+    else
+      for (const sresp of srespAll) {
+        const myreservations = reservations.filter(
+          (r) => r[reservable_entity_key] === sresp.row[retable.pk_name]
+        );
+        /*console.log({
+        taken: resEnts[sresp.row[retable.pk_name]] || 0,
+        available: sresp.row[slots_available_field],
+      });*/
+        const to = new Date(first(reswhere[start_field])?.lt);
+        const from = new Date(first(reswhere[end_field])?.gt);
+        let maxAvailable = sresp.row[slots_available_field];
+        for (let day = from; day <= to; day.setDate(day.getDate() + 1)) {
+          const active = myreservations.filter(
+            (r) => r[start_field] <= day && r[end_field] >= day
+          );
+          const taken = active
+            .map((r) => r[slot_count_field] || 1)
+            .reduce((a, b) => a + b, 0);
+          maxAvailable = Math.min(
+            maxAvailable,
+            sresp.row[slots_available_field] - taken
+          );
+          //console.log({ car: sresp.row.name, day, maxAvailable });
+        }
+        if (maxAvailable > 0) srespsAvailable.push(sresp);
+      }
+  }
+  const showRow = (r) => r.html;
+  return div(srespsAvailable.map(showRow));
+};
+
+module.exports = {
+  name: "Available Resources Feed",
+  display_state_form: false,
+  get_state_fields,
+  configuration_workflow,
+  run,
+};

package/index.js

@@ -167,7 +167,8 @@ const configuration_workflow = () =>
   });
 
 const get_state_fields = async (table_id, viewname, { show_view }) => {
-  const table_fields = await Field.find({ table_id });
+  const table = Table.findOne(table_id);
+  const table_fields = table.fields;
   return table_fields.map((f) => {
     const sf = new Field(f);
     sf.required = false;
@@ -525,7 +526,9 @@ module.exports = {
       run,
       runPost,
     },
+    require("./available-feed"),
   ],
+  actions: { validate_reservation: require("./validate") },
 };
 
 /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/reservable",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Reservable resources",
   "main": "index.js",
   "dependencies": {
@@ -18,5 +18,21 @@
   },
   "scripts": {
     "test": "jest"
+  },
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "parserOptions": {
+      "ecmaVersion": 2020
+    },
+    "env": {
+      "node": true,
+      "es6": true
+    },
+    "rules": {
+      "no-unused-vars": "off",
+      "no-case-declarations": "off",
+      "no-empty": "warn",
+      "no-fallthrough": "warn"
+    }
   }
 }

package/validate.js

@@ -0,0 +1,71 @@
+const View = require("@saltcorn/data/models/view");
+const Table = require("@saltcorn/data/models/table");
+
+module.exports = {
+  configFields: async ({ table }) => {
+    const views = await View.find({
+      viewtemplate: "Available Resources Feed",
+      table_id: table.id,
+    });
+    return [
+      {
+        name: "feedview",
+        label: "View",
+        sublabel: `A view on table ${table.name} with pattern: Available Resources Feed`,
+        type: "String",
+        required: true,
+        attributes: {
+          options: views.map((f) => f.name),
+        },
+      },
+    ];
+  },
+  requireRow: true,
+  run: async ({ table, req, row, configuration: { feedview } }) => {
+    const view = View.findOne({ name: feedview });
+    const {
+      reservable_entity_key,
+      valid_field,
+      slot_count_field,
+      slots_available_field,
+      show_view,
+      start_field,
+      end_field,
+    } = view.configuration;
+    //get all relevant reservations
+
+    const ress = await table.getRows({
+      [reservable_entity_key]: row[reservable_entity_key],
+      [start_field]: { lt: row[end_field], equal: true, day_only: true },
+      [end_field]: { gt: row[start_field], equal: true, day_only: true },
+      ...(valid_field ? { [valid_field]: true } : {}),
+    });
+
+    //get entity
+    const refield = table.getField(reservable_entity_key);
+    const retable = Table.findOne(refield.reftable_name);
+    const entity = await retable.getRow({
+      [retable.pk_name]: row[reservable_entity_key],
+    });
+    //check that for every day, there is availablity
+    const from = new Date(row[start_field]);
+    const to = new Date(row[end_field]);
+    let maxAvailable = entity[slots_available_field];
+    // loop for every day
+    for (let day = from; day <= to; day.setDate(day.getDate() + 1)) {
+      // your day is here
+      const active = ress.filter(
+        (r) => r[start_field] <= day && r[end_field] >= day
+      );
+      const taken = active
+        .map((r) => r[slot_count_field])
+        .reduce((a, b) => a + b, 0);
+      maxAvailable = Math.min(
+        maxAvailable,
+        entity[slots_available_field] - taken
+      );
+    }
+    if (maxAvailable < row[slot_count_field])
+      return { error: `Only ${maxAvailable} are available` };
+  },
+};