tm1npm 1.0.0

package/src/objects/GitPlan.ts

@@ -0,0 +1,121 @@
+import { GitCommit } from './GitCommit';
+
+export class GitPlan {
+    /** Base GitPlan abstraction
+     */
+
+    private _planId: string;
+    private _branch: string;
+    private _force: boolean;
+
+    constructor(planId: string, branch: string, force: boolean) {
+        /** Initialize GitPlan object
+         * :param plan_id: id of the Plan
+         * :param branch: current branch
+         * :param force: force git context reset
+         */
+        this._planId = planId;
+        this._branch = branch;
+        this._force = force;
+    }
+
+    public get planId(): string {
+        return this._planId;
+    }
+
+    public get branch(): string {
+        return this._branch;
+    }
+
+    public get force(): boolean {
+        return this._force;
+    }
+}
+
+
+export class GitPushPlan extends GitPlan {
+    /** GitPushPlan abstraction based on GitPlan
+     */
+
+    private _newBranch: string;
+    private _newCommit: GitCommit;
+    private _parentCommit: GitCommit;
+    private _sourceFiles: string[];
+
+    constructor(
+        planId: string,
+        branch: string,
+        force: boolean,
+        newBranch: string,
+        newCommit: GitCommit,
+        parentCommit: GitCommit,
+        sourceFiles: string[]
+    ) {
+        /** Initialize GitPushPlan object
+         * :param plan_id: id of the PushPlan
+         * :param branch: current branch to base the pushplan on
+         * :param force: force git context reset
+         * :param new_branch: the new branch that will be pushed to
+         * :param new_commit: GitCommit of the new commit
+         * :param parent_commit: The current commit in the branch
+         * :param source_files: list of included files in the push
+         */
+        super(planId, branch, force);
+        this._newBranch = newBranch;
+        this._newCommit = newCommit;
+        this._parentCommit = parentCommit;
+        this._sourceFiles = sourceFiles;
+    }
+
+    public get newBranch(): string {
+        return this._newBranch;
+    }
+
+    public get newCommit(): GitCommit {
+        return this._newCommit;
+    }
+
+    public get parentCommit(): GitCommit {
+        return this._parentCommit;
+    }
+
+    public get sourceFiles(): string[] {
+        return this._sourceFiles;
+    }
+}
+
+
+export class GitPullPlan extends GitPlan {
+    /** GitPushPlan abstraction based on GitPlan
+     */
+
+    private _commit: GitCommit;
+    private _operations: string[];
+
+    constructor(
+        planId: string,
+        branch: string,
+        force: boolean,
+        commit: GitCommit,
+        operations: string[]
+    ) {
+        /** Initialize GitPushPlan object
+         * :param plan_id: id of the PullPlan
+         * :param branch: current branch to base the pullplan on
+         * :param force: force git context reset
+         * :param commit: GitCommit of the commit to pull
+         * :param operations: list of changes made upon pulling
+         */
+        super(planId, branch, force);
+        this._commit = commit;
+        this._operations = operations;
+    }
+
+    public get commit(): GitCommit {
+        return this._commit;
+    }
+
+    public get operations(): string[] {
+        return this._operations;
+    }
+}

package/src/objects/GitRemote.ts

@@ -0,0 +1,31 @@
+export class GitRemote {
+    /** Abstraction of GitRemote
+     */
+
+    private _connected: boolean;
+    private _branches: string[];
+    private _tags: string[];
+
+    constructor(connected: boolean, branches: string[], tags: string[]) {
+        /** Initialize GitRemote object
+         * :param connected: is Git connected to remote
+         * :param branches: list of remote branches
+         * :param tags: list of remote tags
+         */
+        this._connected = connected;
+        this._branches = branches;
+        this._tags = tags;
+    }
+
+    public get connected(): boolean {
+        return this._connected;
+    }
+
+    public get branches(): string[] {
+        return this._branches;
+    }
+
+    public get tags(): string[] {
+        return this._tags;
+    }
+}

package/src/objects/Hierarchy.ts

