@fincity/kirun-js 2.7.0 → 2.8.2

package/src/engine/function/system/array/IndexOf.ts

@@ -2,7 +2,6 @@ import { KIRuntimeException } from '../../../exception/KIRuntimeException';
 import { EventResult } from '../../../model/EventResult';
 import { FunctionOutput } from '../../../model/FunctionOutput';
 import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
-import { isNullValue } from '../../../util/NullCheck';
 import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
 import { AbstractArrayFunction } from './AbstractArrayFunction';
 
@@ -12,7 +11,7 @@ export class IndexOf extends AbstractArrayFunction {
             'IndexOf',
             [
                 IndexOf.PARAMETER_ARRAY_SOURCE,
-                IndexOf.PARAMETER_ANY_NOT_NULL,
+                IndexOf.PARAMETER_ANY_ELEMENT_OBJECT,
                 IndexOf.PARAMETER_INT_FIND_FROM,
             ],
             IndexOf.EVENT_RESULT_INTEGER,
@@ -24,7 +23,9 @@ export class IndexOf extends AbstractArrayFunction {
             ?.getArguments()
             ?.get(IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName());
 
-        var find = context?.getArguments()?.get(IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName());
+        let find = context
+            ?.getArguments()
+            ?.get(IndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName());
 
         let len: number = context
             ?.getArguments()
@@ -34,7 +35,6 @@ export class IndexOf extends AbstractArrayFunction {
             return new FunctionOutput([
                 EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_NAME, -1]])),
             ]);
