tm1npm 1.0.0

package/src/objects/Application.ts

@@ -0,0 +1,146 @@
+import { TM1Object } from './TM1Object';
+
+export enum ApplicationTypes {
+    CUBE = 'tm1.cube',
+    DIMENSION = 'tm1.dimension',
+    PROCESS = 'tm1.process',
+    CHORE = 'tm1.chore',
+    VIEW = 'tm1.view',
+    SUBSET = 'tm1.subset',
+    DOCUMENT = 'tm1.document',
+    FOLDER = 'tm1.folder',
+    LINK = 'tm1.link'
+}
+
+// Compatibility aliases
+export const ApplicationTypeAliases = {
+    Cube: ApplicationTypes.CUBE,
+    Dimension: ApplicationTypes.DIMENSION,
+    Process: ApplicationTypes.PROCESS,
+    Chore: ApplicationTypes.CHORE,
+    View: ApplicationTypes.VIEW,
+    Subset: ApplicationTypes.SUBSET,
+    Document: ApplicationTypes.DOCUMENT,
+    Folder: ApplicationTypes.FOLDER,
+    Link: ApplicationTypes.LINK
+};
+
+export class Application extends TM1Object {
+    private _name: string;
+    private _path: string;
+    private _documented: boolean;
+    private _type: string;
+
+    constructor(
+        name: string,
+        path: string = '',
+        documented: boolean = false,
+        type: string = 'Application'
+    ) {
+        super();
+        this._name = name;
+        this._path = path;
+        this._documented = documented;
+        this._type = type;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(name: string) {
+        this._name = name;
+    }
+
+    public get path(): string {
+        return this._path;
+    }
+
+    public set path(path: string) {
+        this._path = path;
+    }
+
+    public get documented(): boolean {
+        return this._documented;
+    }
+
+    public set documented(documented: boolean) {
+        this._documented = documented;
+    }
+
+    public get type(): string {
+        return this._type;
+    }
+
+    public get body(): string {
+        return JSON.stringify({
+            Name: this._name,
+            Path: this._path,
+            Documented: this._documented,
+            Type: this._type
+        });
+    }
+
+    public static fromDict(applicationAsDict: any): Application {
+        return new Application(
+            applicationAsDict.Name,
+            applicationAsDict.Path || '',
+            applicationAsDict.Documented || false,
+            applicationAsDict.Type || 'Application'
+        );
+    }
+}
+
+export class CubeApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, false, ApplicationTypes.CUBE);
+    }
+}
+
+export class DimensionApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, false, ApplicationTypes.DIMENSION);
+    }
+}
+
+export class ProcessApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, false, ApplicationTypes.PROCESS);
+    }
+}
+
+export class ChoreApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, false, ApplicationTypes.CHORE);
+    }
+}
+
+export class ViewApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, false, ApplicationTypes.VIEW);
+    }
+}
+
+export class SubsetApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, false, ApplicationTypes.SUBSET);
+    }
+}
+
+export class DocumentApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, true, ApplicationTypes.DOCUMENT);
+    }
+}
+
+export class FolderApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, false, ApplicationTypes.FOLDER);
+    }
+}
+
+export class LinkApplication extends Application {
+    constructor(name: string, path: string = '') {
+        super(name, path, false, ApplicationTypes.LINK);
+    }
+}

package/src/objects/Axis.ts

