tm1npm 1.0.0

package/src/objects/ChoreTask.ts

@@ -0,0 +1,92 @@
+import { TM1Object } from './TM1Object';
+import { formatUrl } from '../utils/Utils';
+
+export interface ChoreTaskParameter {
+    Name: string;
+    Value: string;
+}
+
+export class ChoreTask extends TM1Object {
+    /** Abstraction of a Chore Task
+     * 
+     *    A Chore task always conistst of
+     *    - The step integer ID: it's order in the execution plan.
+     *      1 to n, where n is the last Process in the Chore
+     *    - The name of the process to execute
+     *    - The parameters for the process
+     */
+
+    private _step: number;
+    private _processName: string;
+    private _parameters: ChoreTaskParameter[];
+
+    constructor(step: number, processName: string, parameters: ChoreTaskParameter[]) {
+        /**
+         * :param step: step in the execution order of the Chores' processes. 1 to n, where n the number of processes
+         * :param process_name: name of the process
+         * :param parameters: list of dictionaries with 'Name' and 'Value' property:
+         *                     [{
+         *                         'Name': '..',
+         *                         'Value': '..'
+         *                     },
+         *                     ...
+         *                     ]            
+         */
+        super();
+        this._step = step;
+        this._processName = processName;
+        this._parameters = parameters;
+    }
+
+    public static fromDict(choreTaskAsDict: Record<string, any>, step?: number): ChoreTask {
+        let processName: string;
+        if ('Process' in choreTaskAsDict) {
+            processName = choreTaskAsDict['Process']['Name'];
+        } else {
+            // Extract "ProcessName" from "Processes('ProcessName')"
+            processName = choreTaskAsDict['Process@odata.bind'].slice(11, -2);
+        }
+
+        return new ChoreTask(
+            step !== undefined ? step : parseInt(choreTaskAsDict['Step']),
+            processName,
+            (choreTaskAsDict['Parameters'] || []).map((p: any) => ({
+                Name: p['Name'],
+                Value: p['Value']
+            }))
+        );
+    }
+
+    public get bodyAsDict(): Record<string, any> {
+        const bodyAsDict: Record<string, any> = {};
+        bodyAsDict['Process@odata.bind'] = formatUrl("Processes('{}')", this._processName);
+        bodyAsDict['Parameters'] = this._parameters;
+        return bodyAsDict;
+    }
+
+    public get step(): number {
+        return this._step;
+    }
+
+    public get processName(): string {
+        return this._processName;
+    }
+
+    public get parameters(): ChoreTaskParameter[] {
+        return this._parameters;
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.bodyAsDict);
+    }
+
+    public equals(other: ChoreTask): boolean {
+        return this.processName === other.processName && 
+               JSON.stringify(this.parameters) === JSON.stringify(other.parameters);
+    }
+
+    public notEquals(other: ChoreTask): boolean {
+        return this.processName !== other.processName || 
+               JSON.stringify(this._parameters) !== JSON.stringify(other.parameters);
+    }
+}

package/src/objects/Cube.ts

