@saltcorn/reservable 0.2.2 → 0.3.0

package/README.md

@@ -18,11 +18,7 @@ for a single resource, you can leave this out. On the other hand, if you are bui
 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.
 
 ### Example
 
@@ -33,3 +29,31 @@ and a full restyle taking 45 minutes. You can book either Goldilocks or Rapunzel
 
 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.
+
+### Using Reserve view
+
+The reserve view is a quick way to get started but offers limited control over the look and feel and workflow of the reservation process. 
+
+You should 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.
+
+### Using the "Reservation availabilites" table provider
+
+Using the table provider gives you full control over the workflow and the look and feel of your reservation process. 
+
+First, define a standard database table for reservations as described above. This table should also have an Edit view for adding new reservations.
+
+Now define a new table with the reservation availabilities table provider. in the configuration, pick the table for the reservations and fill out the field choices. You also set up the different services offered and the times you are available.
+
+You can now create lists or feed views on this provided table in order to display your availability to the user. 
+
+In order to let the user perform a reservation you should link to the edit view on the reservations table. Create a viewlink and pick this edit view on the reservations table with no relation. you need to use the extra state formula to identify the reservation time and duration. If you start tiem field name is `startat` and the duration field is `duration`, use this as the extra state formula: `{startat: start_date, duration: service_duration}` - `start_date` and `service_duration` are fields defined by the table provider as you can see in the field list. You can also use other Fields such as the service title to fill information in the edit view.
+
+You may also want to use the validate_reservation action to ensure that reservation is still available at the time of the booking (that is, it was not reserved by another user while the user was looking at the edit view). In the reservations table add a trigger with when=Validate and action=validate_reservation. This is simply configured by selecting the provided table.
+
+### Multiday bookings
+
+The Available Resources Feed view is used to make multi-day bookings for instance for hotel or car rental. 

package/common.js

@@ -0,0 +1,83 @@
+const gcd = function (a, b) {
+  if (!b) {
+    return a;
+  }
+
+  return gcd(b, a % b);
+};
+
+let gcdArr = function (arr) {
+  let gcdres = gcd(arr[0], arr[1]);
+  for (let i = 2; i < arr.length; i++) {
+    gcdres = gcd(gcdres, arr[i]);
+  }
+  return gcdres;
+};
+
+function range(size, startAt = 0) {
+  return [...Array(size).keys()].map((i) => i + startAt);
+}
+
+const get_available_slots = async ({
+  table,
+  availability,
+  date,
+  entity_wanted,
+  reservable_entity_key,
+  services,
+  start_field,
+  duration_field,
+}) => {
+  const from = new Date(date);
+  from.setHours(0, 0, 0, 0);
+  const to = new Date(date);
+  to.setHours(23, 59, 59, 999);
+  const q = {};
+  q[start_field] = [{ gt: from }, { lt: to }];
+  if (reservable_entity_key && entity_wanted)
+    q[reservable_entity_key] = entity_wanted;
+  //console.log(JSON.stringify({ date, q }, null, 2));
+  const taken_slots = await table.getRows(q);
+
+  // figure out regular availability for this day
+  const dayOfWeek = [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+  ][date.getDay()];
+  const relevant_availabilities = availability.filter(
+    ({ day }) =>
+      day === dayOfWeek ||
+      (day === "Mon-Fri" && !["Saturday", "Sunday"].includes(dayOfWeek))
+  );
+
+  const available_slots = [];
+  const durGCD = gcdArr(services.map((s) => s.duration));
+  relevant_availabilities.forEach(({ from, to }) => {
+    for (let i = (from * 60) / durGCD; i < (to * 60) / durGCD; i++) {
+      available_slots[i] = true;
+    }
+  });
+  //console.log({ taken_slots });
+  taken_slots.forEach((slot) => {
+    /*    console.log(
+      "taken slot",
+      slot,
+      slot[start_field].getHours(),
+      slot[start_field].getTimezoneOffset()
+    ); */
+    const from =
+      slot[start_field].getHours() * 60 + slot[start_field].getMinutes();
+    const to = from + slot[duration_field];
+    for (let i = from / durGCD; i < to / durGCD; i++) {
+      available_slots[i] = false;
+    }
+  });
+  return { available_slots, from, durGCD, taken_slots };
+};
+
+module.exports = { get_available_slots, range };

