btrz-liquid-templates 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Betterez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# btrz-liquid-templates
+Extension and helpers for liquid templates to deal with our data and other things we need to encapsulate

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "btrz-liquid-templates",
+  "version": "1.0.0",
+  "description": "Extension and helpers for liquid templates to deal with our data and other things we need to encapsulate",
+  "main": "src/index.js",
+  "scripts": {
+    "tdd": "mocha --recursive test/ -w",
+    "test": "mocha --recursive  test/",
+    "preversion": "npm test",
+    "postversion": "git push origin main && git push --tags",
+    "version": "git tag $1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Betterez/btrz-liquid-templates.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Betterez/btrz-liquid-templates/issues"
+  },
+  "homepage": "https://github.com/Betterez/btrz-liquid-templates#readme",
+  "dependencies": {
+    "axios": "^0.27.2",
+    "btrz-formatter": "1.3.0",
+    "bz-date": "1.3.0",
+    "liquidjs": "^10.9.2",
+    "moment": "^2.29.4",
+    "moment-timezone": "^0.5.43",
+    "symbology": "^4.0.1",
+    "written-number": "^0.11.1"
+  },
+  "devDependencies": {
+    "browserify": "^17.0.0",
+    "chai": "4.3.10",
+    "mocha": "10.2.0",
+    "tinyify": "4.0.0"
+  }
+}
+  

package/src/barcode.js

@@ -0,0 +1,57 @@
+const {SymbologyType, createStream, OutputType} = require("symbology");
+
+function getCode(code) {
+  return SymbologyType[code.toUpperCase()];
+}
+
+function Barcode(engine) {
+  this.registerTag("barcode", {
+    parse: function(tagToken, remainTokens) {
+      try {
+        const args = (tagToken.args || "").split(" ");
+        this.content = args[0] || "not-content-given";
+        this.type = args[1] || "code128";
+        this.height = args[2] || 30;
+        this.width = args[3] || 200;
+        this.margin = args[4] || "0,0,0,0";
+      } catch (err) {
+        this.content = "not-content-given";
+        this.type = "code128";
+        this.height = 30;
+        this.width = args[3] || 200;
+        this.margin = args[4] || "0,0,0,0";
+      }
+    },
+    render: async function(ctx) {
+      let content = await this.liquid.evalValue(this.content, ctx) || this.content;
+      let result = await createStream({
+        symbology: getCode(this.type),
+        height: this.height,
+        showHumanReadableText: false,
+        scale: 2.0,
+      }, String(content), OutputType.PNG);
+      let margin = [0,0,0,0];
+      try {
+        margin = this.margin.split(",").map((i) => {
+          return parseInt(i,10);
+        });
+        if (margin.length !== 4) {
+          margin = [0,0,0,0];
+        }
+      } catch (err) {
+        console.log("ERROR:", err);
+        margin = [0,0,0,0];
+      }
+      return `{
+        "image": "${result.data}",
+        "width": ${this.width || 200},
+        "margin": [${margin.join(",")}]
+      }`;
+    }
+});
+}
+
+module.exports = {
+  Barcode
+};
+

package/src/dateFormat.js

