tm1npm 1.0.0

package/src/objects/ProcessDebugBreakpoint.ts

@@ -0,0 +1,239 @@
+import { TM1Object } from './TM1Object';
+
+export enum HitMode {
+    BREAK_ALWAYS = 'BreakAlways',
+    BREAK_EQUAL = 'BreakEqual',
+    BREAK_GREATER_OR_EQUAL = 'BreakGreaterOrEqual'
+}
+
+export enum BreakPointType {
+    // A breakpoint that pauses execution when the named variable is written to
+    PROCESS_DEBUG_CONTEXT_DATA_BREAK_POINT = "ProcessDebugContextDataBreakpoint",
+    // A breakpoint that pauses execution at a specific script line
+    PROCESS_DEBUG_CONTEXT_LINE_BREAK_POINT = "ProcessDebugContextLineBreakpoint",
+    // A breakpoint that pauses execution when an object lock is acquired.
+    PROCESS_DEBUG_CONTEXT_LOCK_BREAK_POINT = "ProcessDebugContextLockBreakpoint"
+}
+
+export class ProcessDebugBreakpoint extends TM1Object {
+    /** Abstraction of a TM1 Process Debug Breakpoint.
+     *
+     */
+
+    private _type: BreakPointType;
+    private _id: number;
+    private _enabled: boolean;
+    private _hitMode: HitMode;
+    private _hitCount: number;
+    private _expression: string;
+    private _variableName: string;
+    private _processName: string;
+    private _procedure: string;
+    private _lineNumber: number;
+    private _objectName: string;
+    private _objectType: string;
+    private _lockMode: string;
+
+    constructor(
+        breakpointId: number,
+        breakpointType: BreakPointType | string = BreakPointType.PROCESS_DEBUG_CONTEXT_LINE_BREAK_POINT,
+        enabled: boolean = true,
+        hitMode: HitMode | string = HitMode.BREAK_ALWAYS,
+        hitCount: number = 0,
+        expression: string = '',
+        variableName: string = '',
+        processName: string = '',
+        procedure: string = '',
+        lineNumber: number = 0,
+        objectName: string = '',
+        objectType: string = '',
+        lockMode: string = ''
+    ) {
+        super();
+        this._type = this.parseBreakPointType(breakpointType);
+        this._id = breakpointId;
+        this._enabled = enabled;
+        this._hitMode = this.parseHitMode(hitMode);
+        this._hitCount = hitCount;
+        this._expression = expression;
+        this._variableName = variableName;
+        this._processName = processName;
+        this._procedure = procedure;
+        this._lineNumber = lineNumber;
+        this._objectName = objectName;
+        this._objectType = objectType;
+        this._lockMode = lockMode;
+    }
+
+    private parseBreakPointType(breakpointType: BreakPointType | string): BreakPointType {
+        if (typeof breakpointType === 'string') {
+            for (const member of Object.values(BreakPointType)) {
+                if (member.toLowerCase() === breakpointType.replace(/\s+/g, '').toLowerCase()) {
+                    return member;
+                }
+            }
+            throw new Error(`Invalid BreakPointType: '${breakpointType}'`);
+        }
+        return breakpointType;
+    }
+
+    private parseHitMode(hitMode: HitMode | string): HitMode {
+        if (typeof hitMode === 'string') {
+            for (const member of Object.values(HitMode)) {
+                if (member.toLowerCase() === hitMode.replace(/\s+/g, '').toLowerCase()) {
+                    return member;
+                }
+            }
+            throw new Error(`Invalid HitMode: '${hitMode}'`);
+        }
+        return hitMode;
+    }
+
+    public static fromDict(breakpointAsDict: any): ProcessDebugBreakpoint {
+        /**
+         *
+         * :param breakpoint_as_dict
+         * :return: an instance of this class
+         */
+        const breakpointType = breakpointAsDict['@odata.type'].substring(16);
+        return new ProcessDebugBreakpoint(
+            breakpointAsDict['ID'],
+            breakpointType,
+            breakpointAsDict['Enabled'],
+            breakpointAsDict['HitMode'],
+            breakpointAsDict['HitCount'],
+            breakpointAsDict['Expression'],
+            breakpointType === "ProcessDebugContextDataBreakpoint" ? breakpointAsDict['VariableName'] : "",
+            breakpointType === "ProcessDebugContextLineBreakpoint" ? breakpointAsDict['ProcessName'] : "",
+            breakpointType === "ProcessDebugContextLineBreakpoint" ? breakpointAsDict['Procedure'] : "",
+            breakpointType === "ProcessDebugContextLineBreakpoint" ? breakpointAsDict['LineNumber'] : 0,
+            breakpointType === "ProcessDebugContextLockBreakpoint" ? breakpointAsDict['ObjectName'] : "",
+            breakpointType === "ProcessDebugContextLockBreakpoint" ? breakpointAsDict['ObjectType'] : "",
+            breakpointType === "ProcessDebugContextLockBreakpoint" ? breakpointAsDict['LockMode'] : ""
+        );
+    }
+
+    public get breakpointType(): string {
+        return this._type.toString();
+    }
+
+    public get breakpointId(): number {
+        return this._id;
+    }
+
+    public get enabled(): boolean {
+        return this._enabled;
+    }
+
+    public set enabled(value: boolean) {
+        this._enabled = value;
+    }
+
+    public get hitMode(): string {
+        return this._hitMode.toString();
+    }
+
+    public set hitMode(value: HitMode | string) {
+        this._hitMode = this.parseHitMode(value);
+    }
+
+    public get hitCount(): number {
+        return this._hitCount;
+    }
+
+    public get expression(): string {
+        return this._expression;
+    }
+
+    public set expression(value: string) {
+        this._expression = value;
+    }
+
+    public get variableName(): string {
+        return this._variableName;
+    }
+
+    public set variableName(value: string) {
+        this._variableName = value;
+    }
+
+    public get processName(): string {
+        return this._processName;
+    }
+
+    public set processName(value: string) {
+        this._processName = value;
+    }
+
+    public get procedure(): string {
+        return this._procedure;
+    }
+
+    public set procedure(value: string) {
+        this._procedure = value;
+    }
+
+    public get lineNumber(): number {
+        return this._lineNumber;
+    }
+
+    public set lineNumber(value: number) {
+        this._lineNumber = value;
+    }
+
+    public get objectName(): string {
+        return this._objectName;
+    }
+
+    public set objectName(value: string) {
+        this._objectName = value;
+    }
+
+    public get objectType(): string {
+        return this._objectType;
+    }
+
+    public set objectType(value: string) {
+        this._objectType = value;
+    }
+
+    public get lockMode(): string {
+        return this._lockMode;
+    }
+
+    public set lockMode(value: string) {
+        this._lockMode = value;
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.constructBody());
+    }
+
+    public get bodyAsDict(): any {
+        return this.constructBody();
+    }
+
+    private constructBody(): any {
+        const bodyAsDict: any = {
+            '@odata.type': "#ibm.tm1.api.v1." + this._type,
+            'ID': this._id,
+            'Enabled': this._enabled,
+            'HitMode': this._hitMode.toString(),
+            'Expression': this._expression
+        };
+
+        if (this._type === BreakPointType.PROCESS_DEBUG_CONTEXT_DATA_BREAK_POINT) {
+            bodyAsDict['VariableName'] = this._variableName;
+        } else if (this._type === BreakPointType.PROCESS_DEBUG_CONTEXT_LINE_BREAK_POINT) {
+            bodyAsDict['ProcessName'] = this._processName;
+            bodyAsDict['Procedure'] = this._procedure;
+            bodyAsDict['LineNumber'] = this._lineNumber;
+        } else if (this._type === BreakPointType.PROCESS_DEBUG_CONTEXT_LOCK_BREAK_POINT) {
+            bodyAsDict['ObjectName'] = this._objectName;
+            bodyAsDict['ObjectType'] = this._objectType;
+            bodyAsDict['LockMode'] = this._lockMode;
+        }
+
+        return bodyAsDict;
+    }
+}