package/index.js

@@ -26,6 +26,8 @@ const { InvalidConfiguration } = require("@saltcorn/data/utils");
 const {
   getForm,
 } = require("@saltcorn/data/base-plugin/viewtemplates/viewable_fields");
+const { get_available_slots, range } = require("./common.js");
+
 const configuration_workflow = () =>
   new Workflow({
     steps: [
@@ -181,87 +183,6 @@ const get_state_fields = async (table_id, viewname, { show_view }) => {
     return sf;
   });
 };
-const gcd = function (a, b) {
-  if (!b) {
-    return a;
-  }
-
-  return gcd(b, a % b);
-};
-
-let gcdArr = function (arr) {
-  let gcdres = gcd(arr[0], arr[1]);
-  for (let i = 2; i < arr.length; i++) {
-    gcdres = gcd(gcdres, arr[i]);
-  }
-  return gcdres;
-};
-
-function range(size, startAt = 0) {
-  return [...Array(size).keys()].map((i) => i + startAt);
-}
-
-const get_available_slots = async ({
-  table,
-  availability,
-  date,
-  entity_wanted,
-  reservable_entity_key,
-  services,
-  start_field,
-  duration_field,
-}) => {
-  const from = new Date(date);
-  from.setHours(0, 0, 0, 0);
-  const to = new Date(date);
-  to.setHours(23, 59, 59, 999);
-  const q = {};
-  q[start_field] = [{ gt: from }, { lt: to }];
-  if (reservable_entity_key && entity_wanted)
-    q[reservable_entity_key] = entity_wanted;
-  //console.log({ date, q });
-  const taken_slots = await table.getRows(q);
-
-  // figure out regular availability for this day
-  const dayOfWeek = [
-    "Sunday",
-    "Monday",
-    "Tuesday",
-    "Wednesday",
-    "Thursday",
-    "Friday",
-    "Saturday",
-  ][date.getDay()];
-  const relevant_availabilities = availability.filter(
-    ({ day }) =>
-      day === dayOfWeek ||
-      (day === "Mon-Fri" && !["Saturday", "Sunday"].includes(dayOfWeek))
-  );
-
-  const available_slots = [];
-  const durGCD = gcdArr(services.map((s) => s.duration));
-  relevant_availabilities.forEach(({ from, to }) => {
-    for (let i = (from * 60) / durGCD; i < (to * 60) / durGCD; i++) {
-      available_slots[i] = true;
-    }
-  });
-  //console.log({ taken_slots });
-  taken_slots.forEach((slot) => {
-    /*    console.log(
-      "taken slot",
-      slot,
-      slot[start_field].getHours(),
-      slot[start_field].getTimezoneOffset()
-    ); */
-    const from =
-      slot[start_field].getHours() * 60 + slot[start_field].getMinutes();
-    const to = from + slot[duration_field];
-    for (let i = from / durGCD; i < to / durGCD; i++) {
-      available_slots[i] = false;
-    }
-  });
-  return { available_slots, from, durGCD, taken_slots };
-};
 
 const run = async (
   table_id,
@@ -589,6 +510,9 @@ module.exports = {
     require("./available-feed"),
   ],
   actions: { validate_reservation: require("./validate") },
+  table_providers: {
+    "Reservation availabilites": require("./table-provider.js"),
+  },
 };
 
 /*

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@saltcorn/reservable",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Reservable resources",
   "main": "index.js",
   "dependencies": {
     "@saltcorn/markup": "^0.5.1",
-    "@saltcorn/data": "^0.5.1"
+    "@saltcorn/data": "^0.5.1",
+    "@saltcorn/plain-date": "0.2.5"
   },
   "author": "Tom Nielsen",
   "license": "MIT",

package/table-provider.js

@@ -0,0 +1,298 @@
+const { eval_expression } = require("@saltcorn/data/models/expression");
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+const FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
+const Field = require("@saltcorn/data/models/field");
+const Table = require("@saltcorn/data/models/table");
+const { getState } = require("@saltcorn/data/db/state");
+const { mkTable } = require("@saltcorn/markup");
+const { pre, code } = require("@saltcorn/markup/tags");
+const PlainDate = require("@saltcorn/plain-date");
+
+const { get_available_slots, range } = require("./common");
+
+const configuration_workflow = (req) =>
+  new Workflow({
+    steps: [
+      {
+        name: "table",
+        form: async () => {
+          const tables = await Table.find({});
+          return new Form({
+            fields: [
+              {
+                name: "table_name",
+                label: "Reservations Table",
+                type: "String",
+                required: true,
+                attributes: {
+                  options: tables.map((t) => t.name),
+                },
+                sublabel: "Select a table with reservations",
+              },
+            ],
+          });
+        },
+      },
+      {
+        name: "fields",
+        form: async (context) => {
+          const table = await Table.findOne({ name: context.table_name });
+          const fields = await table.getFields();
+
+          return new Form({
+            fields: [
+              {
+                name: "reservable_entity_key",
+                label: "Key to reservable entity",
+                type: "String",
+                attributes: {
+                  options: fields.filter((f) => f.is_fkey).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: "duration_field",
+                label: "Duration field",
+                sublabel: "Integer field holding booked duration in minutes",
+                type: "String",
+                required: true,
+                attributes: {
+                  options: fields
+                    .filter((f) => f.type.name === "Integer")
+                    .map((f) => f.name),
+                },
+              },
+            ],
+          });
+        },
+      },
+      {
+        name: "services",
+        form: async () => {
+          return new Form({
+            fields: [
+              new FieldRepeat({
+                name: "services",
+                fields: [
+                  {
+                    name: "title",
+                    label: "Title",
+                    sublabel: "Optional name of this service",
+                    type: "String",
+                  },
+                  {
+                    name: "duration",
+                    label: "Duration (minutes)",
+                    type: "Integer",
+                    attributes: {
+                      min: 0,
+                    },
+                  },
+                ],
+              }),
+            ],
+          });
+        },
+      },
+      {
+        name: "availability",
+        form: async () => {
+          return new Form({
+            fields: [
+              new FieldRepeat({
+                name: "availability",
+                fields: [
+                  {
+                    name: "day",
+                    label: "Day of week",
+                    type: "String",
+                    required: true,
+                    attributes: {
+                      options:
+                        "Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday,Mon-Fri",
+                    },
+                  },
+                  {
+                    name: "from",
+                    label: "Start hour",
+                    type: "Integer",
+                    required: true,
+                    attributes: {
+                      min: 0,
+                      max: 23,
+                    },
+                  },
+                  {
+                    name: "to",
+                    label: "End hour",
+                    type: "Integer",
+                    required: true,
+                    attributes: {
+                      min: 0,
+                      max: 24,
+                    },
+                  },
+                ],
+              }),
+            ],
+          });
+        },
+      },
+    ],
+  });
+
+module.exports = {
+  configuration_workflow,
+  fields: (cfg) => {
+    if (!cfg?.table_name) return [];
+
+    const table = Table.findOne({ name: cfg.table_name });
+    let entity_key;
+    if (cfg.reservable_entity_key) {
+      entity_key = table.getField(cfg.reservable_entity_key);
+    }
+    return [
+      {
+        name: "reserve_ident",
+        type: "String",
+        primary_key: true,
+        is_unique: true,
+      },
+      {
+        name: "start_day",
+        label: "Start day",
+        type: "Date",
+        attributes: { day_only: true },
+      },
+      {
+        name: "start_date",
+        label: "Start date",
+        type: "Date",
+      },
+      {
+        name: "start_hour",
+        label: "Start hour",
+        type: "Integer",
+        attributes: { min: 0, max: 23 },
+      },
+      {
+        name: "start_minute",
+        label: "Start mintute",
+        type: "Integer",
+        attributes: { min: 0, max: 59 },
+      },
+      {
+        name: "service",
+        label: "Service",
+        type: "String",
+        attributes: { options: cfg.services.map((s) => s.title) },
+      },
+      {
+        name: "service_duration",
+        label: "Duration",
+        type: "Integer",
+      },
+      ...(entity_key
+        ? [
+            {
+              name: "entity",
+              label: "Entity",
+              type: `Key to ${entity_key.reftable_name}`,
+              attributes: {
+                summary_field: entity_key.attributes.summary_field,
+              },
+            },
+          ]
+        : []),
+    ];
+  },
+  get_table: (cfg) => {
+    return {
+      disableFiltering: true,
+      getRows: async (where, opts) => {
+        const table = Table.findOne({ name: cfg.table_name });
+        const date = !where?.start_day
+          ? new Date()
+          : where?.start_day.constructor.name === "PlainDate"
+          ? where.start_day.toDate()
+          : new Date(where?.start_day);
+
+        const services = where?.service
+          ? cfg.services.filter((s) => s.title === where.service)
+          : cfg.services;
+        const { available_slots, from, durGCD, taken_slots } =
+          await get_available_slots({
+            table,
+            date,
+            availability: cfg.availability,
+            entity_wanted: where?.entity || undefined,
+            reservable_entity_key: cfg.reservable_entity_key,
+            start_field: cfg.start_field,
+            duration_field: cfg.duration_field,
+            services,
+          });
+        const minSlot = Math.min(...Object.keys(available_slots));
+        const maxSlot = Math.max(...Object.keys(available_slots));
+        const service_availabilities = services.map((service, serviceIx) => {
+          const nslots = service.duration / durGCD;
+          const availabilities = [];
+          for (let i = minSlot; i <= maxSlot; i++) {
+            const mins_since_midnight = i * durGCD;
+            const hour = Math.floor(mins_since_midnight / 60);
+
+            const minute = mins_since_midnight - hour * 60;
+            const date1 = new Date(date);
+            date1.setHours(hour);
+            date1.setMinutes(minute);
+            date1.setSeconds(0);
+            date1.setMilliseconds(0);
+            if (date1 > new Date())
+              if (range(nslots, i).every((j) => available_slots[j])) {
+                availabilities.push({
+                  date: date1,
+                  available: true,
+                });
+              } else {
+                availabilities.push({
+                  date: date1,
+                  available: false,
+                });
+              }
+          }
+          //console.log({ availabilities, service });
+          return { availabilities, service, serviceIx };
+        });
+
+        const rows = service_availabilities
+          .map(({ availabilities, service, serviceIx }) =>
+            availabilities
+              .filter((a) => a.available)
+              .map(({ date }) => {
+                return {
+                  reserve_ident: `${date.toISOString()}//${service.title}`,
+                  service: service.title,
+                  service_duration: service.duration,
+                  start_day: new PlainDate(date),
+                  start_date: date,
+                  start_hour: date.getHours(),
+                  start_minute: date.getMinutes(),
+                };
+              })
+          )
+          .flat();
+        return rows;
+      },
+    };
+  },
+};

package/validate.js

@@ -7,67 +7,147 @@ module.exports = {
       viewtemplate: "Available Resources Feed",
       table_id: table.id,
     });
-    return [
+    const tables = await Table.find(
       {
-        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),
-        },
+        provider_name: "Reservation availabilites",
       },
+      {
+        cached: true,
+      }
+    );
+    const neither = views.length === 0 && tables.length === 0;
+    //console.log({ views, tables, neither });
+
+    return [
+      ...(views.length || neither
+        ? [
+            {
+              name: "feedview",
+              label: "View",
+              sublabel: `A view on table ${table.name} with pattern: Available Resources Feed`,
+              type: "String",
+              attributes: {
+                options: views.map((f) => f.name),
+              },
+            },
+          ]
+        : []),
+      ...(tables.length || neither
+        ? [
+            {
+              name: "reserve_provided_table",
+              label: "Table",
+              sublabel: `A table with provider: Reservation availabilites`,
+              type: "String",
+              attributes: {
+                options: tables.map((f) => f.name),
+              },
+            },
+          ]
+        : []),
     ];
   },
   requireRow: true,
-  run: async ({ table, req, row, configuration: { feedview } }) => {
-    const view = View.findOne({ name: feedview });
+  run: async ({
+    table,
+    req,
+    row,
+    configuration: { feedview, reserve_provided_table },
+  }) => {
+    const get_config = () => {
+      if (feedview) {
+        const view = View.findOne({ name: feedview });
+        return view.configuration;
+      } else if (reserve_provided_table) {
+        const table = Table.findOne({ name: reserve_provided_table });
+        return table.provider_cfg;
+      }
+    };
     const {
       reservable_entity_key,
       valid_field,
       slot_count_field,
       slots_available_field,
-      show_view,
       start_field,
       end_field,
-    } = view.configuration;
+      duration_field,
+    } = get_config();
     //get all relevant reservations
 
-    const ress = await table.getRows({
-      [reservable_entity_key]:
-        row[reservable_entity_key]?.id || 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]?.id || 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
-      );
+    let entity;
+    if (reservable_entity_key) {
+      const refield = table.getField(reservable_entity_key);
+      const retable = Table.findOne(refield.reftable_name);
+      entity = await retable.getRow({
+        [retable.pk_name]:
+          row[reservable_entity_key]?.id || row[reservable_entity_key],
+      });
+    }
+    if (end_field) {
+      const q = valid_field ? { [valid_field]: true } : {};
+      if (end_field) {
+        q[start_field] = { lt: row[end_field], equal: true, day_only: true };
+        q[end_field] = { gt: row[start_field], equal: true, day_only: true };
+      } else {
+        q[start_field] = {
+          lt: row[start_field],
+          gt: row[start_field],
+          equal: true,
+          day_only: true,
+        };
+      }
+      if (reservable_entity_key)
+        q[reservable_entity_key] =
+          row[reservable_entity_key]?.id || row[reservable_entity_key];
+      //console.log("q", q);
+
+      const ress = await table.getRows(q);
+
+      //check that for every day, there is availablity
+      const from = new Date(row[start_field]);
+      const to = new Date(row[end_field]);
+      let maxAvailable =
+        slots_available_field && entity ? entity[slots_available_field] : 1;
+      // 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) => (slot_count_field ? r[slot_count_field] : 1))
+          .reduce((a, b) => a + b, 0);
+        maxAvailable = Math.min(
+          maxAvailable,
+          (slots_available_field && entity
+            ? entity[slots_available_field]
+            : 1) - taken
+        );
+      }
+      if (maxAvailable < (slot_count_field ? row[slot_count_field] : 1))
+        return maxAvailable === 1
+          ? { error: `Not available` }
+          : { error: `Only ${maxAvailable} are available` };
+    } else if (reserve_provided_table) {
+      const { get_table } = require("./table-provider");
+      const table = Table.findOne({ name: reserve_provided_table });
+      const ptable = get_table(table.provider_cfg);
+      const q = {};
+      if (entity) q.entity = entity.id; //todo pk_name
+      q.start_day = row[start_field];
+      const rows = await ptable.getRows(q);
+      const start_hr = new Date(row[start_field]).getHours()
+      const start_min = new Date(row[start_field]).getMinutes()
+      if (
+        !rows.find(
+          (r) =>
+            r.start_hour === start_hr &&
+            r.start_minute === start_min &&
+            r.service_duration >= row[duration_field]
+        )
+      )
+        return { error: `Not available` };
     }
-    if (maxAvailable < row[slot_count_field])
-      return { error: `Only ${maxAvailable} are available` };
   },
 };