-
         if (len < 0 || len > source.length)
             throw new KIRuntimeException(
                 'The size of the search index of the array is greater than the size of the array',

package/src/engine/function/system/array/LastIndexOf.ts

@@ -11,7 +11,7 @@ export class LastIndexOf extends AbstractArrayFunction {
             'LastIndexOf',
             [
                 LastIndexOf.PARAMETER_ARRAY_SOURCE,
-                LastIndexOf.PARAMETER_ANY_NOT_NULL,
+                LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT,
                 LastIndexOf.PARAMETER_INT_FIND_FROM,
             ],
             LastIndexOf.EVENT_RESULT_INTEGER,
@@ -23,9 +23,9 @@ export class LastIndexOf extends AbstractArrayFunction {
             ?.getArguments()
             ?.get(LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName());
 
-        var find = context
+        let find = context
             ?.getArguments()
-            ?.get(LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName());
+            ?.get(LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName());
 
         let len = context
             ?.getArguments()

package/src/engine/function/system/array/Rotate.ts

@@ -8,7 +8,7 @@ export class Rotate extends AbstractArrayFunction {
         super(
             'Rotate',
             [Rotate.PARAMETER_ARRAY_SOURCE, Rotate.PARAMETER_ROTATE_LENGTH],
-            Rotate.EVENT_RESULT_ANY,
+            Rotate.EVENT_RESULT_ARRAY,
         );
     }
 

package/src/engine/function/system/array/Shuffle.ts

@@ -5,7 +5,7 @@ import { AbstractArrayFunction } from './AbstractArrayFunction';
 
 export class Shuffle extends AbstractArrayFunction {
     public constructor() {
-        super('Shuffle', [Shuffle.PARAMETER_ARRAY_SOURCE], Shuffle.EVENT_RESULT_ANY);
+        super('Shuffle', [Shuffle.PARAMETER_ARRAY_SOURCE], Shuffle.EVENT_RESULT_ARRAY);
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/array/Sort.ts

@@ -17,7 +17,7 @@ export class Sort extends AbstractArrayFunction {
                 Sort.PARAMETER_BOOLEAN_ASCENDING,
                 Sort.PARAMETER_KEY_PATH,
             ],
-            Sort.EVENT_RESULT_ANY,
+            Sort.EVENT_RESULT_ARRAY,
         );
     }
 

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

@@ -1,54 +1,61 @@
-import { Schema } from "../../../json/schema/Schema";
-import { FunctionSignature } from "../../../model/FunctionSignature";
-import { Event } from "../../../model/Event";
-import { Parameter } from "../../../model/Parameter";
-import { Namespaces } from "../../../namespaces/Namespaces";
-import { MapUtil } from "../../../util/MapUtil";
-import { AbstractFunction } from "../../AbstractFunction";
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { EventResult } from "../../../model/EventResult";
-import { FunctionOutput } from "../../../model/FunctionOutput";
-import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
-import { isNullValue } from "../../../util/NullCheck";
-import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { Function } from "../../../../engine/function/Function";
+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 { AbstractFunction } from '../../AbstractFunction';
+import { Function } from '../../Function';
 
 export abstract class AbstractDateFunction extends AbstractFunction {
+    private readonly signature: FunctionSignature;
 
-    private signature: FunctionSignature;
+    public static readonly PARAMETER_TIMESTAMP_NAME: string = 'isoTimeStamp';
 
-    public static readonly EVENT_RESULT_NAME: string = 'result';
-
-    public static readonly PARAMETER_DATE_NAME: string = 'isoDate';
+    public static readonly PARAMETER_TIMESTAMP_NAME_ONE: string = 'isoTimeStamp1';
+    public static readonly PARAMETER_TIMESTAMP_NAME_TWO: string = 'isoTimeStamp2';
 
-    public static readonly PARAMETER_FIELD_NAME: string = 'value';
+    public static readonly PARAMETER_UNIT_NAME: string = 'unit';
 
-    public static readonly PARAMETER_INT_NAME: string = "intValue";
+    public static readonly PARAMETER_NUMBER_NAME: string = 'number';
 
-	public static readonly PARAMETER_UNIT_NAME: string  = "unit";
-    
-    protected static readonly PARAMETER_DATE: Parameter = new Parameter(
-        AbstractDateFunction.PARAMETER_DATE_NAME,
-        Schema.ofString(this.PARAMETER_DATE_NAME).setRef(Namespaces.DATE + ".timeStamp")
+    public static readonly PARAMETER_TIMESTAMP: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+        Schema.ofRef(Namespaces.DATE + '.Timestamp'),
     );
 
-    protected static readonly PARAMETER_FIELD : Parameter = new Parameter(
-        AbstractDateFunction.PARAMETER_FIELD_NAME,
-        Schema.ofInteger(this.PARAMETER_FIELD_NAME)
+    public static readonly PARAMETER_TIMESTAMP_ONE: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_ONE,
+        Schema.ofRef(Namespaces.DATE + '.Timestamp'),
     );
 
-    protected static readonly PARAMETER_INT : Parameter = new Parameter(
-        AbstractDateFunction.PARAMETER_INT_NAME,
-        Schema.ofInteger(this.PARAMETER_INT_NAME)
+    public static readonly PARAMETER_TIMESTAMP_TWO: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_TWO,
+        Schema.ofRef(Namespaces.DATE + '.Timestamp'),
     );
 
-    protected static readonly PARAMETER_UNIT : Parameter = new Parameter(
+    public static readonly PARAMETER_VARIABLE_UNIT: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_UNIT_NAME,
+        Schema.ofRef(Namespaces.DATE + '.Timeunit'),
+    ).setVariableArgument(true);
+
+    public static readonly PARAMETER_UNIT: Parameter = new Parameter(
         AbstractDateFunction.PARAMETER_UNIT_NAME,
-        Schema.ofString(this.PARAMETER_UNIT_NAME)
-        .setEnums(["YEAR" , "MONTH" , "DAY" , "HOUR" , "MINUTE" , "SECOND" , "MILLISECOND"])
+        Schema.ofRef(Namespaces.DATE + '.Timeunit'),
     );
 
-    protected static readonly EVENT_INT: Event = new Event(
+    public static readonly PARAMETER_NUMBER: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_NUMBER_NAME,
+        Schema.ofInteger(AbstractDateFunction.PARAMETER_NUMBER_NAME),
+    );
+
+    public static readonly EVENT_RESULT_NAME: string = 'result';
+    public static readonly EVENT_TIMESTAMP_NAME: string = 'isoTimeStamp';
+
+    public static readonly EVENT_INT: Event = new Event(
         Event.OUTPUT,
         MapUtil.of(
             AbstractDateFunction.EVENT_RESULT_NAME,
@@ -56,107 +63,218 @@ export abstract class AbstractDateFunction extends AbstractFunction {
         ),
     );
 
-    protected static readonly EVENT_BOOLEAN: Event = new Event(
+    public static readonly EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractDateFunction.EVENT_RESULT_NAME,
+            Schema.ofString(AbstractDateFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    public static readonly EVENT_LONG: Event = new Event(
         Event.OUTPUT,
         MapUtil.of(
             AbstractDateFunction.EVENT_RESULT_NAME,
-            Schema.ofBoolean(AbstractDateFunction.EVENT_RESULT_NAME)
-        )
+            Schema.ofLong(AbstractDateFunction.EVENT_RESULT_NAME),
+        ),
     );
 
-    protected static readonly EVENT_DATE : Event = new Event(
+    protected static readonly EVENT_BOOLEAN: Event = new Event(
         Event.OUTPUT,
         MapUtil.of(
             AbstractDateFunction.EVENT_RESULT_NAME,
-            Schema.ofString(AbstractDateFunction.EVENT_RESULT_NAME).setRef(Namespaces.DATE + ".timeStamp")
-        )
-    ); 
+            Schema.ofBoolean(AbstractDateFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    public static readonly EVENT_TIMESTAMP: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractDateFunction.EVENT_TIMESTAMP_NAME,
+            Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+        ),
+    );
 
     public getSignature(): FunctionSignature {
         return this.signature;
     }
 
-
-    constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
-
+    constructor(functionName: string, event: Event, ...parameter: Parameter[]) {
         super();
-        const paramMap: Map<string, Parameter> = new Map();
-        parameter.forEach((e) => paramMap.set(e.getParameterName(), e));
 
         this.signature = new FunctionSignature(functionName)
-            .setNamespace(namespace)
-            .setParameters(paramMap)
+            .setNamespace(Namespaces.DATE)
             .setEvents(MapUtil.of(event.getName(), event));
 
-    }
-
-    public static ofEntryDateAndBooleanOutput(name: string, fun: ( date : string) => boolean) : [string, Function] {
-    
-        return [name, new (class extends AbstractDateFunction {
-
-            constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
-                super(namespace, functionName, event, ...parameter);
-            }
-
-            protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-                
-                const date = context.getArguments()?.get(AbstractDateFunction.PARAMETER_DATE_NAME);
-                
-                if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
-                    throw new KIRuntimeException("Please provide a valid date.");
-
-                return new FunctionOutput([EventResult.outputOf(MapUtil.of(AbstractDateFunction.EVENT_RESULT_NAME, fun(date)))]);
+        if (!parameter?.length) return;
 
-            }
-
-
-        })(Namespaces.DATE, name, AbstractDateFunction.EVENT_BOOLEAN, AbstractDateFunction.PARAMETER_DATE)];
+        const paramMap: Map<string, Parameter> = new Map();
+        parameter.forEach((e) => paramMap.set(e.getParameterName(), e));
+        this.signature.setParameters(paramMap);
     }
 
-    public static ofEntryDateAndIntegerOutput(name: string, fun: (date: string) => number) : [string, Function] {
-        
-        return [name, new (class extends AbstractDateFunction {
-            constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
-                super(namespace, functionName, event, ...parameter);
-            }
-
-            protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-
-                const date = context.getArguments()?.get(AbstractDateFunction.PARAMETER_DATE_NAME);
-
-                if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
-                    throw new KIRuntimeException("Please provide a valid date object");
-
-                return new FunctionOutput([EventResult.outputOf(MapUtil.of( AbstractDateFunction.EVENT_RESULT_NAME, fun(date)))])
-            }
-        })(Namespaces.DATE, name, AbstractDateFunction.EVENT_INT, AbstractDateFunction.PARAMETER_DATE)];
+    public static ofEntryTimestampAndIntegerOutput(
+        name: string,
+        fun: (isoTimestamp: string) => number,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                                ),
+                            ),
+                        ),
+                    ]);
+                }
+            })(name, AbstractDateFunction.EVENT_INT, AbstractDateFunction.PARAMETER_TIMESTAMP),
+        ];
     }
 