@@ -0,0 +1,149 @@
+import { TM1Object } from './TM1Object';
+import { Subset, AnonymousSubset } from './Subset';
+import { formatUrl } from '../utils/Utils';
+
+export class ViewAxisSelection extends TM1Object {
+    /** Describes what is selected in a dimension on an axis. Can be a Registered Subset or an Anonymous Subset
+     */
+
+    private _subset: Subset | AnonymousSubset;
+    private _dimensionName: string;
+    private _hierarchyName: string;
+
+    constructor(dimensionName: string, subset: Subset | AnonymousSubset) {
+        /**
+         *    :Parameters:
+         *        `dimension_name` : String
+         *        `subset` : Subset or AnonymousSubset
+         */
+        super();
+        this._subset = subset;
+        this._dimensionName = dimensionName;
+        this._hierarchyName = dimensionName;
+    }
+
+    public get subset(): Subset | AnonymousSubset {
+        return this._subset;
+    }
+
+    public get dimensionName(): string {
+        return this._dimensionName;
+    }
+
+    public get hierarchyName(): string {
+        return this._hierarchyName;
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.constructBody());
+    }
+
+    public get bodyAsDict(): Record<string, any> {
+        return this.constructBody();
+    }
+
+    public static fromDict(data: Record<string, any>): ViewAxisSelection {
+        // Basic implementation - would need actual data structure
+        return new ViewAxisSelection('', new AnonymousSubset('', ''));
+    }
+
+    private constructBody(): Record<string, any> {
+        /** construct the ODATA conform JSON represenation for the ViewAxisSelection entity.
+         *
+         * :return: dictionary
+         */
+        const bodyAsDict: Record<string, any> = {};
+        
+        if (this._subset instanceof AnonymousSubset) {
+            bodyAsDict['Subset'] = JSON.parse(this._subset.body);
+        } else if (this._subset instanceof Subset) {
+            const subsetPath = formatUrl(
+                "Dimensions('{}')/Hierarchies('{}')/Subsets('{}')",
+                this._dimensionName,
+                this._hierarchyName,
+                this._subset.name
+            );
+            bodyAsDict['Subset@odata.bind'] = subsetPath;
+        }
+        
+        return bodyAsDict;
+    }
+}
+
+
+export class ViewTitleSelection {
+    /** Describes what is selected in a dimension on the view title.
+     *    Can be a Registered Subset or an Anonymous Subset
+     */
+
+    private _dimensionName: string;
+    private _hierarchyName: string;
+    private _subset: AnonymousSubset | Subset;
+    private _selected: string;
+
+    constructor(dimensionName: string, subset: AnonymousSubset | Subset, selected: string) {
+        this._dimensionName = dimensionName;
+        this._hierarchyName = dimensionName;
+        this._subset = subset;
+        this._selected = selected;
+    }
+
+    public get subset(): Subset | AnonymousSubset {
+        return this._subset;
+    }
+
+    public get dimensionName(): string {
+        return this._dimensionName;
+    }
+
+    public get hierarchyName(): string {
+        return this._hierarchyName;
+    }
+
+    public get selected(): string {
+        return this._selected;
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.constructBody());
+    }
+
+    public get bodyAsDict(): Record<string, any> {
+        return this.constructBody();
+    }
+
+    public static fromDict(data: Record<string, any>): ViewTitleSelection {
+        // Basic implementation - would need actual data structure
+        return new ViewTitleSelection('', new AnonymousSubset('', ''), '');
+    }
+
+    private constructBody(): Record<string, any> {
+        /** construct the ODATA conform JSON represenation for the ViewTitleSelection entity.
+         *
+         * :return: string, the valid JSON
+         */
+        const bodyAsDict: Record<string, any> = {};
+        
+        if (this._subset instanceof AnonymousSubset) {
+            bodyAsDict['Subset'] = JSON.parse(this._subset.body);
+        } else if (this._subset instanceof Subset) {
+            const subsetPath = formatUrl(
+                "Dimensions('{}')/Hierarchies('{}')/Subsets('{}')",
+                this._dimensionName,
+                this._hierarchyName,
+                this._subset.name
+            );
+            bodyAsDict['Subset@odata.bind'] = subsetPath;
+        }
+        
+        const elementPath = formatUrl(
+            "Dimensions('{}')/Hierarchies('{}')/Elements('{}')",
+            this._dimensionName,
+            this._hierarchyName,
+            this._selected
+        );
+        bodyAsDict['Selected@odata.bind'] = elementPath;
+        
+        return bodyAsDict;
+    }
+}