@@ -0,0 +1,125 @@
+import { TM1Object } from './TM1Object';
+import { Rules } from './Rules';
+
+export class Cube extends TM1Object {
+    /** Abstraction of a TM1 Cube
+     *        
+     */
+
+    private _name: string = '';
+    private _dimensions: string[] = [];
+    private _rules?: Rules;
+
+    constructor(name: string, dimensions: Iterable<string>, rules?: string | Rules) {
+        /**
+         * 
+         * :param name: name of the Cube
+         * :param dimensions: list of (existing) dimension names
+         * :param rules: instance of .Objects.Rules
+         */
+        super();
+        this._name = name;
+        this.dimensions = Array.from(dimensions);
+        this.rules = rules;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public get dimensions(): string[] {
+        return this._dimensions;
+    }
+
+    public set dimensions(value: string[]) {
+        this._dimensions = value;
+    }
+
+    public get hasRules(): boolean {
+        if (this._rules) {
+            return true;
+        }
+        return false;
+    }
+
+    public get rules(): Rules | undefined {
+        return this._rules;
+    }
+
+    public set rules(value: string | Rules | undefined) {
+        if (value === undefined || value === null) {
+            this._rules = undefined;
+        } else if (typeof value === 'string') {
+            this._rules = new Rules(value);
+        } else if (value instanceof Rules) {
+            this._rules = value;
+        } else {
+            throw new Error('value must be undefined or of type string or Rules');
+        }
+    }
+
+    public get skipcheck(): boolean {
+        if (this.hasRules && this.rules) {
+            return this.rules.skipcheck;
+        }
+        return false;
+    }
+
+    public get undefvals(): boolean {
+        if (this.hasRules && this.rules) {
+            return this.rules.undefvals;
+        }
+        return false;
+    }
+
+    public get feedstrings(): boolean {
+        if (this.hasRules && this.rules) {
+            return this.rules.feedstrings;
+        }
+        return false;
+    }
+
+    public static fromJSON(cubeAsJson: string): Cube {
+        /** Alternative constructor
+         *
+         * :param cube_as_json: user as JSON string
+         * :return: cube, an instance of this class
+         */
+        const cubeAsDict = JSON.parse(cubeAsJson);
+        return Cube.fromDict(cubeAsDict);
+    }
+
+    public static fromDict(cubeAsDict: any): Cube {
+        /** Alternative constructor
+         *
+         * :param cube_as_dict: user as dict
+         * :return: user, an instance of this class
+         */
+        return new Cube(
+            cubeAsDict.Name,
+            cubeAsDict.Dimensions.map((dimension: any) => dimension.Name),
+            cubeAsDict.Rules ? new Rules(cubeAsDict.Rules) : undefined
+        );
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.constructBody());
+    }
+
+    public get bodyAsDict(): any {
+        return this.constructBody();
+    }
+
+    private constructBody(): any {
+        const body: any = {
+            Name: this._name,
+            Dimensions: this._dimensions.map(dim => ({ Name: dim }))
+        };
+
+        if (this._rules) {
+            body.Rules = this._rules.text;
+        }
+
+        return body;
+    }
+}

package/src/objects/Dimension.ts