package/src/objects/ProcessParameter.ts

@@ -0,0 +1,76 @@
+import { TM1Object } from './TM1Object';
+
+export enum ProcessParameterType {
+    String = 'String',
+    Numeric = 'Numeric'
+}
+
+export class ProcessParameter extends TM1Object {
+    private _name: string;
+    private _prompt: string;
+    private _value: string | number;
+    private _type: ProcessParameterType;
+
+    constructor(
+        name: string,
+        prompt: string = '',
+        value: string | number = '',
+        type: ProcessParameterType = ProcessParameterType.String
+    ) {
+        super();
+        this._name = name;
+        this._prompt = prompt;
+        this._value = value;
+        this._type = type;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(name: string) {
+        this._name = name;
+    }
+
+    public get prompt(): string {
+        return this._prompt;
+    }
+
+    public set prompt(prompt: string) {
+        this._prompt = prompt;
+    }
+
+    public get value(): string | number {
+        return this._value;
+    }
+
+    public set value(value: string | number) {
+        this._value = value;
+    }
+
+    public get type(): ProcessParameterType {
+        return this._type;
+    }
+
+    public set type(type: ProcessParameterType) {
+        this._type = type;
+    }
+
+    public get body(): string {
+        return JSON.stringify({
+            Name: this._name,
+            Prompt: this._prompt,
+            Value: this._value,
+            Type: this._type
+        });
+    }
+
+    public static fromDict(parameterAsDict: any): ProcessParameter {
+        return new ProcessParameter(
+            parameterAsDict.Name,
+            parameterAsDict.Prompt || '',
+            parameterAsDict.Value || '',
+            parameterAsDict.Type || ProcessParameterType.String
+        );
+    }
+}

package/src/objects/ProcessVariable.ts

@@ -0,0 +1,89 @@
+import { TM1Object } from './TM1Object';
+
+export enum ProcessVariableType {
+    String = 'String',
+    Numeric = 'Numeric'
+}
+
+export class ProcessVariable extends TM1Object {
+    private _name: string;
+    private _type: ProcessVariableType;
+    private _position: number;
+    private _startByte: number;
+    private _endByte: number;
+
+    constructor(
+        name: string,
+        type: ProcessVariableType = ProcessVariableType.String,
+        position: number = 1,
+        startByte: number = 1,
+        endByte: number = 8
+    ) {
+        super();
+        this._name = name;
+        this._type = type;
+        this._position = position;
+        this._startByte = startByte;
+        this._endByte = endByte;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(name: string) {
+        this._name = name;
+    }
+
+    public get type(): ProcessVariableType {
+        return this._type;
+    }
+
+    public set type(type: ProcessVariableType) {
+        this._type = type;
+    }
+
+    public get position(): number {
+        return this._position;
+    }
+
+    public set position(position: number) {
+        this._position = position;
+    }
+
+    public get startByte(): number {
+        return this._startByte;
+    }
+
+    public set startByte(startByte: number) {
+        this._startByte = startByte;
+    }
+
+    public get endByte(): number {
+        return this._endByte;
+    }
+
+    public set endByte(endByte: number) {
+        this._endByte = endByte;
+    }
+
+    public get body(): string {
+        return JSON.stringify({
+            Name: this._name,
+            Type: this._type,
+            Position: this._position,
+            StartByte: this._startByte,
+            EndByte: this._endByte
+        });
+    }
+
+    public static fromDict(variableAsDict: any): ProcessVariable {
+        return new ProcessVariable(
+            variableAsDict.Name,
+            variableAsDict.Type || ProcessVariableType.String,
+            variableAsDict.Position || 1,
+            variableAsDict.StartByte || 1,
+            variableAsDict.EndByte || 8
+        );
+    }
+}

package/src/objects/Rules.ts

@@ -0,0 +1,117 @@
+import { TM1Object } from './TM1Object';
+
+export class Rules extends TM1Object {
+    /**
+     *     Abstraction of Rules on a cube.
+     *
+     *     rules_analytics
+     *         A collection of rulestatements, where each statement is stored in uppercase without linebreaks.
+     *         comments are not included.
+     *
+     */
+    public static readonly KEYWORDS = ['SKIPCHECK', 'FEEDSTRINGS', 'UNDEFVALS', 'FEEDERS'];
+
+    private _text: string;
+    private _rulesAnalytics: string[] = [];
+
+    constructor(rules: string) {
+        super();
+        this._text = rules;
+        this._rulesAnalytics = [];
+        this.initAnalytics();
+    }
+
+    // this._rulesAnalytics serves for analysis on cube rules
+    private initAnalytics(): void {
+        const textWithoutComments = this._text
+            .split('\n')
+            .filter(rule => rule.trim().length > 0 && rule.trim()[0] !== '#')
+            .join('\n');
+
+        for (const statement of textWithoutComments.split(';')) {
+            if (statement.trim().length > 0) {
+                this._rulesAnalytics.push(statement.replace(/\n/g, '').toUpperCase());
+            }
+        }
+    }
+
+    public get text(): string {
+        return this._text;
+    }
+
+    public get rulesAnalytics(): string[] {
+        return this._rulesAnalytics;
+    }
+
+    public get ruleStatements(): string[] {
+        if (this.hasFeeders) {
+            return this.rulesAnalytics.slice(0, this._rulesAnalytics.indexOf('FEEDERS'));
+        }
+        return this.rulesAnalytics;
+    }
+
+    public get feederStatements(): string[] {
+        if (this.hasFeeders) {
+            return this.rulesAnalytics.slice(this._rulesAnalytics.indexOf('FEEDERS') + 1);
+        }
+        return [];
+    }
+
+    public get skipcheck(): boolean {
+        for (const rule of this._rulesAnalytics.slice(0, 5)) {
+            if (rule === 'SKIPCHECK') {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public get undefvals(): boolean {
+        for (const rule of this._rulesAnalytics.slice(0, 5)) {
+            if (rule === 'UNDEFVALS') {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public get feedstrings(): boolean {
+        for (const rule of this._rulesAnalytics.slice(0, 5)) {
+            if (rule === 'FEEDSTRINGS') {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public get hasFeeders(): boolean {
+        if (this._rulesAnalytics.includes('FEEDERS')) {
+            // has feeders declaration
+            const feeders = this.rulesAnalytics.slice(this._rulesAnalytics.indexOf('FEEDERS'));
+            // has at least one actual feeder statement
+            return feeders.length > 1;
+        }
+        return false;
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.bodyAsDict);
+    }
+
+    public get bodyAsDict(): any {
+        return { Rules: this.text };
+    }
+
+    public get length(): number {
+        return this.rulesAnalytics.length;
+    }
+
+    // iterate through actual rule statements without linebreaks. Ignore comments.
+    public *[Symbol.iterator](): Iterator<string> {
+        yield* this.rulesAnalytics;
+    }
+
+    public toString(): string {
+        return this.text;
+    }
+}

package/src/objects/Sandbox.ts

@@ -0,0 +1,90 @@
+import { TM1Object } from './TM1Object';
+
+export class Sandbox extends TM1Object {
+    /** Abstraction of a TM1 Sandbox
+     *        
+     */
+
+    private _name!: string;
+    private _includeInSandboxDimension!: boolean;
+    public loaded: boolean;
+    public active: boolean;
+    public queued: boolean;
+
+    constructor(
+        name: string,
+        includeInSandboxDimension: boolean = true,
+        loaded: boolean = false,
+        active: boolean = false,
+        queued: boolean = false
+    ) {
+        /**
+         * 
+         * :param name: name of the Sandbox
+         * :param include_in_sandbox_dimension:
+         * :params loaded, active, queued: leave default as false when creating sandbox 
+         */
+        super();
+        this.name = name;
+        this.includeInSandboxDimension = includeInSandboxDimension;
+        this.loaded = loaded;
+        this.active = active;
+        this.queued = queued;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(value: string) {
+        this._name = value;
+    }
+
+    public get includeInSandboxDimension(): boolean {
+        return this._includeInSandboxDimension;
+    }
+
+    public set includeInSandboxDimension(value: boolean) {
+        this._includeInSandboxDimension = value;
+    }
+
+    public static fromJSON(sandboxAsJson: string): Sandbox {
+        /** Alternative constructor
+         *
+         * :param sandbox_as_json: user as JSON string
+         * :return: sandbox, an instance of this class
+         */
+        const sandboxAsDict = JSON.parse(sandboxAsJson);
+        return Sandbox.fromDict(sandboxAsDict);
+    }
+
+    public static fromDict(sandboxAsDict: any): Sandbox {
+        /** Alternative constructor
+         *
+         * :param sandbox_as_dict: user as dict
+         * :return: an instance of this class
+         */
+        return new Sandbox(
+            sandboxAsDict.Name,
+            sandboxAsDict.IncludeInSandboxDimension,
+            sandboxAsDict.IsLoaded,
+            sandboxAsDict.IsActive,
+            sandboxAsDict.IsQueued
+        );
+    }
+
+    public get body(): string {
+        return this.constructBody();
+    }
+
+    private constructBody(): string {
+        /**
+         * construct body (json) from the class attributes
+         * :return: String, TM1 JSON representation of a sandbox
+         */
+        const bodyAsDict: any = {};
+        bodyAsDict.Name = this.name;
+        bodyAsDict.IncludeInSandboxDimension = this._includeInSandboxDimension;
+        return JSON.stringify(bodyAsDict);
+    }
+}

package/src/objects/Server.ts

@@ -0,0 +1,45 @@
+export class Server {
+    /** Abstraction of the TM1 Server
+     *
+     *    :Notes:
+     *        contains the information you get from http://localhost:5895/Servers
+     *        no methods so far
+     */
+    public name: string;
+    public ipAddress: string;
+    public ipV6Address: string;
+    public portNumber: number;
+    public clientMessagePortNumber: number;
+    public httpPortNumber: number;
+    public usingSSL: boolean;
+    public acceptingClients: boolean;
+    public selfRegistered: boolean;
+    public host: string;
+    public isLocal: boolean;
+    public sslCertificateId: string;
+    public sslCertificateAuthority: string;
+    public sslCertificateRevocationList: string;
+    public clientExportSslServerKeyId: string;
+    public clientExportSslServerCert: string;
+    public lastUpdated: string;
+
+    constructor(serverAsDict: Record<string, any>) {
+        this.name = serverAsDict['Name'];
+        this.ipAddress = serverAsDict['IPAddress'];
+        this.ipV6Address = serverAsDict['IPv6Address'];
+        this.portNumber = serverAsDict['PortNumber'];
+        this.clientMessagePortNumber = serverAsDict['ClientMessagePortNumber'];
+        this.httpPortNumber = serverAsDict['HTTPPortNumber'];
+        this.usingSSL = serverAsDict['UsingSSL'];
+        this.acceptingClients = serverAsDict['AcceptingClients'];
+        this.selfRegistered = serverAsDict['SelfRegistered'];
+        this.host = serverAsDict['Host'];
+        this.isLocal = serverAsDict['IsLocal'];
+        this.sslCertificateId = serverAsDict['SSLCertificateID'];
+        this.sslCertificateAuthority = serverAsDict['SSLCertificateAuthority'];
+        this.sslCertificateRevocationList = serverAsDict['SSLCertificateRevocationList'];
+        this.clientExportSslServerKeyId = serverAsDict['ClientExportSSLSvrKeyID'];
+        this.clientExportSslServerCert = serverAsDict['ClientExportSSLSvrCert'];
+        this.lastUpdated = serverAsDict['LastUpdated'];
+    }
+}