package/src/objects/Chore.ts

@@ -0,0 +1,174 @@
+import { TM1Object } from './TM1Object';
+import { ChoreFrequency } from './ChoreFrequency';
+import { ChoreStartTime } from './ChoreStartTime';
+import { ChoreTask } from './ChoreTask';
+
+export class Chore extends TM1Object {
+    /** Abstraction of TM1 Chore
+     *
+     */
+    public static readonly SINGLE_COMMIT = 'SingleCommit';
+    public static readonly MULTIPLE_COMMIT = 'MultipleCommit';
+
+    private _name: string;
+    private _startTime: ChoreStartTime;
+    private _dstSensitivity: boolean;
+    private _active: boolean;
+    private _executionMode: string;
+    private _frequency: ChoreFrequency;
+    private _tasks: ChoreTask[];
+
+    constructor(
+        name: string,
+        startTime: ChoreStartTime,
+        dstSensitivity: boolean,
+        active: boolean,
+        executionMode: string,
+        frequency: ChoreFrequency,
+        tasks: Iterable<ChoreTask>
+    ) {
+        super();
+        this._name = name;
+        this._startTime = startTime;
+        this._dstSensitivity = dstSensitivity;
+        this._active = active;
+        this._executionMode = executionMode;
+        this._frequency = frequency;
+        this._tasks = Array.from(tasks);
+    }
+
+    public static fromJSON(choreAsJson: string): Chore {
+        /** Alternative constructor
+         *
+         * :param chore_as_json: string, JSON. Response of /Chores('x')/Tasks?$expand=*
+         * :return: Chore, an instance of this class
+         */
+        const choreAsDict = JSON.parse(choreAsJson);
+        return Chore.fromDict(choreAsDict);
+    }
+
+    public static fromDict(choreAsDict: any): Chore {
+        /** Alternative constructor
+         *
+         * :param chore_as_dict: Chore as dict
+         * :return: Chore, an instance of this class
+         */
+        return new Chore(
+            choreAsDict.Name,
+            ChoreStartTime.fromString(choreAsDict.StartTime),
+            choreAsDict.DSTSensitive,
+            choreAsDict.Active,
+            choreAsDict.ExecutionMode,
+            ChoreFrequency.fromString(choreAsDict.Frequency),
+            choreAsDict.Tasks.map((task: any, step: number) => 
+                ChoreTask.fromDict(task, step))
+        );
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(name: string) {
+        this._name = name;
+    }
+
+    public get startTime(): ChoreStartTime {
+        return this._startTime;
+    }
+
+    public set startTime(startTime: ChoreStartTime) {
+        this._startTime = startTime;
+    }
+
+    public get dstSensitivity(): boolean {
+        return this._dstSensitivity;
+    }
+
+    public set dstSensitivity(dstSensitivity: boolean) {
+        this._dstSensitivity = dstSensitivity;
+    }
+
+    public get active(): boolean {
+        return this._active;
+    }
+
+    public get executionMode(): string {
+        return this._executionMode;
+    }
+
+    public set executionMode(executionMode: string) {
+        this._executionMode = executionMode;
+    }
+
+    public get frequency(): ChoreFrequency {
+        return this._frequency;
+    }
+
+    public set frequency(frequency: ChoreFrequency) {
+        this._frequency = frequency;
+    }
+
+    public get tasks(): ChoreTask[] {
+        return this._tasks;
+    }
+
+    public set tasks(tasks: ChoreTask[]) {
+        this._tasks = tasks;
+    }
+
+    public addTask(task: ChoreTask): void {
+        this._tasks.push(task);
+    }
+
+    public removeTask(step: number): ChoreTask | undefined {
+        if (step >= 0 && step < this._tasks.length) {
+            return this._tasks.splice(step, 1)[0];
+        }
+        return undefined;
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.constructBody());
+    }
+
+    public get bodyAsDict(): any {
+        return this.constructBody();
+    }
+
+    private constructBody(): any {
+        const body: any = {};
+        body.Name = this._name;
+        body.StartTime = this._startTime.toString();
+        body.DSTSensitive = this._dstSensitivity;
+        body.Active = this._active;
+        body.ExecutionMode = this._executionMode;
+        body.Frequency = this._frequency.toString();
+        body.Tasks = this._tasks.map(task => task.bodyAsDict);
+        return body;
+    }
+
+    public reschedule(frequency: ChoreFrequency, startTime?: ChoreStartTime): void {
+        /** Reschedule the chore
+         *
+         * :param frequency: new ChoreFrequency
+         * :param start_time: new ChoreStartTime (optional)
+         */
+        this._frequency = frequency;
+        if (startTime) {
+            this._startTime = startTime;
+        }
+    }
+
+    public activate(): void {
+        /** Activate the chore
+         */
+        this._active = true;
+    }
+
+    public deactivate(): void {
+        /** Deactivate the chore
+         */
+        this._active = false;
+    }
+}

