@fincity/kirun-js 2.5.0 → 2.8.2

package/src/engine/function/system/date/FromNow.ts

@@ -0,0 +1,77 @@
+import { DateTime } from 'luxon';
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+
+export class FromNow extends AbstractDateFunction {
+    public static readonly PARAMETER_FROM_NAME = 'from';
+    public static readonly PARAMETER_FROM = new Parameter(
+        FromNow.PARAMETER_FROM_NAME,
+        Schema.ofRef(Namespaces.DATE + '.Timestamp').setDefaultValue(''),
+    );
+    public static readonly PARAMETER_LOCALE_NAME = 'locale';
+    public static readonly PARAMETER_LOCALE = new Parameter(
+        FromNow.PARAMETER_LOCALE_NAME,
+        Schema.ofString(FromNow.PARAMETER_LOCALE_NAME).setDefaultValue('system'),
+    );
+
+    public static readonly PARAMETER_FORMAT_NAME = 'format';
+    public static readonly PARAMETER_FORMAT = new Parameter(
+        FromNow.PARAMETER_FORMAT_NAME,
+        Schema.ofString(FromNow.PARAMETER_FORMAT_NAME)
+            .setEnums(['LONG', 'SHORT', 'NARROW'])
+            .setDefaultValue('LONG'),
+    );
+
+    public static readonly PARAMETER_ROUND_NAME = 'round';
+    public static readonly PARAMETER_ROUND = new Parameter(
+        FromNow.PARAMETER_ROUND_NAME,
+        Schema.ofBoolean(FromNow.PARAMETER_ROUND_NAME).setDefaultValue(true),
+    );
+
+    public constructor() {
+        super(
+            'FromNow',
+            AbstractDateFunction.EVENT_STRING,
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+            FromNow.PARAMETER_FORMAT,
+            FromNow.PARAMETER_FROM,
+            AbstractDateFunction.PARAMETER_VARIABLE_UNIT,
+            FromNow.PARAMETER_ROUND,
+            FromNow.PARAMETER_LOCALE,
+        );
+    }
+
+    public internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const from1 = context.getArguments()?.get(FromNow.PARAMETER_FROM_NAME);
+        const fromDate = from1 === '' ? DateTime.now() : DateTime.fromISO(from1);
+        const given = context.getArguments()?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+        const givenDate = DateTime.fromISO(given);
+
+        const units = context.getArguments()?.get(FromNow.PARAMETER_UNIT_NAME);
+        const format = context.getArguments()?.get(FromNow.PARAMETER_FORMAT_NAME);
+        const round = context.getArguments()?.get(FromNow.PARAMETER_ROUND_NAME);
+        const locale = context.getArguments()?.get(FromNow.PARAMETER_LOCALE_NAME);
+
+        const options: any = { base: fromDate, style: format?.toLowerCase(), round, locale };
+        if (units?.length > 0) {
+            options.unit = units.map((e: string) => e.toLowerCase());
+        }
+
+        return Promise.resolve(
+            new FunctionOutput([
+                EventResult.outputOf(
+                    MapUtil.of(
+                        AbstractDateFunction.EVENT_RESULT_NAME,
+                        givenDate.toRelative(options) ?? 'Unknown',
+                    ),
+                ),
+            ]),
+        );
+    }
+}

package/src/engine/function/system/date/GetCurrent.ts

