@saltcorn/reservable 0.1.2 → 0.1.3

package/available-feed.js

@@ -56,6 +56,8 @@ const configuration_workflow = (req) =>
 
           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(
@@ -66,6 +68,13 @@ const configuration_workflow = (req) =>
                 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: [
@@ -78,6 +87,17 @@ const configuration_workflow = (req) =>
                   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",
@@ -93,13 +113,14 @@ const configuration_workflow = (req) =>
                 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",
@@ -109,7 +130,7 @@ const configuration_workflow = (req) =>
                     .filter((f) => f.type.name === "Integer")
                     .map((f) => f.name),
                 },
-              },
+              }, */
               {
                 name: "show_view",
                 label: req.__("Single item view"),
@@ -129,6 +150,29 @@ const configuration_workflow = (req) =>
                   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),
+                },
+              },
             ],
           });
         },
@@ -136,10 +180,20 @@ const configuration_workflow = (req) =>
     ],
   });
 
+const first = (xs) => (Array.isArray(xs) ? xs[0] : xs);
+
 const run = async (
   table_id,
   viewname,
-  { reservable_entity_key, start_field, end_field, duration_field, show_view },
+  {
+    reservable_entity_key,
+    valid_field,
+    slot_count_field,
+    slots_available_field,
+    show_view,
+    start_field,
+    end_field,
+  },
   state,
   extraArgs
 ) => {
@@ -160,9 +214,9 @@ const run = async (
     table: restable,
   });
 
-  const ress = await restable.getRows(reswhere);
-  const resEnts = new Set(ress.map((r) => r[reservable_entity_key]));
-
+  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(
@@ -170,8 +224,45 @@ const run = async (
     );
   const srespAll = await sview.runMany(state, extraArgs);
   const srespsAvailable = [];
-  for (const sresp of srespAll) {
-    if (!resEnts.has(sresp.row[retable.pk_name])) srespsAvailable.push(sresp);
+
+  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));

package/index.js

@@ -528,6 +528,7 @@ module.exports = {
     },
     require("./available-feed"),
   ],
+  actions: { validate_reservation: require("./validate") },
 };
 
 /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/reservable",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Reservable resources",
   "main": "index.js",
   "dependencies": {

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` };
+  },
+};