-    public static ofEntryDateWithIntegerUnitWithOutputName( functionName: string, 
-        func: (date: string, amount: number, unit: string) => string): [string, Function] {
-            return [functionName, new (class extends AbstractDateFunction {
-                constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
-                    super(namespace, functionName, event, ...parameter);
+    public static ofEntryTimestampAndBooleanOutput(
+        name: string,
+        fun: (isoTimestamp: string) => boolean,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                                ),
+                            ),
+                        ),
+                    ]);
                 }
+            })(name, AbstractDateFunction.EVENT_BOOLEAN, AbstractDateFunction.PARAMETER_TIMESTAMP),
+        ];
+    }
 
-                protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-
-                    const date = context.getArguments()?.get(AbstractDateFunction.PARAMETER_DATE_NAME);
-    
-                    if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
-                        throw new KIRuntimeException("Please provide a valid date object");
-
-                    const value = context.getArguments()?.get(AbstractDateFunction.PARAMETER_INT_NAME);
-
-                    const unit = context.getArguments()?.get(AbstractDateFunction.PARAMETER_UNIT_NAME);
-    
-                    return new FunctionOutput([EventResult.outputOf(MapUtil.of( AbstractDateFunction.EVENT_RESULT_NAME, func(date, value , unit)))]);
-
+    public static ofEntryTimestampAndStringOutput(
+        name: string,
+        fun: (isoTimestamp: string) => string,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                                ),
+                            ),
+                        ),
+                    ]);
                 }