@@ -0,0 +1,20 @@
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { MapUtil } from '../../../util/MapUtil';
+import { DateTime } from 'luxon';
+
+export class GetCurrentTimestamp extends AbstractDateFunction {
+    public constructor() {
+        super('GetCurrentTimestamp', AbstractDateFunction.EVENT_TIMESTAMP);
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(AbstractDateFunction.EVENT_TIMESTAMP_NAME, DateTime.now().toISO()),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/GetNames.ts

@@ -0,0 +1,74 @@
+import { Parameter } from '../../../model/Parameter';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { Event } from '../../../model/Event';
+import { Schema } from '../../../json/schema/Schema';
+import { MapUtil } from '../../../util/MapUtil';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { DateTime } from 'luxon';
+import { EventResult } from '../../../model/EventResult';
+
+export class GetNames extends AbstractDateFunction {
+    public static readonly EVENT_NAMES_NAME = 'names';
+    public static readonly PARAMETER_UNIT_NAME = 'unit';
+    public static readonly PARAMETER_LOCALE_NAME = 'locale';
+
+    constructor() {
+        super(
+            'GetNames',
+            new Event(
+                GetNames.EVENT_NAMES_NAME,
+                MapUtil.of(
+                    GetNames.EVENT_NAMES_NAME,
+                    Schema.ofArray(
+                        GetNames.EVENT_NAMES_NAME,
+                        Schema.ofString(GetNames.EVENT_NAMES_NAME),
+                    ),
+                ),
+            ),
+            new Parameter(
+                GetNames.PARAMETER_UNIT_NAME,
+                Schema.ofString(GetNames.PARAMETER_UNIT_NAME).setEnums([
+                    'TIMEZONES',
+                    'MONTHS',
+                    'WEEKDAYS',
+                ]),
+            ),
+            new Parameter(
+                GetNames.PARAMETER_LOCALE_NAME,
+                Schema.ofString(GetNames.PARAMETER_LOCALE_NAME).setDefaultValue('system'),
+            ),
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const unit = context.getArguments()?.get(GetNames.PARAMETER_UNIT_NAME);
+        const locale = context.getArguments()?.get(GetNames.PARAMETER_LOCALE_NAME);
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(GetNames.EVENT_NAMES_NAME, this.getNames(unit, locale)),
+            ),
+        ]);
+    }
+
+    private getNames(unit: string, locale: string): string[] {
+        if (unit === 'TIMEZONES') {
+            return Intl.supportedValuesOf('timeZone');
+        }
+
+        if (unit === 'MONTHS') {
+            return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].map((month) =>
+                DateTime.now().setLocale(locale).set({ month }).toFormat('MMMM'),
+            );
+        }
+
+        if (unit === 'WEEKDAYS') {
+            return [1, 2, 3, 4, 5, 6, 7].map((day) =>
+                DateTime.now().setLocale(locale).set({ month: 7, day }).toFormat('EEEE'),
+            );
+        }
+
+        return [];
+    }
+}

package/src/engine/function/system/date/IsBetween.ts