package/src/objects/ChoreFrequency.ts

@@ -0,0 +1,83 @@
+import { TM1Object } from './TM1Object';
+
+export class ChoreFrequency extends TM1Object {
+    /** Utility class to handle time representation fore Chore Frequency
+     */
+
+    private _days: string;
+    private _hours: string;
+    private _minutes: string;
+    private _seconds: string;
+
+    constructor(days: string | number, hours: string | number, minutes: string | number, seconds: string | number) {
+        super();
+        this._days = String(days).padStart(2, '0');
+        this._hours = String(hours).padStart(2, '0');
+        this._minutes = String(minutes).padStart(2, '0');
+        this._seconds = String(seconds).padStart(2, '0');
+    }
+
+    public get days(): string {
+        return this._days;
+    }
+
+    public get hours(): string {
+        return this._hours;
+    }
+
+    public get minutes(): string {
+        return this._minutes;
+    }
+
+    public get seconds(): string {
+        return this._seconds;
+    }
+
+    public set days(value: string | number) {
+        this._days = String(value).padStart(2, '0');
+    }
+
+    public set hours(value: string | number) {
+        this._hours = String(value).padStart(2, '0');
+    }
+
+    public set minutes(value: string | number) {
+        this._minutes = String(value).padStart(2, '0');
+    }
+
+    public set seconds(value: string | number) {
+        this._seconds = String(value).padStart(2, '0');
+    }
+
+    public static fromString(frequencyString: string): ChoreFrequency {
+        const posDt = frequencyString.indexOf('DT', 1);
+        const posH = frequencyString.indexOf('H', posDt);
+        const posM = frequencyString.indexOf('M', posH);
+        const posS = frequencyString.length - 1;
+        
+        return new ChoreFrequency(
+            frequencyString.substring(1, posDt),
+            frequencyString.substring(posDt + 2, posH),
+            frequencyString.substring(posH + 1, posM),
+            frequencyString.substring(posM + 1, posS)
+        );
+    }
+
+    public get frequencyString(): string {
+        return `P${this._days}DT${this._hours}H${this._minutes}M${this._seconds}S`;
+    }
+
+    public get body(): string {
+        return JSON.stringify({
+            Days: this._days,
+            Hours: this._hours,
+            Minutes: this._minutes,
+            Seconds: this._seconds,
+            FrequencyString: this.frequencyString
+        });
+    }
+
+    public toString(): string {
+        return this.frequencyString;
+    }
+}

package/src/objects/ChoreStartTime.ts