-            })(Namespaces.DATE, functionName, AbstractDateFunction.EVENT_DATE,
-                 AbstractDateFunction.PARAMETER_DATE, AbstractDateFunction.PARAMETER_INT, AbstractDateFunction.PARAMETER_UNIT)];
+            })(name, AbstractDateFunction.EVENT_STRING, AbstractDateFunction.PARAMETER_TIMESTAMP),
+        ];
+    }
 
-          
-        }
+    public static ofEntryTimestampIntegerAndTimestampOutput(
+        name: string,
+        fun: (isoTimestamp: string, integer: number) => string,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_NUMBER_NAME),
+                                ),
+                            ),
+                        ),
+                    ]);
+                }
+            })(
+                name,
+                AbstractDateFunction.EVENT_INT,
+                AbstractDateFunction.PARAMETER_TIMESTAMP,
+                AbstractDateFunction.PARAMETER_NUMBER,
+            ),
+        ];
+    }
 
-}
+    public static ofEntryTimestampTimestampAndTOutput<T>(
+        name: string,
+        event: Event,
+        fun: (ts1: string, ts2: string, ...parameters: any[]) => T,
+        ...parameters: Parameter[]
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    const args = [];
+
+                    if (parameters?.length) {
+                        args.push(
+                            ...parameters.map((e) =>
+                                context.getArguments()?.get(e.getParameterName()),
+                            ),
+                        );
+                    }
+
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_ONE),
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_TWO),
+                                    args,
+                                ),
+                            ),
+                        ),
+                    ]);
+                }
+            })(
+                name,
+                event,
+                AbstractDateFunction.PARAMETER_TIMESTAMP_ONE,
+                AbstractDateFunction.PARAMETER_TIMESTAMP_TWO,
+                ...parameters,
+            ),
+        ];
+    }
+}

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