@@ -0,0 +1,107 @@
+import { TM1Object } from './TM1Object';
+import { Hierarchy } from './Hierarchy';
+
+export class Dimension extends TM1Object {
+    private _name: string;
+    private _hierarchies: Hierarchy[] = [];
+    private _attributes: Record<string, any> = {};
+
+    constructor(name: string, hierarchies?: Hierarchy[]) {
+        super();
+        this._name = name;
+        this._hierarchies = hierarchies ? [...hierarchies] : [];
+        this._attributes = { Caption: name };
+    }
+
+    public static fromJSON(dimensionAsJson: string): Dimension {
+        const dimensionAsDict = JSON.parse(dimensionAsJson);
+        return Dimension.fromDict(dimensionAsDict);
+    }
+
+    public static fromDict(dimensionAsDict: any): Dimension {
+        const hierarchies = dimensionAsDict.Hierarchies ? 
+            dimensionAsDict.Hierarchies.map((h: any) => 
+                Hierarchy.fromDict(h, dimensionAsDict.Name)) : [];
+        
+        return new Dimension(dimensionAsDict.Name, hierarchies);
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(value: string) {
+        for (const hierarchy of this._hierarchies) {
+            hierarchy.dimensionName = value;
+            if (hierarchy.name === this._name) {
+                hierarchy.name = value;
+            }
+        }
+        this._name = value;
+    }
+
+    public get uniqueName(): string {
+        return '[' + this._name + ']';
+    }
+
+    public get hierarchies(): Hierarchy[] {
+        return this._hierarchies;
+    }
+
+    public get hierarchyNames(): string[] {
+        return this._hierarchies.map(h => h.name);
+    }
+
+    public get defaultHierarchy(): Hierarchy | undefined {
+        return this._hierarchies[0];
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.constructBody());
+    }
+
+    public get bodyAsDict(): any {
+        return this.constructBody();
+    }
+
+    private constructBody(): any {
+        return {
+            Name: this._name,
+            Hierarchies: this._hierarchies.map(h => h.bodyAsDict)
+        };
+    }
+
+    public addHierarchy(hierarchy: Hierarchy): void {
+        hierarchy.dimensionName = this._name;
+        this._hierarchies.push(hierarchy);
+    }
+
+    public removeHierarchy(hierarchyName: string): boolean {
+        const index = this._hierarchies.findIndex(h => 
+            h.name.toLowerCase() === hierarchyName.toLowerCase());
+        
+        if (index !== -1) {
+            this._hierarchies.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    public getHierarchy(hierarchyName: string): Hierarchy | undefined {
+        return this._hierarchies.find(h => 
+            h.name.toLowerCase() === hierarchyName.toLowerCase());
+    }
+
+    public hasHierarchy(hierarchyName: string): boolean {
+        return this._hierarchies.some(h => 
+            h.name.toLowerCase() === hierarchyName.toLowerCase());
+    }
+
+    public *[Symbol.iterator](): Iterator<Hierarchy> {
+        yield* this._hierarchies;
+    }
+
+    public get length(): number {
+        return this._hierarchies.length;
+    }
+}

package/src/objects/Element.ts

@@ -0,0 +1,153 @@
+import { TM1Object } from './TM1Object';
+
+export enum ElementType {
+    NUMERIC = 1,
+    STRING = 2,
+    CONSOLIDATED = 3
+}
+
+export class Element extends TM1Object {
+    public static readonly ELEMENT_ATTRIBUTES_PREFIX = "}ElementAttributes_";
+
+    private _name: string;
+    private _uniqueName?: string;
+    private _index?: number;
+    private _elementType: ElementType;
+    private _attributes?: string[];
+
+    constructor(
+        name: string,
+        elementType: ElementType | string,
+        attributes?: string[],
+        uniqueName?: string,
+        index?: number
+    ) {
+        super();
+        this._name = name;
+        this._uniqueName = uniqueName;
+        this._index = index;
+        this._elementType = this.parseElementType(elementType);
+        this._attributes = attributes;
+    }
+
+    private parseElementType(elementType: ElementType | string): ElementType {
+        if (typeof elementType === 'string') {
+            const lowerType = elementType.toLowerCase().replace(/\s+/g, '');
+            switch (lowerType) {
+                case 'numeric':
+                    return ElementType.NUMERIC;
+                case 'string':
+                    return ElementType.STRING;
+                case 'consolidated':
+                    return ElementType.CONSOLIDATED;
+                default:
+                    throw new Error(`Invalid element type: '${elementType}'`);
+            }
+        }
+        return elementType;
+    }
+
+    public static fromDict(elementAsDict: any): Element {
+        return new Element(
+            elementAsDict.Name,
+            elementAsDict.Type,
+            elementAsDict.Attributes,
+            elementAsDict.UniqueName,
+            elementAsDict.Index
+        );
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(value: string) {
+        this._name = value;
+    }
+
+    public get uniqueName(): string | undefined {
+        return this._uniqueName;
+    }
+
+    public set uniqueName(value: string | undefined) {
+        this._uniqueName = value;
+    }
+
+    public get index(): number | undefined {
+        return this._index;
+    }
+
+    public set index(value: number | undefined) {
+        this._index = value;
+    }
+
+    public get elementType(): ElementType {
+        return this._elementType;
+    }
+
+    public set elementType(value: ElementType | string) {
+        this._elementType = this.parseElementType(value);
+    }
+
+    public get attributes(): string[] | undefined {
+        return this._attributes;
+    }
+
+    public set attributes(value: string[] | undefined) {
+        this._attributes = value;
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.constructBody());
+    }
+
+    public get bodyAsDict(): any {
+        return this.constructBody();
+    }
+
+    private constructBody(): any {
+        const body: any = {
+            Name: this._name,
+            Type: this.elementTypeToString(this._elementType)
+        };
+
+        if (this._uniqueName !== undefined) {
+            body.UniqueName = this._uniqueName;
+        }
+
+        if (this._index !== undefined) {
+            body.Index = this._index;
+        }
+
+        if (this._attributes !== undefined) {
+            body.Attributes = this._attributes;
+        }
+
+        return body;
+    }
+
+    private elementTypeToString(elementType: ElementType): string {
+        switch (elementType) {
+            case ElementType.NUMERIC:
+                return 'Numeric';
+            case ElementType.STRING:
+                return 'String';
+            case ElementType.CONSOLIDATED:
+                return 'Consolidated';
+            default:
+                return 'String';
+        }
+    }
+
+    public isNumeric(): boolean {
+        return this._elementType === ElementType.NUMERIC;
+    }
+
+    public isString(): boolean {
+        return this._elementType === ElementType.STRING;
+    }
+
+    public isConsolidated(): boolean {
+        return this._elementType === ElementType.CONSOLIDATED;
+    }
+}

package/src/objects/ElementAttribute.ts

@@ -0,0 +1,115 @@
+import { TM1Object } from './TM1Object';
+
+export enum ElementAttributeType {
+    NUMERIC = 1,
+    STRING = 2,
+    ALIAS = 3
+}
+
+export class ElementAttribute extends TM1Object {
+    private _name: string;
+    private _attributeType: ElementAttributeType;
+
+    constructor(name: string, attributeType: ElementAttributeType | string) {
+        super();
+        this._name = name;
+        this._attributeType = this.parseAttributeType(attributeType);
+    }
+
+    private parseAttributeType(attributeType: ElementAttributeType | string): ElementAttributeType {
+        if (typeof attributeType === 'string') {
+            const lowerType = attributeType.toLowerCase().replace(/\s+/g, '');
+            switch (lowerType) {
+                case 'numeric':
+                    return ElementAttributeType.NUMERIC;
+                case 'string':
+                    return ElementAttributeType.STRING;
+                case 'alias':
+                    return ElementAttributeType.ALIAS;
+                default:
+                    throw new Error(`Invalid attribute type: '${attributeType}'`);
+            }
+        }
+        return attributeType;
+    }
+
+    public static fromJSON(elementAttributeAsJson: string): ElementAttribute {
+        return ElementAttribute.fromDict(JSON.parse(elementAttributeAsJson));
+    }
+
+    public static fromDict(elementAttributeAsDict: any): ElementAttribute {
+        return new ElementAttribute(
+            elementAttributeAsDict.Name,
+            elementAttributeAsDict.Type
+        );
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(value: string) {
+        this._name = value;
+    }
+
+    public get attributeType(): string {
+        return this.attributeTypeToString(this._attributeType);
+    }
+
+    public set attributeType(value: ElementAttributeType | string) {
+        this._attributeType = this.parseAttributeType(value);
+    }
+
+    public get attributeTypeEnum(): ElementAttributeType {
+        return this._attributeType;
+    }
+
+    public get body(): string {
+        return JSON.stringify(this.bodyAsDict);
+    }
+
+    public get bodyAsDict(): any {
+        return {
+            Name: this._name,
+            Type: this.attributeType
+        };
+    }
+
+    private attributeTypeToString(attributeType: ElementAttributeType): string {
+        switch (attributeType) {
+            case ElementAttributeType.NUMERIC:
+                return 'Numeric';
+            case ElementAttributeType.STRING:
+                return 'String';
+            case ElementAttributeType.ALIAS:
+                return 'Alias';
+            default:
+                return 'String';
+        }
+    }
+
+    public isNumeric(): boolean {
+        return this._attributeType === ElementAttributeType.NUMERIC;
+    }
+
+    public isString(): boolean {
+        return this._attributeType === ElementAttributeType.STRING;
+    }
+
+    public isAlias(): boolean {
+        return this._attributeType === ElementAttributeType.ALIAS;
+    }
+
+    public equals(other: TM1Object): boolean {
+        if (other instanceof ElementAttribute) {
+            return this._name.toLowerCase().replace(/\s+/g, '') === 
+                   other._name.toLowerCase().replace(/\s+/g, '');
+        }
+        return false;
+    }
+
+    public equalsString(other: string): boolean {
+        return this._name.toLowerCase().replace(/\s+/g, '') === 
+               other.toLowerCase().replace(/\s+/g, '');
+    }
+}

package/src/objects/Git.ts

@@ -0,0 +1,86 @@
+import { GitCommit } from './GitCommit';
+import { GitRemote } from './GitRemote';
+
+export class Git {
+    /** Abstraction of Git object
+     */
+
+    private _url: string;
+    private _deployment: string;
+    private _force: boolean;
+    private _deployedCommit: GitCommit;
+    private _remote: GitRemote;
+    private _config?: Record<string, any>;
+
+    constructor(
+        url: string,
+        deployment: string,
+        force: boolean,
+        deployedCommit: GitCommit,
+        remote: GitRemote,
+        config?: Record<string, any>
+    ) {
+        /** Initialize GIT object
+         * :param url: file or http(s) path to GIT repository
+         * :param deployment: name of selected deployment group
+         * :param force: whether or not Git context was forced
+         * :param deployed_commit: GitCommit object of the currently deployed commit
+         * :param remote: GitRemote object of the current remote
+         * :param config: Dictionary containing git configuration parameters
+         */
+        this._url = url;
+        this._deployment = deployment;
+        this._force = force;
+        this._deployedCommit = deployedCommit;
+        this._remote = remote;
+        this._config = config;
+    }
+
+    public get url(): string {
+        return this._url;
+    }
+
+    public get force(): boolean {
+        return this._force;
+    }
+
+    public get config(): Record<string, any> | undefined {
+        return this._config;
+    }
+
+    public get deployment(): string {
+        return this._deployment;
+    }
+
+    public get deployedCommit(): GitCommit {
+        return this._deployedCommit;
+    }
+
+    public get remote(): GitRemote {
+        return this._remote;
+    }
+
+    public static fromDict(jsonResponse: any): Git {
+        const deployedCommit = new GitCommit(
+            jsonResponse["DeployedCommit"].ID,
+            jsonResponse["DeployedCommit"].Summary,
+            jsonResponse["DeployedCommit"].Author
+        );
+
+        const remote = new GitRemote(
+            jsonResponse["Remote"].Connected,
+            jsonResponse["Remote"].Branches,
+            jsonResponse["Remote"].Tags
+        );
+
+        const git = new Git(
+            jsonResponse["URL"],
+            jsonResponse["Deployment"],
+            jsonResponse["Deployment"],
+            deployedCommit,
+            remote
+        );
+
+        return git;
+    }
+}

package/src/objects/GitCommit.ts

@@ -0,0 +1,31 @@
+export class GitCommit {
+    /** Abstraction of Git Commit
+     */
+
+    private _commitId: string;
+    private _summary: string;
+    private _author: string;
+
+    constructor(commitId: string, summary: string, author: string) {
+        /** Initialize GitCommit object
+         * :param commit_id: id of the commit
+         * :param summary: commit message
+         * :param author: the author of the commit
+         */
+        this._commitId = commitId;
+        this._summary = summary;
+        this._author = author;
+    }
+
+    public get commitId(): string {
+        return this._commitId;
+    }
+
+    public get summary(): string {
+        return this._summary;
+    }
+
+    public get author(): string {
+        return this._author;
+    }
+}