@@ -0,0 +1,111 @@
+export class ChoreStartTime {
+    /** Utility class to handle time representation for Chore Start Time
+     */
+
+    private _datetime: Date;
+    public tz?: string;
+
+    constructor(year: number, month: number, day: number, hour: number, minute: number, second: number, tz?: string) {
+        /**
+         * :param year: year
+         * :param month: month
+         * :param day: day
+         * :param hour: hour or None
+         * :param minute: minute or None
+         * :param second: second or None
+         */
+        this._datetime = new Date(year, month - 1, day, hour, minute, second); // month is 0-indexed in JS
+        this.tz = tz;
+    }
+
+    public static fromString(startTimeString: string): ChoreStartTime {
+        // extract optional tz info (e.g., +01:00) from string end
+        let tz: string | undefined;
+        if (startTimeString.includes('+')) {
+            // case "2020-11-05T08:00:01+01:00",
+            tz = "+" + startTimeString.split('+')[1];
+        } else if (startTimeString.split('-').length === 4) {
+            // case: "2020-11-05T08:00:01-01:00",
+            const parts = startTimeString.split('-');
+            tz = "-" + parts[parts.length - 1];
+        } else {
+            tz = undefined;
+        }
+
+        // f to handle strange timestamp 2016-09-25T20:25Z instead of common 2016-09-25T20:25:00Z
+        // second is defaulted to 0 if not specified in the chore schedule
+        const f = (x: string | undefined): number => x ? parseInt(x) : 0;
+        
+        return new ChoreStartTime(
+            f(startTimeString.substring(0, 4)),
+            f(startTimeString.substring(5, 7)),
+            f(startTimeString.substring(8, 10)),
+            f(startTimeString.substring(11, 13)),
+            f(startTimeString.substring(14, 16)),
+            startTimeString[16] !== ":" ? 0 : f(startTimeString.substring(17, 19)),
+            tz
+        );
+    }
+
+    public get startTimeString(): string {
+        // produce timestamp 2016-09-25T20:25:00Z instead of common 2016-09-25T20:25Z where no seconds are specified
+        const year = this._datetime.getFullYear().toString().padStart(4, '0');
+        const month = (this._datetime.getMonth() + 1).toString().padStart(2, '0');
+        const day = this._datetime.getDate().toString().padStart(2, '0');
+        const hour = this._datetime.getHours().toString().padStart(2, '0');
+        const minute = this._datetime.getMinutes().toString().padStart(2, '0');
+        const second = this._datetime.getSeconds().toString().padStart(2, '0');
+        
+        let startTime = `${year}-${month}-${day}T${hour}:${minute}:${second}`;
+
+        if (this.tz) {
+            startTime += this.tz;
+        } else {
+            startTime += "Z";
+        }
+
+        return startTime;
+    }
+
+    public get datetime(): Date {
+        return this._datetime;
+    }
+
+    public toString(): string {
+        return this.startTimeString;
+    }
+
+    public setTime(
+        year?: number, 
+        month?: number, 
+        day?: number, 
+        hour?: number, 
+        minute?: number,
+        second?: number
+    ): void {
+        const _year = year !== undefined ? year : this._datetime.getFullYear();
+        const _month = month !== undefined ? month - 1 : this._datetime.getMonth(); // month is 0-indexed
+        const _day = day !== undefined ? day : this._datetime.getDate();
+        const _hour = hour !== undefined ? hour : this._datetime.getHours();
+        const _minute = minute !== undefined ? minute : this._datetime.getMinutes();
+        const _second = second !== undefined ? second : this._datetime.getSeconds();
+
+        this._datetime = new Date(_year, _month, _day, _hour, _minute, _second);
+    }
+
+    public add(days: number = 0, hours: number = 0, minutes: number = 0, seconds: number = 0): void {
+        const totalMs = days * 24 * 60 * 60 * 1000 + 
+                       hours * 60 * 60 * 1000 + 
+                       minutes * 60 * 1000 + 
+                       seconds * 1000;
+        this._datetime = new Date(this._datetime.getTime() + totalMs);
+    }
+
+    public subtract(days: number = 0, hours: number = 0, minutes: number = 0, seconds: number = 0): void {
+        const totalMs = days * 24 * 60 * 60 * 1000 + 
+                       hours * 60 * 60 * 1000 + 
+                       minutes * 60 * 1000 + 
+                       seconds * 1000;
+        this._datetime = new Date(this._datetime.getTime() - totalMs);
+    }
+}