@@ -0,0 +1,560 @@
+const {timezones, BzDate} = require("bz-date");
+const formatter = require("btrz-formatter");
+const moment = require("moment");
+require("moment-timezone");
+function shortLang(lang) {
+  let result = "en";
+  if (lang && lang.substring) {
+    result = lang.substring(0, 2);
+  }
+  return result;
+}
+function getFriendlyFormat(humanDate) {
+  return (humanDate === "mm") ? "ddd mmm dd, yyyy" : "ddd dd mmm, yyyy"
+}
+
+function formatBzDate(bzDate, format, envs) {
+  const lang = shortLang(envs.lang);
+  const timeFormat = envs.providerPreferences.preferences.timeFormat;
+  const timeZone = envs.providerPreferences.preferences.timeZone;
+  const offset = timezones.getOffset(timeZone, bzDate);
+  const createdLocal = bzDate.addMinutes(offset);
+  return `${formatter.dateFormat(createdLocal.toString(`'yyyy-mm-dd' ${timeFormat}`), `${format}`, false, lang)}`;
+}
+
+function formatMoment(date, format, envs, applyTimeZone) {
+  const lang = shortLang(envs.lang);
+  const timeFormat = envs.providerPreferences.preferences.timeFormat;
+  const timeZone = envs.providerPreferences.preferences.timeZone;
+  const timeFormatCompatibleWithMomentJS = timeFormat.replace("TT", "A").replace(/M/g, "m");
+  let strDate = "";
+  if (applyTimeZone) {
+    strDate = moment(date).tz(timeZone.tz)
+      .format(`'YYYY-MM-DD' ${timeFormatCompatibleWithMomentJS}`);
+  } else {
+    strDate = moment(date)
+      .format(`'YYYY-MM-DD' ${timeFormatCompatibleWithMomentJS}`);
+  }
+  return `${formatter.dateFormat(strDate, `${format}`, false, lang)}`;
+}
+
+function formatBzDate2(bzDate, format, envs) {
+  const lang = shortLang(envs.lang);
+  const timeFormat = envs.providerPreferences.preferences.timeFormat;
+  return `${formatter.dateFormat(bzDate.toString(`'yyyy-mm-dd' ${timeFormat}`), `${format}`, false, lang)}`;
+}
+
+function getDate(envs, item, propName, format, applyTimeZone) {
+  let dateObjOrString = null;
+  if (item[propName]) {
+    dateObjOrString = item[propName];
+  } else {
+    dateObjOrString = envs[item][propName];
+  }
+  if (dateObjOrString && dateObjOrString.toUpperCase) {
+    return formatMoment(dateObjOrString, format, envs, applyTimeZone);
+  }
+  const date = new BzDate(dateObjOrString);
+  if (applyTimeZone == false) {
+    return formatBzDate2(date, format, envs);
+  }
+  return formatBzDate(date, format, envs);
+}
+
+function getTimeFromString(timeString, format) {
+  return formatter.timeFormat(timeString, format);
+};
+
+function HumanDateTime(engine) {
+  this.registerTag("humanDateTime", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.propName = args[1] || "createdAt";
+      this.applyTimeZone = true;
+      if (args.length > 2) {
+        this.applyTimeZone = args[2] === "true"
+      }
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item][this.propName]) {
+        const format = `${getFriendlyFormat(ctx.environments.humanDate || "mm")} ${ ctx.environments.providerPreferences.preferences.timeFormat}`;
+        return getDate(ctx.environments, this.item, this.propName, format, this.applyTimeZone);
+      }
+      return "PNA";
+    }
+  });
+}
+
+function HumanDate(engine) {
+  this.registerTag("humanDate", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.propName = args[1] || "createdAt";
+      this.applyTimeZone = true;
+      if (args.length > 2) {
+        this.applyTimeZone = args[2] === "true"
+      }
+    },
+    render: async function(ctx) {
+     
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item][this.propName]) {
+        const format = getFriendlyFormat(ctx.environments.humanDate || "mm");
+        return getDate(ctx.environments, this.item, this.propName, format, this.applyTimeZone);
+      }
+      return "PNA";
+    }
+  });
+}
+
+async function getNameOrValue(itemName, propName, ctx, liquid) {
+  if (ctx.environments[itemName]) {
+    if (!ctx.environments[itemName][propName]) {
+      return null;
+    }
+    return itemName;
+  }
+  const value = await liquid.evalValue(itemName, ctx);
+  if (!value || !value[propName]) {
+    return null;
+  }
+  return value;
+}
+
+function DateTime(engine) {
+  this.registerTag("dateTime", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.propName = args[1] || "createdAt";
+      if (args.length > 2) {
+        this.format = args.slice(2).join(" ") || "";
+      }
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences) {
+        const format = this.format || `${ctx.environments.providerPreferences.preferences.dateFormat} ${ctx.environments.providerPreferences.preferences.timeFormat}`;
+        const item = await getNameOrValue(this.item, this.propName, ctx, this.liquid);
+        if (item) {
+          return getDate(ctx.environments, item, this.propName, format);
+        }
+      }
+      return "PNA";
+    }
+  });
+}
+
+function DateF(engine) {
+  this.registerTag("dateF", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.propName = args[1] || "createdAt";
+      this.applyTimeZone = true;
+      if (args.length > 2) {
+        this.applyTimeZone = args[2] === "true"
+      }
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences) {
+        const format = ctx.environments.providerPreferences.preferences.dateFormat;
+        const item = await getNameOrValue(this.item, this.propName, ctx, this.liquid);
+        if (item) {
+          return getDate(ctx.environments, item, this.propName, format, this.applyTimeZone);
+        }
+      }
+      return "PNA";
+    }
+  });
+}
+
+function TimeF(engine) {
+  this.registerTag("timeF", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.propName = args[1] || "createdAt";
+      this.applyTimeZone = true;
+      if (args.length > 2) {
+        this.applyTimeZone = args[2] === "true"
+      }
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences) {
+        const format = ctx.environments.providerPreferences.preferences.timeFormat;
+        const item = await getNameOrValue(this.item, this.propName, ctx, this.liquid);
+        if (item) {
+          const dateObjOrString = item?.[this.propName] || ctx.environments[item]?.[this.propName];
+          // Keep this for compatibility with time format (HH:mm)
+          if (dateObjOrString.toUpperCase && dateObjOrString.indexOf("T") === -1) {
+            return getTimeFromString(dateObjOrString, format);
+          }
+          return getDate(ctx.environments, item, this.propName, format, this.applyTimeZone);
+        }
+      }
+      return "PNA";
+    }
+  });
+}
+
+function ExpDate(engine) {
+  this.registerTag("expDate", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      if (args.length > 1) {
+        this.format = args.slice(2).join(" ") || "";
+      }
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].expirationDate) {
+        const item = ctx.environments[this.item];
+        let expireDate = new BzDate(item.expirationDate);
+        if (item.departureTime) {
+          const timeParts = item.departureTime.split(":");
+          expireDate.addHours(timeParts[0]);
+          expireDate.addMinutes(timeParts[1]);
+        }
+        if (item.expire && item.expire > 0) {
+          if (item.expireUnit === "minutes") {
+            expireDate = expireDate.addMinutes(item.expire);
+          } else {
+            expireDate = expireDate.addDays(item.expire);
+          }
+        }
+        const format = this.format || `${ctx.environments.providerPreferences.preferences.dateFormat} ${ctx.environments.providerPreferences.preferences.timeFormat}`;
+        return formatBzDate2(expireDate, format, ctx.environments);
+      }
+      return "PNA";
+    }
+  });
+}
+
+function DepartureDateTime(engine) {
+  this.registerTag("departureDateTime", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].departureTimestamp && ctx.environments.fromStation) {
+        const dateFormat = ctx.environments.providerPreferences.preferences.dateFormat;
+        const timeFormat = ctx.environments.providerPreferences.preferences.timeFormat;
+        const originStationTimezone = ctx.environments.fromStation.timeZone
+        if (originStationTimezone) {
+          const lang = shortLang(ctx.environments.lang);
+          const date = moment(ctx.environments[this.item].departureTimestamp).tz(originStationTimezone).format("YYYY-MM-DD");
+          const time = moment(ctx.environments[this.item].departureTimestamp).tz(originStationTimezone).format("HH:mm");
+          const formattedDate = formatter.dateFormat(date, dateFormat, true, lang);
+          const formattedTime = formatter.timeFormat(time, timeFormat);
+
+          return `${formattedDate} ${formattedTime}`;
+        } else {
+          // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+          // For reservations, this logic may produce an incorrect / misleading date and time.
+          const format = `${dateFormat} ${timeFormat}`;
+          return getDate(ctx.environments, this.item, "departureTimestamp", format, this.applyTimeZone);
+        }
+        
+      }
+      return "PNA";
+    }
+  });
+}
+
+function ArrivalDateTime(engine) {
+  this.registerTag("arrivalDateTime", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].arrivalTimestamp && ctx.environments.toStation) {
+        const lang = shortLang(ctx.environments.lang);
+        const dateFormat = ctx.environments.providerPreferences.preferences.dateFormat;
+        const timeFormat = ctx.environments.providerPreferences.preferences.timeFormat;
+        const originStationTimezone = ctx.environments.toStation.timeZone
+        if (originStationTimezone) {
+          const date = moment(ctx.environments[this.item].arrivalTimestamp).tz(originStationTimezone).format("YYYY-MM-DD");
+          const time = moment(ctx.environments[this.item].arrivalTimestamp).tz(originStationTimezone).format("HH:mm");
+          const formattedDate = formatter.dateFormat(date, dateFormat, true, lang);
+          const formattedTime = formatter.timeFormat(time, timeFormat);
+
+          return `${formattedDate} ${formattedTime}`;
+        } else {
+          // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+          // For reservations, this logic may produce an incorrect / misleading date and time.
+          const format = `${dateFormat} ${timeFormat}`;
+          return getDate(ctx.environments, this.item, "arrivalTimestamp", format, this.applyTimeZone);
+        }
+        
+      }
+      return "PNA";
+    }
+  });
+}
+
+function DepartureDate(engine) {
+  this.registerTag("departureDate", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].departureTimestamp && ctx.environments.fromStation) {
+        const dateFormat = ctx.environments.providerPreferences.preferences.dateFormat;
+        const originStationTimezone = ctx.environments.fromStation.timeZone
+        if (originStationTimezone) {
+          const lang = shortLang(ctx.environments.lang);
+          const date = moment(ctx.environments[this.item].departureTimestamp).tz(originStationTimezone).format("YYYY-MM-DD");
+          const formattedDate = formatter.dateFormat(date, dateFormat, true, lang);
+
+          return `${formattedDate}`;
+        } else {
+          // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+          // For reservations, this logic may produce an incorrect / misleading date and time.
+          const format = `${dateFormat}`;
+          return getDate(ctx.environments, this.item, "departureTimestamp", format, this.applyTimeZone);
+        }
+        
+      }
+      return "PNA";
+    }
+  });
+}
+
+function ArrivalDate(engine) {
+  this.registerTag("arrivalDate", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].arrivalTimestamp && ctx.environments.toStation) {
+        const lang = shortLang(ctx.environments.lang);
+        const dateFormat = ctx.environments.providerPreferences.preferences.dateFormat;
+        const originStationTimezone = ctx.environments.toStation.timeZone
+        if (originStationTimezone) {
+          const date = moment(ctx.environments[this.item].arrivalTimestamp).tz(originStationTimezone).format("YYYY-MM-DD");
+          const formattedDate = formatter.dateFormat(date, dateFormat, true, lang);
+
+          return `${formattedDate}`;
+        } else {
+          // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+          // For reservations, this logic may produce an incorrect / misleading date and time.
+          const format = `${dateFormat}`;
+          return getDate(ctx.environments, this.item, "arrivalTimestamp", format, this.applyTimeZone);
+        }
+        
+      }
+      return "PNA";
+    }
+  });
+}
+
+function DepartureTime(engine) {
+  this.registerTag("departureTime", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].departureTimestamp && ctx.environments.fromStation) {
+        const timeFormat = ctx.environments.providerPreferences.preferences.timeFormat;
+        const originStationTimezone = ctx.environments.fromStation.timeZone
+        if (originStationTimezone) {
+          const lang = shortLang(ctx.environments.lang);
+          const time = moment(ctx.environments[this.item].departureTimestamp).tz(originStationTimezone).format("HH:mm");
+          const formattedTime = formatter.timeFormat(time, timeFormat);
+
+          return `${formattedTime}`;
+        } else {
+          // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+          // For reservations, this logic may produce an incorrect / misleading date and time.
+          const format = `${timeFormat}`;
+          return getDate(ctx.environments, this.item, "departureTimestamp", format, this.applyTimeZone);
+        }
+        
+      }
+      return "PNA";
+    }
+  });
+}
+
+function ArrivalTime(engine) {
+  this.registerTag("arrivalTime", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].arrivalTimestamp && ctx.environments.toStation) {
+        const lang = shortLang(ctx.environments.lang);
+        const timeFormat = ctx.environments.providerPreferences.preferences.timeFormat;
+        const originStationTimezone = ctx.environments.toStation.timeZone
+        if (originStationTimezone) {
+          const time = moment(ctx.environments[this.item].arrivalTimestamp).tz(originStationTimezone).format("HH:mm");
+          const formattedTime = formatter.timeFormat(time, timeFormat);
+
+          return `${formattedTime}`;
+        } else {
+          // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+          // For reservations, this logic may produce an incorrect / misleading date and time.
+          const format = `${timeFormat}`;
+          return getDate(ctx.environments, this.item, "arrivalTimestamp", format, this.applyTimeZone);
+        }
+        
+      }
+      return "PNA";
+    }
+  });
+}
+
+function HumanDepartureDateTime(engine) {
+  this.registerTag("humanDepartureDateTime", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].departureTimestamp && ctx.environments.fromStation) {
+        const timeFormat = ctx.environments.providerPreferences.preferences.timeFormat;
+        const format = `${getFriendlyFormat(ctx.environments.humanDate || "mm")} ${timeFormat}`;
+        const originStationTimezone = ctx.environments.fromStation.timeZone
+        if (originStationTimezone) {
+          const lang = shortLang(ctx.environments.lang);
+          const dateTime = moment(ctx.environments[this.item].departureTimestamp).tz(originStationTimezone).format(`YYYY-MM-DD ${timeFormat.replace("TT", "A").replace(/M/g, "m")}`);
+          return `${formatter.dateFormat(dateTime, `${format}`, false, lang)}`;
+        } else {
+          // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+          // For reservations, this logic may produce an incorrect / misleading date and time.
+          return getDate(ctx.environments, this.item, "departureTimestamp", format, this.applyTimeZone);
+        } 
+      }
+      return "PNA";
+    }
+  });
+}
+
+function HumanArrivalDateTime(engine) {
+  this.registerTag("humanArrivalDateTime", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].arrivalTimestamp && ctx.environments.toStation) {
+          const timeFormat = ctx.environments.providerPreferences.preferences.timeFormat;
+          const format = `${getFriendlyFormat(ctx.environments.humanDate || "mm")} ${timeFormat}`;
+          const originStationTimezone = ctx.environments.toStation.timeZone
+          if (originStationTimezone) {
+            const lang = shortLang(ctx.environments.lang);
+            const dateTime = moment(ctx.environments[this.item].arrivalTimestamp).tz(originStationTimezone).format(`YYYY-MM-DD ${timeFormat.replace("TT", "A").replace(/M/g, "m")}`);
+            return `${formatter.dateFormat(dateTime, `${format}`, false, lang)}`;
+          } else {
+            // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+            // For reservations, this logic may produce an incorrect / misleading date and time.
+            return getDate(ctx.environments, this.item, "arrivalTimestamp", format, this.applyTimeZone);
+          } 
+      }
+      return "PNA";
+    }
+  });
+}
+
+function HumanDepartureDate(engine) {
+  this.registerTag("humanDepartureDate", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].departureTimestamp && ctx.environments.fromStation) {
+        const timeFormat = ctx.environments.providerPreferences.preferences.timeFormat;
+        const format = getFriendlyFormat(ctx.environments.humanDate || "mm");
+        const originStationTimezone = ctx.environments.fromStation.timeZone
+        if (originStationTimezone) {
+          const lang = shortLang(ctx.environments.lang);
+          const dateTime = moment(ctx.environments[this.item].departureTimestamp).tz(originStationTimezone).format(`YYYY-MM-DD ${timeFormat.replace("TT", "A").replace(/M/g, "m")}`);
+          return `${formatter.dateFormat(dateTime, `${format}`, false, lang)}`;
+        } else {
+          // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+          // For reservations, this logic may produce an incorrect / misleading date and time.
+          return getDate(ctx.environments, this.item, "departureTimestamp", format, this.applyTimeZone);
+        } 
+      }
+      return "PNA";
+    }
+  });
+}
+
+function HumanArrivalDate(engine) {
+  this.registerTag("humanArrivalDate", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket";
+      this.applyTimeZone = true;
+    },
+    render: async function(ctx) {
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        ctx.environments[this.item] && ctx.environments[this.item].arrivalTimestamp && ctx.environments.toStation) {
+          const timeFormat = ctx.environments.providerPreferences.preferences.timeFormat;
+          const format = getFriendlyFormat(ctx.environments.humanDate || "mm");
+          const originStationTimezone = ctx.environments.toStation.timeZone
+          if (originStationTimezone) {
+            const lang = shortLang(ctx.environments.lang);
+            const dateTime = moment(ctx.environments[this.item].arrivalTimestamp).tz(originStationTimezone).format(`YYYY-MM-DD ${timeFormat.replace("TT", "A").replace(/M/g, "m")}`);
+            return `${formatter.dateFormat(dateTime, `${format}`, false, lang)}`;
+          } else {
+            // Legacy logic which does not consider that the timezone of the origin station may differ from the account's timezone.
+            // For reservations, this logic may produce an incorrect / misleading date and time.
+            return getDate(ctx.environments, this.item, "arrivalTimestamp", format, this.applyTimeZone);
+          } 
+      }
+      return "PNA";
+    }
+  });
+}
+
+
+module.exports = {
+  DateF,
+  DateTime,
+  ExpDate,
+  HumanDate,
+  HumanDateTime,
+  HumanDepartureDate,
+  HumanArrivalDate,
+  HumanDepartureDateTime,
+  HumanArrivalDateTime,
+  DepartureDateTime,
+  ArrivalDateTime,
+  DepartureDate,
+  ArrivalDate,
+  DepartureTime,
+  ArrivalTime,
+  TimeF
+};
+