@@ -0,0 +1,99 @@
+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 AddSubtractTime extends AbstractDateFunction {
+    public static readonly PARAMETER_YEARS_NAME = 'years';
+    public static readonly PARAMETER_MONTHS_NAME = 'months';
+    public static readonly PARAMETER_DAYS_NAME = 'days';
+    public static readonly PARAMETER_HOURS_NAME = 'hours';
+    public static readonly PARAMETER_MINUTES_NAME = 'minutes';
+    public static readonly PARAMETER_SECONDS_NAME = 'seconds';
+    public static readonly PARAMETER_MILLISECONDS_NAME = 'milliseconds';
+
+    private readonly isAdd: boolean;
+
+    constructor(isAdd: boolean) {
+        super(
+            isAdd ? 'AddTime' : 'SubtractTime',
+            AbstractDateFunction.EVENT_TIMESTAMP,
+            AbstractDateFunction.PARAMETER_TIMESTAMP,
+            Parameter.of(
+                AddSubtractTime.PARAMETER_YEARS_NAME,
+                Schema.ofNumber(AddSubtractTime.PARAMETER_YEARS_NAME).setDefaultValue(0),
+            ),
+            Parameter.of(
+                AddSubtractTime.PARAMETER_MONTHS_NAME,
+                Schema.ofNumber(AddSubtractTime.PARAMETER_MONTHS_NAME).setDefaultValue(0),
+            ),
+            Parameter.of(
+                AddSubtractTime.PARAMETER_DAYS_NAME,
+                Schema.ofNumber(AddSubtractTime.PARAMETER_DAYS_NAME).setDefaultValue(0),
+            ),
+            Parameter.of(
+                AddSubtractTime.PARAMETER_HOURS_NAME,
+                Schema.ofNumber(AddSubtractTime.PARAMETER_HOURS_NAME).setDefaultValue(0),
+            ),
+            Parameter.of(
+                AddSubtractTime.PARAMETER_MINUTES_NAME,
+                Schema.ofNumber(AddSubtractTime.PARAMETER_MINUTES_NAME).setDefaultValue(0),
+            ),
+            Parameter.of(
+                AddSubtractTime.PARAMETER_SECONDS_NAME,
+                Schema.ofNumber(AddSubtractTime.PARAMETER_SECONDS_NAME).setDefaultValue(0),
+            ),
+            Parameter.of(
+                AddSubtractTime.PARAMETER_MILLISECONDS_NAME,
+                Schema.ofNumber(AddSubtractTime.PARAMETER_MILLISECONDS_NAME).setDefaultValue(0),
+            ),
+        );
+
+        this.isAdd = isAdd;
+    }
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        const timestamp = context
+            .getArguments()
+            ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME);
+
+        const dateTime = getDateTime(timestamp);
+        const years = context.getArguments()?.get(AddSubtractTime.PARAMETER_YEARS_NAME);
+        const months = context.getArguments()?.get(AddSubtractTime.PARAMETER_MONTHS_NAME);
+        const days = context.getArguments()?.get(AddSubtractTime.PARAMETER_DAYS_NAME);
+        const hours = context.getArguments()?.get(AddSubtractTime.PARAMETER_HOURS_NAME);
+        const minutes = context.getArguments()?.get(AddSubtractTime.PARAMETER_MINUTES_NAME);
+        const seconds = context.getArguments()?.get(AddSubtractTime.PARAMETER_SECONDS_NAME);
+        const milliseconds = context
+            .getArguments()
+            ?.get(AddSubtractTime.PARAMETER_MILLISECONDS_NAME);
+
+        const options = {
+            years,
+            months,
+            days,
+            hours,
+            minutes,
+            seconds,
+            milliseconds,
+        } as DurationLikeObject;
+
+        let newDateTime;
+
+        if (this.isAdd) {
+            newDateTime = dateTime.plus(options);
+        } else {
+            newDateTime = dateTime.minus(options);
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                MapUtil.of(AbstractDateFunction.EVENT_TIMESTAMP_NAME, newDateTime.toISO()),
+            ),
+        ]);
+    }
+}