@@ -0,0 +1,229 @@
+import { TM1Object } from './TM1Object';
+import { Element } from './Element';
+import { ElementAttribute } from './ElementAttribute';
+
+export class Hierarchy extends TM1Object {
+    private _name: string;
+    private _dimensionName: string;
+    private _elements: Map<string, Element> = new Map();
+    private _elementAttributes: ElementAttribute[] = [];
+    private _edges: Map<string, number> = new Map();
+    private _subsets: string[] = [];
+    private _balanced: boolean = false;
+    private _defaultMember?: string;
+
+    constructor(
+        name: string,
+        dimensionName: string,
+        elements?: Element[],
+        elementAttributes?: ElementAttribute[],
+        edges?: Map<string, number>,
+        subsets?: string[],
+        structure?: number,
+        defaultMember?: string
+    ) {
+        super();
+        this._name = name;
+        this._dimensionName = dimensionName;
+        
+        if (elements) {
+            for (const elem of elements) {
+                this._elements.set(elem.name.toLowerCase(), elem);
+            }
+        }
+        
+        this._elementAttributes = elementAttributes ? [...elementAttributes] : [];
+        this._edges = edges ? new Map(edges) : new Map();
+        this._subsets = subsets ? [...subsets] : [];
+        this._balanced = structure !== undefined ? structure === 0 : false;
+        this._defaultMember = defaultMember;
+    }
+
+    public static fromDict(hierarchyAsDict: any, dimensionName: string): Hierarchy {
+        const elements = hierarchyAsDict.Elements ? 
+            hierarchyAsDict.Elements.map((e: any) => Element.fromDict(e)) : [];
+        
+        const elementAttributes = hierarchyAsDict.ElementAttributes ? 
+            hierarchyAsDict.ElementAttributes.map((ea: any) => ElementAttribute.fromDict(ea)) : [];
+        
+        const edges = new Map<string, number>();
+        if (hierarchyAsDict.Edges) {
+            for (const edge of hierarchyAsDict.Edges) {
+                const key = `${edge.ParentName}:${edge.ComponentName}`;
+                edges.set(key, edge.Weight || 1);
+            }
+        }
+
+        return new Hierarchy(
+            hierarchyAsDict.Name,
+            dimensionName,
+            elements,
+            elementAttributes,
+            edges,
+            hierarchyAsDict.Subsets,
+            hierarchyAsDict.Structure,
+            hierarchyAsDict.DefaultMember
+        );
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(value: string) {
+        this._name = value;
+    }
+
+    public get dimensionName(): string {
+        return this._dimensionName;
+    }
+
+    public set dimensionName(value: string) {
+        this._dimensionName = value;
+    }
+
+    public get uniqueName(): string {
+        return `[${this._dimensionName}].[${this._name}]`;
+    }
+
+    public get elements(): Element[] {
+        return Array.from(this._elements.values());
+    }
+
+    public get elementNames(): string[] {
+        return Array.from(this._elements.keys());
+    }
+
+    public get elementAttributes(): ElementAttribute[] {
+        return this._elementAttributes;
+    }
+
+    public get edges(): Map<string, number> {
+        return this._edges;
+    }
+
+    public get subsets(): string[] {
+        return this._subsets;
+    }
+
+    public get balanced(): boolean {
+        return this._balanced;
+    }
+
+    public set balanced(value: boolean) {
+        this._balanced = value;
+    }
+
+    public get defaultMember(): string | undefined {
+        return this._defaultMember;
+    }
+
+    public set defaultMember(value: string | undefined) {
+        this._defaultMember = 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,
+            Elements: this.elements.map(e => e.bodyAsDict),
+            ElementAttributes: this._elementAttributes.map(ea => ea.bodyAsDict),
+            Edges: this.constructEdges(),
+            Subsets: this._subsets
+        };
+
+        if (this._defaultMember !== undefined) {
+            body.DefaultMember = this._defaultMember;
+        }
+
+        body.Structure = this._balanced ? 0 : 1;
+
+        return body;
+    }
+
+    private constructEdges(): any[] {
+        const edges: any[] = [];
+        
+        for (const [key, weight] of this._edges) {
+            const [parentName, componentName] = key.split(':');
+            edges.push({
+                ParentName: parentName,
+                ComponentName: componentName,
+                Weight: weight
+            });
+        }
+        
+        return edges;
+    }
+
+    public addElement(element: Element): void {
+        this._elements.set(element.name.toLowerCase(), element);
+    }
+
+    public removeElement(elementName: string): boolean {
+        return this._elements.delete(elementName.toLowerCase());
+    }
+
+    public getElement(elementName: string): Element | undefined {
+        return this._elements.get(elementName.toLowerCase());
+    }
+
+    public hasElement(elementName: string): boolean {
+        return this._elements.has(elementName.toLowerCase());
+    }
+
+    public addEdge(parentName: string, componentName: string, weight: number = 1): void {
+        const key = `${parentName}:${componentName}`;
+        this._edges.set(key, weight);
+    }
+
+    public removeEdge(parentName: string, componentName: string): boolean {
+        const key = `${parentName}:${componentName}`;
+        return this._edges.delete(key);
+    }
+
+    public getEdgeWeight(parentName: string, componentName: string): number | undefined {
+        const key = `${parentName}:${componentName}`;
+        return this._edges.get(key);
+    }
+
+    public addElementAttribute(elementAttribute: ElementAttribute): void {
+        this._elementAttributes.push(elementAttribute);
+    }
+
+    public removeElementAttribute(attributeName: string): boolean {
+        const index = this._elementAttributes.findIndex(ea => 
+            ea.name.toLowerCase() === attributeName.toLowerCase());
+        
+        if (index !== -1) {
+            this._elementAttributes.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    public getElementAttribute(attributeName: string): ElementAttribute | undefined {
+        return this._elementAttributes.find(ea => 
+            ea.name.toLowerCase() === attributeName.toLowerCase());
+    }
+
+    public hasElementAttribute(attributeName: string): boolean {
+        return this._elementAttributes.some(ea => 
+            ea.name.toLowerCase() === attributeName.toLowerCase());
+    }
+
+    public *[Symbol.iterator](): Iterator<Element> {
+        yield* this._elements.values();
+    }
+
+    public get length(): number {
+        return this._elements.size;
+    }
+}

package/src/objects/MDXView.ts

@@ -0,0 +1,91 @@
+import { View } from './View';
+import { caseAndSpaceInsensitiveEquals } from '../utils/Utils';
+
+export class MDXView extends View {
+    /** Abstraction on TM1 MDX view
+     *
+     *     IMPORTANT. MDXViews can't be seen through the old TM1 clients (Archict, Perspectives). They do exist though!
+     */
+
+    private _mdx: string;
+
+    constructor(cubeName: string, viewName: string, MDX: string) {
+        super(cubeName, viewName);
+        this._mdx = MDX;
+    }
+
+    public get mdx(): string {
+        return this._mdx;
+    }
+
+    public set mdx(value: string) {
+        this._mdx = value;
+    }
+
+    public get MDX(): string {
+        return this._mdx;
+    }
+
+    public set MDX(value: string) {
+        this._mdx = value;
+    }
+
+    public get body(): string {
+        return this.constructBody();
+    }
+
+    public substituteTitle(dimension: string, hierarchy: string, element: string): void {
+        /** dimension and hierarchy name are space sensitive!
+         *
+         * :param dimension:
+         * :param hierarchy:
+         * :param element:
+         * :return:
+         */
+        let pattern = new RegExp(`\\[${dimension}\\]\\.\\[${hierarchy}\\]\\.\\[(.*?)\\]`, 'gi');
+        let findings = this._mdx.match(pattern);
+
+        if (findings) {
+            this._mdx = this._mdx.replace(
+                pattern,
+                `[${dimension}].[${hierarchy}].[${element}]`
+            );
+            return;
+        }
+
+        if (!hierarchy || caseAndSpaceInsensitiveEquals(dimension, hierarchy)) {
+            pattern = new RegExp(`\\[${dimension}\\]\\.\\[(.*?)\\]`, 'gi');
+            findings = this._mdx.match(pattern);
+            if (findings) {
+                this._mdx = this._mdx.replace(
+                    pattern,
+                    `[${dimension}].[${element}]`
+                );
+                return;
+            }
+        }
+
+        throw new Error(`No selection in title with dimension: '${dimension}' and hierarchy: '${hierarchy}'`);
+    }
+
+    public static fromJSON(viewAsJson: string, cubeName?: string): MDXView {
+        const viewAsDict = JSON.parse(viewAsJson);
+        return MDXView.fromDict(viewAsDict, cubeName);
+    }
+
+    public static fromDict(viewAsDict: any, cubeName?: string): MDXView {
+        return new MDXView(
+            viewAsDict.Cube?.Name || cubeName!,
+            viewAsDict.Name,
+            viewAsDict.MDX
+        );
+    }
+
+    private constructBody(): string {
+        const mdxViewAsDict: any = {};
+        mdxViewAsDict['@odata.type'] = 'ibm.tm1.api.v1.MDXView';
+        mdxViewAsDict['Name'] = this._name;
+        mdxViewAsDict['MDX'] = this._mdx;
+        return JSON.stringify(mdxViewAsDict);
+    }
+}