@@ -0,0 +1,62 @@
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+
+export class IsBetween extends AbstractDateFunction {
+    public static readonly PARAMETER_START_TIMESTAMP_NAME = 'startTimestamp';
+    public static readonly PARAMETER_END_TIMESTAMP_NAME = 'endTimestamp';
+
+    public static readonly PARAMETER_CHECK_TIMESTAMP_NAME = 'checkTimestamp';
+
+    constructor() {
+        super(
+            'IsBetween',
+            IsBetween.EVENT_BOOLEAN,
+            Parameter.of(
+                IsBetween.PARAMETER_START_TIMESTAMP_NAME,
+                Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+            ),
+            Parameter.of(
+                IsBetween.PARAMETER_END_TIMESTAMP_NAME,
+                Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+            ),
+            Parameter.of(
+                IsBetween.PARAMETER_CHECK_TIMESTAMP_NAME,
+                Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+            ),
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const startTimestamp = context
+            .getArguments()
+            ?.get(IsBetween.PARAMETER_START_TIMESTAMP_NAME);
+        const endTimestamp = context.getArguments()?.get(IsBetween.PARAMETER_END_TIMESTAMP_NAME);
+        const checkTimestamp = context
+            .getArguments()
+            ?.get(IsBetween.PARAMETER_CHECK_TIMESTAMP_NAME);
+
+        let startDateTime = getDateTime(startTimestamp);
+        let endDateTime = getDateTime(endTimestamp);
+        const checkDateTime = getDateTime(checkTimestamp);
+
+        if (startDateTime > endDateTime) {
+            [startDateTime, endDateTime] = [endDateTime, startDateTime];
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(
+                    IsBetween.EVENT_RESULT_NAME,
+                    startDateTime <= checkDateTime && checkDateTime <= endDateTime,
+                ),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/IsValidISODate.ts

@@ -1,43 +1,57 @@
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { Schema } from "../../../json/schema/Schema";
+import { Schema } from '../../../json/schema/Schema';
 import { Event } from '../../../model/Event';
-import { EventResult } from "../../../model/EventResult";
-import { FunctionOutput } from "../../../model/FunctionOutput";
-import { FunctionSignature } from "../../../model/FunctionSignature";
-import { Parameter } from "../../../model/Parameter";
-import { Namespaces } from "../../../namespaces/Namespaces";
-import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
-import { MapUtil } from "../../../util/MapUtil";
-import { isNullValue } from "../../../util/NullCheck";
-import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { AbstractFunction } from "../../AbstractFunction";
-
-
-const VALUE : string = "isoDate";
-
-const OUTPUT : string = "output";
-
-const SIGNATURE = new FunctionSignature('IsValidISODate')
-.setNamespace(Namespaces.DATE)
-.setParameters(MapUtil.of(VALUE, Parameter.of(VALUE, Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
-.setEvents(MapUtil.of(OUTPUT , new Event(OUTPUT , MapUtil.of(OUTPUT, Schema.ofBoolean(OUTPUT)))));
-
-export class IsValidISODate extends AbstractFunction{
-
-    public getSignature(): FunctionSignature {
-        return SIGNATURE;
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { DateTime } from 'luxon';
+
+export class IsValidISODate extends AbstractFunction {
+    private static readonly SIGNATURE = new FunctionSignature('IsValidISODate')
+        .setNamespace(Namespaces.DATE)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(
+                    AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                    Schema.ofString(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                ),
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.outputEventMapEntry(
+                    MapUtil.of(
+                        AbstractDateFunction.EVENT_RESULT_NAME,
+                        Schema.ofBoolean(AbstractDateFunction.EVENT_RESULT_NAME),
+                    ),
+                ),
+            ]),
+        );
+
+    protected internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dt = DateTime.fromISO(timestamp);
+
+        return Promise.resolve(
+            new FunctionOutput([
+                EventResult.outputOf(
+                    MapUtil.of(
+                        AbstractDateFunction.EVENT_RESULT_NAME,
+                        dt.isValid,
+                    ),
+                ),
+            ]),
+        );
     }
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-        
-        var date = context.getArguments()?.get(VALUE);
-
-        if(isNullValue(date))
-            throw new KIRuntimeException("Please provide a valid date object");
-
-        return new FunctionOutput([ EventResult.of(OUTPUT , MapUtil.of( OUTPUT , ValidDateTimeUtil.validate(date)))]);
-        
+    public getSignature(): FunctionSignature {
+        return IsValidISODate.SIGNATURE;
     }
-    
-
-}
+}

package/src/engine/function/system/date/LastFirstOf.ts

@@ -0,0 +1,72 @@
+import { DateTime } from 'luxon';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { Parameter } from '../../../model/Parameter';
+import { Schema } from '../../../json/schema/Schema';
+import { getDateTime } from './common';
+
+export class LastFirstOf extends AbstractFunction {
+    private readonly signature: FunctionSignature;
+    private readonly isLast: boolean;
+
+    constructor(isLast: boolean) {
+        super();
+
+        this.isLast = isLast;
+        this.signature = new FunctionSignature(isLast ? 'LastOf' : 'FirstOf')
+            .setNamespace(Namespaces.DATE)
+            .setParameters(
+                new Map([
+                    [
+                        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                        new Parameter(
+                            AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                            Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+                        ).setVariableArgument(true),
+                    ],
+                ]),
+            )
+            .setEvents(
+                new Map([
+                    [
+                        AbstractDateFunction.EVENT_TIMESTAMP_NAME,
+                        AbstractDateFunction.EVENT_TIMESTAMP,
+                    ],
+                ]),
+            );
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamps = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        if (!timestamps?.length) {
+            throw new Error('No timestamps provided');
+        }
+
+        const dateTimes: DateTime[] = timestamps.map((ts: string) => getDateTime(ts));
+        dateTimes.sort((a, b) => a.toMillis() - b.toMillis());
+
+        return Promise.resolve(
+            new FunctionOutput([
+                EventResult.outputOf(
+                    MapUtil.of(
+                        AbstractDateFunction.EVENT_TIMESTAMP_NAME,
+                        dateTimes[this.isLast ? dateTimes.length - 1 : 0].toISO(),
+                    ),
+                ),
+            ]),
+        );
+    }
+}

package/src/engine/function/system/date/SetTimeZone.ts

@@ -0,0 +1,43 @@
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+
+export class SetTimeZone extends AbstractDateFunction {
+    public static readonly PARAMETER_TIMEZONE_NAME: string = 'timezone';
+
+    constructor() {
+        super(
+            'SetTimeZone',
+            AbstractDateFunction.EVENT_TIMESTAMP,
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+            Parameter.of(
+                SetTimeZone.PARAMETER_TIMEZONE_NAME,
+                Schema.ofString(SetTimeZone.PARAMETER_TIMEZONE_NAME),
+            ),
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp);
+
+        const timeZone = context.getArguments()?.get(SetTimeZone.PARAMETER_TIMEZONE_NAME);
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(
+                    AbstractDateFunction.EVENT_RESULT_NAME,
+                    dateTime.setZone(timeZone).toISO()!,
+                ),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/StartEndOf.ts

@@ -0,0 +1,44 @@
+import { DurationLikeObject } from 'luxon';
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+
+export class StartEndOf extends AbstractDateFunction {
+    private readonly isStart: boolean;
+
+    constructor(isStart: boolean) {
+        super(
+            isStart ? 'StartOf' : 'EndOf',
+            AbstractDateFunction.EVENT_TIMESTAMP,
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+            AbstractDateFunction.PARAMETER_UNIT,
+        );
+
+        this.isStart = isStart;
+    }
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp);
+
+        const unit = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_UNIT_NAME)
+            ?.toLowerCase();
+
+        const newDateTime = this.isStart ? dateTime.startOf(unit) : dateTime.endOf(unit);
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(AbstractDateFunction.EVENT_TIMESTAMP_NAME, newDateTime.toISO()),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/TimeAs.ts

@@ -0,0 +1,64 @@
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+import { Schema } from '../../../json/schema/Schema';
+
+export class TimeAs extends AbstractDateFunction {
+    public static readonly EVENT_TIME_OBJECT_NAME = 'object';
+    public static readonly EVENT_TIME_ARRAY_NAME = 'array';
+
+    private readonly isArray: boolean;
+
+    constructor(isArray: boolean) {
+        super(
+            isArray ? 'TimeAsArray' : 'TimeAsObject',
+            new Event(
+                Event.OUTPUT,
+                MapUtil.of(
+                    isArray ? TimeAs.EVENT_TIME_ARRAY_NAME : TimeAs.EVENT_TIME_OBJECT_NAME,
+                    isArray
+                        ? Schema.ofArray(
+                              TimeAs.EVENT_TIME_ARRAY_NAME,
+                              Schema.ofInteger('timeParts'),
+                          )
+                        : Schema.ofRef(Namespaces.DATE + '.TimeObject'),
+                ),
+            ),
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+        );
+
+        this.isArray = isArray;
+    }
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp).toObject();
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(
+                    this.isArray ? TimeAs.EVENT_TIME_ARRAY_NAME : TimeAs.EVENT_TIME_OBJECT_NAME,
+                    this.isArray
+                        ? [
+                              dateTime.year,
+                              dateTime.month,
+                              dateTime.day,
+                              dateTime.hour,
+                              dateTime.minute,
+                              dateTime.second,
+                              dateTime.millisecond,
+                          ]
+                        : dateTime,
+                ),
+            ),
+        ]);
+    }
+}

package/src/engine/function/system/date/TimestampToEpoch.ts

@@ -0,0 +1,54 @@
+import { DateTime } from 'luxon';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+import { AbstractDateFunction } from './AbstractDateFunction';
+
+export class TimestampToEpoch extends AbstractFunction {
+    private readonly signature: FunctionSignature;
+    private readonly isSeconds: boolean;
+
+    constructor(name: string, isSeconds: boolean) {
+        super();
+
+        this.isSeconds = isSeconds;
+        this.signature = new FunctionSignature(name)
+            .setNamespace(Namespaces.DATE)
+            .setParameters(
+                new Map([
+                    [
+                        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+                        AbstractDateFunction.PARAMETER_TIMESTAMP,
+                    ],
+                ]),
+            )
+            .setEvents(
+                new Map([
+                    [AbstractDateFunction.EVENT_RESULT_NAME, AbstractDateFunction.EVENT_LONG],
+                ]),
+            );
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+        const epoch = this.isSeconds
+            ? DateTime.fromISO(timestamp).toSeconds()
+            : DateTime.fromISO(timestamp).toMillis();
+
+        return Promise.resolve(
+            new FunctionOutput([
+                EventResult.outputOf(MapUtil.of(AbstractDateFunction.EVENT_RESULT_NAME, epoch)),
+            ]),
+        );
+    }
+}

package/src/engine/function/system/date/ToDateString.ts

@@ -0,0 +1,49 @@
+import { Schema } from '../../../json/schema/Schema';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { Parameter } from '../../../model/Parameter';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractDateFunction } from './AbstractDateFunction';
+import { getDateTime } from './common';
+
+export class ToDateString extends AbstractDateFunction {
+    public static readonly PARAMETER_FORMAT_NAME = 'format';
+    public static readonly PARAMETER_LOCALE_NAME = 'locale';
+
+    constructor() {
+        super(
+            'ToDateString',
+            AbstractDateFunction.EVENT_STRING,
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+            Parameter.of(
+                ToDateString.PARAMETER_FORMAT_NAME,
+                Schema.ofString(ToDateString.PARAMETER_FORMAT_NAME),
+            ),
+            Parameter.of(
+                ToDateString.PARAMETER_LOCALE_NAME,
+                Schema.ofString(ToDateString.PARAMETER_LOCALE_NAME).setDefaultValue(''),
+            ),
+        );
+    }
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp);
+
+        const format = context.getArguments()?.get(ToDateString.PARAMETER_FORMAT_NAME);
+        let locale = context.getArguments()?.get(ToDateString.PARAMETER_LOCALE_NAME);
+        if (locale === '') locale = 'system';
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(
+                    AbstractDateFunction.EVENT_RESULT_NAME,
+                    dateTime.toFormat(format, { locale }),
+                ),
+            ),
+        ]);
+    }
+}