tm1npm 1.0.0

package/src/objects/NativeView.ts

@@ -0,0 +1,268 @@
+import { View } from './View';
+import { ViewAxisSelection, ViewTitleSelection } from './Axis';
+import { Subset, AnonymousSubset } from './Subset';
+import { caseAndSpaceInsensitiveEquals, readObjectNameFromUrl } from '../utils/Utils';
+
+export class NativeView extends View {
+    /** Abstraction of TM1 NativeView (classic cube view)
+     *
+     *     :Notes:
+     *         Complete, functional and tested
+     */
+
+    private _suppressEmptyColumns: boolean;
+    private _suppressEmptyRows: boolean;
+    private _formatString: string;
+    private _titles: ViewTitleSelection[];
+    private _columns: ViewAxisSelection[];
+    private _rows: ViewAxisSelection[];
+
+    constructor(
+        cubeName: string,
+        viewName: string,
+        suppressEmptyColumns: boolean = false,
+        suppressEmptyRows: boolean = false,
+        formatString: string = "0.#########",
+        titles?: Iterable<ViewTitleSelection>,
+        columns?: Iterable<ViewAxisSelection>,
+        rows?: Iterable<ViewAxisSelection>
+    ) {
+        super(cubeName, viewName);
+        this._suppressEmptyColumns = suppressEmptyColumns;
+        this._suppressEmptyRows = suppressEmptyRows;
+        this._formatString = formatString;
+        this._titles = titles ? Array.from(titles) : [];
+        this._columns = columns ? Array.from(columns) : [];
+        this._rows = rows ? Array.from(rows) : [];
+    }
+
+    public get body(): string {
+        return this.constructBody();
+    }
+
+    public get rows(): ViewAxisSelection[] {
+        return this._rows;
+    }
+
+    public get columns(): ViewAxisSelection[] {
+        return this._columns;
+    }
+
+    public get titles(): ViewTitleSelection[] {
+        return this._titles;
+    }
+
+    public get mdx(): string {
+        return this.asMDX;
+    }
+
+    public get MDX(): string {
+        return this.asMDX;
+    }
+
+    public get asMDX(): string {
+        /** Build a valid MDX Query from an Existing cubeview. 
+         * Takes Zero suppression into account. 
+         * Throws an Exception when no elements are place on the columns.
+         * Subsets are referenced in the result-MDX through the TM1SubsetToSet Function
+         *
+         * :return: String, the MDX Query
+         */
+        if (!this.columns || this.columns.length === 0) {
+            throw new Error("Column selection must not be empty");
+        }
+
+        // Basic MDX construction - this would need a full MDX builder implementation
+        let mdx = "SELECT ";
+        
+        // Build column axis
+        const columnSets: string[] = [];
+        for (const columnSelection of this.columns) {
+            const subset = columnSelection.subset;
+            if (subset instanceof AnonymousSubset) {
+                if (subset.expression) {
+                    columnSets.push(subset.expression);
+                } else {
+                    const members = subset.elements.map(e => `[${subset.dimensionName}].[${e}]`);
+                    columnSets.push(`{${members.join(', ')}}`);
+                }
+            } else {
+                columnSets.push(`TM1SubsetToSet([${subset.dimensionName}], "${subset.name}")`);
+            }
+        }
+        
+        if (this._suppressEmptyColumns) {
+            mdx += `NON EMPTY (${columnSets.join(' * ')}) ON COLUMNS`;
+        } else {
+            mdx += `(${columnSets.join(' * ')}) ON COLUMNS`;
+        }
+
+        // Build row axis if exists
+        if (this.rows && this.rows.length > 0) {
+            const rowSets: string[] = [];
+            for (const rowSelection of this.rows) {
+                const subset = rowSelection.subset;
+                if (subset instanceof AnonymousSubset) {
+                    if (subset.expression) {
+                        rowSets.push(subset.expression);
+                    } else {
+                        const members = subset.elements.map(e => `[${subset.dimensionName}].[${e}]`);
+                        rowSets.push(`{${members.join(', ')}}`);
+                    }
+                } else {
+                    rowSets.push(`TM1SubsetToSet([${subset.dimensionName}], "${subset.name}")`);
+                }
+            }
+            
+            if (this._suppressEmptyRows) {
+                mdx += `, NON EMPTY (${rowSets.join(' * ')}) ON ROWS`;
+            } else {
+                mdx += `, (${rowSets.join(' * ')}) ON ROWS`;
+            }
+        }
+
+        mdx += ` FROM [${this.cube}]`;
+
+        // Add WHERE clause for titles
+        if (this.titles && this.titles.length > 0) {
+            const titleSelections: string[] = [];
+            for (const title of this.titles) {
+                if (title.selected && title.selected.length > 0) {
+                    titleSelections.push(`[${title.dimensionName}].[${title.selected[0]}]`);
+                }
+            }
+            if (titleSelections.length > 0) {
+                mdx += ` WHERE (${titleSelections.join(', ')})`;
+            }
+        }
+
+        return mdx;
+    }
+
+    public get suppressEmptyColumns(): boolean {
+        return this._suppressEmptyColumns;
+    }
+
+    public set suppressEmptyColumns(value: boolean) {
+        this._suppressEmptyColumns = value;
+    }
+
+    public get suppressEmptyRows(): boolean {
+        return this._suppressEmptyRows;
+    }
+
+    public set suppressEmptyRows(value: boolean) {
+        this._suppressEmptyRows = value;
+    }
+
+    public get formatString(): string {
+        return this._formatString;
+    }
+
+    public set formatString(value: string) {
+        this._formatString = value;
+    }
+
+    public addTitle(title: ViewTitleSelection): void {
+        this._titles.push(title);
+    }
+
+    public addColumn(column: ViewAxisSelection): void {
+        this._columns.push(column);
+    }
+
+    public addRow(row: ViewAxisSelection): void {
+        this._rows.push(row);
+    }
+
+    public removeTitle(dimensionName: string): boolean {
+        const index = this._titles.findIndex(t => 
+            caseAndSpaceInsensitiveEquals(t.dimensionName, dimensionName));
+        if (index !== -1) {
+            this._titles.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    public removeColumn(dimensionName: string): boolean {
+        const index = this._columns.findIndex(c => 
+            caseAndSpaceInsensitiveEquals(c.subset.dimensionName, dimensionName));
+        if (index !== -1) {
+            this._columns.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    public removeRow(dimensionName: string): boolean {
+        const index = this._rows.findIndex(r => 
+            caseAndSpaceInsensitiveEquals(r.subset.dimensionName, dimensionName));
+        if (index !== -1) {
+            this._rows.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    public static fromJSON(viewAsJson: string, cubeName: string): NativeView {
+        const viewAsDict = JSON.parse(viewAsJson);
+        return NativeView.fromDict(viewAsDict, cubeName);
+    }
+
+    public static fromDict(viewAsDict: any, cubeName: string): NativeView {
+        const view = new NativeView(
+            cubeName,
+            viewAsDict.Name,
+            viewAsDict.SuppressEmptyColumns || false,
+            viewAsDict.SuppressEmptyRows || false,
+            viewAsDict.FormatString || "0.#########"
+        );
+
+        // Parse titles
+        if (viewAsDict.Titles) {
+            for (const titleDict of viewAsDict.Titles) {
+                const title = ViewTitleSelection.fromDict(titleDict);
+                view.addTitle(title);
+            }
+        }
+
+        // Parse columns
+        if (viewAsDict.Columns) {
+            for (const columnDict of viewAsDict.Columns) {
+                const column = ViewAxisSelection.fromDict(columnDict);
+                view.addColumn(column);
+            }
+        }
+
+        // Parse rows
+        if (viewAsDict.Rows) {
+            for (const rowDict of viewAsDict.Rows) {
+                const row = ViewAxisSelection.fromDict(rowDict);
+                view.addRow(row);
+            }
+        }
+
+        return view;
+    }
+
+    private constructBody(): string {
+        const viewAsDict: any = {};
+        viewAsDict['@odata.type'] = 'ibm.tm1.api.v1.NativeView';
+        viewAsDict['Name'] = this._name;
+        viewAsDict['SuppressEmptyColumns'] = this._suppressEmptyColumns;
+        viewAsDict['SuppressEmptyRows'] = this._suppressEmptyRows;
+        viewAsDict['FormatString'] = this._formatString;
+
+        // Add titles
+        viewAsDict['Titles'] = this._titles.map(title => title.bodyAsDict);
+        
+        // Add columns
+        viewAsDict['Columns'] = this._columns.map(column => column.bodyAsDict);
+        
+        // Add rows
+        viewAsDict['Rows'] = this._rows.map(row => row.bodyAsDict);
+
+        return JSON.stringify(viewAsDict);
+    }
+}

package/src/objects/Process.ts

@@ -0,0 +1,320 @@
+import { TM1Object } from './TM1Object';
+import { verifyVersion } from '../utils/Utils';
+
+export class Process extends TM1Object {
+    /** Abstraction of a TM1 Process.
+     *
+     *     IMPORTANT. doesn't work with Processes that were generated through the Wizard
+     */
+
+    /** the auto_generated_string code is required to be in all code-tabs. */
+    public static readonly BEGIN_GENERATED_STATEMENTS = "#****Begin: Generated Statements***";
+    public static readonly END_GENERATED_STATEMENTS = "#****End: Generated Statements****";
+    public static readonly AUTO_GENERATED_STATEMENTS = `${Process.BEGIN_GENERATED_STATEMENTS}\r\n${Process.END_GENERATED_STATEMENTS}\r\n`;
+    public static readonly MAX_STATEMENTS = 16_380;
+    public static readonly MAX_STATEMENTS_POST_11_8_015 = 100_000;
+
+    private _name: string;
+    private _hasSecurityAccess: boolean;
+    private _uiData: string;
+    private _parameters: any[];
+    private _variables: any[];
+    private _variablesUiData: any[];
+    private _prologProcedure: string;
+    private _metadataProcedure: string;
+    private _dataProcedure: string;
+    private _epilogProcedure: string;
+    private _datasourceType: string;
+    private _datasourceAsciiDecimalSeparator: string;
+    private _datasourceAsciiDelimiterChar: string;
+    private _datasourceAsciiDelimiterType: string;
+    private _datasourceAsciiHeaderRecords: number;
+    private _datasourceAsciiQuoteCharacter: string;
+    private _datasourceAsciiThousandSeparator: string;
+    private _datasourceDataSourceNameForClient: string;
+    private _datasourceDataSourceNameForServer: string;
+    private _datasourcePassword: string;
+    private _datasourceUserName: string;
+    private _datasourceQuery: string;
+    private _datasourceUsesUnicode: boolean;
+    private _datasourceView: string;
+    private _datasourceSubset: string;
+    private _datasourceJsonRootPointer: string;
+    private _datasourceJsonVariableMapping: string;
+
+    public static maxStatements(version: string): number {
+        if (verifyVersion("11.8.015", version)) {
+            return Process.MAX_STATEMENTS_POST_11_8_015;
+        }
+        return Process.MAX_STATEMENTS;
+    }
+
+    public static addGeneratedStringToCode(code: string): string {
+        const pattern = /#\*\*\*\*Begin: Generated Statements[\s\S]*#\*\*\*\*End: Generated Statements\*\*\*\*/;
+        if (pattern.test(code)) {
+            return code;
+        } else {
+            return Process.AUTO_GENERATED_STATEMENTS + code;
+        }
+    }
+
+    constructor(
+        name: string,
+        hasSecurityAccess: boolean = false,
+        uiData: string = "CubeAction=1511\fDataAction=1503\fCubeLogChanges=0\f",
+        parameters?: Iterable<any>,
+        variables?: Iterable<any>,
+        variablesUiData?: Iterable<any>,
+        prologProcedure: string = '',
+        metadataProcedure: string = '',
+        dataProcedure: string = '',
+        epilogProcedure: string = '',
+        datasourceType: string = 'None',
+        datasourceAsciiDecimalSeparator: string = '.',
+        datasourceAsciiDelimiterChar: string = ';',
+        datasourceAsciiDelimiterType: string = 'Character',
+        datasourceAsciiHeaderRecords: number = 1,
+        datasourceAsciiQuoteCharacter: string = '',
+        datasourceAsciiThousandSeparator: string = ',',
+        datasourceDataSourceNameForClient: string = '',
+        datasourceDataSourceNameForServer: string = '',
+        datasourcePassword: string = '',
+        datasourceUserName: string = '',
+        datasourceQuery: string = '',
+        datasourceUsesUnicode: boolean = true,
+        datasourceView: string = '',
+        datasourceSubset: string = '',
+        datasourceJsonRootPointer: string = '',
+        datasourceJsonVariableMapping: string = ''
+    ) {
+        /** Default constructor
+         *
+         * :param name: name of the process - mandatory
+         * :param has_security_access:
+         * :param ui_data:
+         * :param parameters:
+         * :param variables:
+         * :param variables_ui_data:
+         * :param prolog_procedure:
+         * :param metadata_procedure:
+         * :param data_procedure:
+         * :param epilog_procedure:
+         * :param datasource_type:
+         * :param datasource_ascii_decimal_separator:
+         * :param datasource_ascii_delimiter_char:
+         * :param datasource_ascii_delimiter_type:
+         * :param datasource_ascii_header_records:
+         * :param datasource_ascii_quote_character:
+         * :param datasource_ascii_thousand_separator:
+         * :param datasource_data_source_name_for_client:
+         * :param datasource_data_source_name_for_server:
+         * :param datasource_password:
+         * :param datasource_user_name:
+         * :param datasource_query:
+         * :param datasource_uses_unicode:
+         * :param datasource_view:
+         * :param datasource_subset:
+         * :param datasource_json_root_pointer:
+         * :param datasource_json_variable_mapping:
+         */
+        super();
+        this._name = name;
+        this._hasSecurityAccess = hasSecurityAccess;
+        this._uiData = uiData;
+        this._parameters = parameters ? Array.from(parameters) : [];
+        this._variables = variables ? Array.from(variables) : [];
+        this._variablesUiData = variablesUiData ? Array.from(variablesUiData) : [];
+        this._prologProcedure = prologProcedure;
+        this._metadataProcedure = metadataProcedure;
+        this._dataProcedure = dataProcedure;
+        this._epilogProcedure = epilogProcedure;
+        this._datasourceType = datasourceType;
+        this._datasourceAsciiDecimalSeparator = datasourceAsciiDecimalSeparator;
+        this._datasourceAsciiDelimiterChar = datasourceAsciiDelimiterChar;
+        this._datasourceAsciiDelimiterType = datasourceAsciiDelimiterType;
+        this._datasourceAsciiHeaderRecords = datasourceAsciiHeaderRecords;
+        this._datasourceAsciiQuoteCharacter = datasourceAsciiQuoteCharacter;
+        this._datasourceAsciiThousandSeparator = datasourceAsciiThousandSeparator;
+        this._datasourceDataSourceNameForClient = datasourceDataSourceNameForClient;
+        this._datasourceDataSourceNameForServer = datasourceDataSourceNameForServer;
+        this._datasourcePassword = datasourcePassword;
+        this._datasourceUserName = datasourceUserName;
+        this._datasourceQuery = datasourceQuery;
+        this._datasourceUsesUnicode = datasourceUsesUnicode;
+        this._datasourceView = datasourceView;
+        this._datasourceSubset = datasourceSubset;
+        this._datasourceJsonRootPointer = datasourceJsonRootPointer;
+        this._datasourceJsonVariableMapping = datasourceJsonVariableMapping;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(value: string) {
+        this._name = value;
+    }
+
+    public get hasSecurityAccess(): boolean {
+        return this._hasSecurityAccess;
+    }
+
+    public set hasSecurityAccess(value: boolean) {
+        this._hasSecurityAccess = value;
+    }
+
+    public get uiData(): string {
+        return this._uiData;
+    }
+
+    public set uiData(value: string) {
+        this._uiData = value;
+    }
+
+    public get parameters(): any[] {
+        return this._parameters;
+    }
+
+    public set parameters(value: any[]) {
+        this._parameters = value;
+    }
+
+    public get variables(): any[] {
+        return this._variables;
+    }
+
+    public set variables(value: any[]) {
+        this._variables = value;
+    }
+
+    public get variablesUiData(): any[] {
+        return this._variablesUiData;
+    }
+
+    public set variablesUiData(value: any[]) {
+        this._variablesUiData = value;
+    }
+
+    public get prologProcedure(): string {
+        return this._prologProcedure;
+    }
+
+    public set prologProcedure(value: string) {
+        this._prologProcedure = Process.addGeneratedStringToCode(value);
+    }
+
+    public get metadataProcedure(): string {
+        return this._metadataProcedure;
+    }
+
+    public set metadataProcedure(value: string) {
+        this._metadataProcedure = Process.addGeneratedStringToCode(value);
+    }
+
+    public get dataProcedure(): string {
+        return this._dataProcedure;
+    }
+
+    public set dataProcedure(value: string) {
+        this._dataProcedure = Process.addGeneratedStringToCode(value);
+    }
+
+    public get epilogProcedure(): string {
+        return this._epilogProcedure;
+    }
+
+    public set epilogProcedure(value: string) {
+        this._epilogProcedure = Process.addGeneratedStringToCode(value);
+    }
+
+    public get datasourceType(): string {
+        return this._datasourceType;
+    }
+
+    public set datasourceType(value: string) {
+        this._datasourceType = value;
+    }
+
+    public static fromDict(processAsDict: any): Process {
+        /** Alternative constructor
+         *
+         * :param process_as_dict: process as dict
+         * :return: process, an instance of this class
+         */
+        return new Process(
+            processAsDict.Name,
+            processAsDict.HasSecurityAccess || false,
+            processAsDict.UIData || "CubeAction=1511\fDataAction=1503\fCubeLogChanges=0\f",
+            processAsDict.Parameters || [],
+            processAsDict.Variables || [],
+            processAsDict.VariablesUIData || [],
+            processAsDict.PrologProcedure || '',
+            processAsDict.MetadataProcedure || '',
+            processAsDict.DataProcedure || '',
+            processAsDict.EpilogProcedure || '',
+            processAsDict.DataSource?.Type || 'None',
+            processAsDict.DataSource?.AsciiDecimalSeparator || '.',
+            processAsDict.DataSource?.AsciiDelimiterChar || ';',
+            processAsDict.DataSource?.AsciiDelimiterType || 'Character',
+            processAsDict.DataSource?.AsciiHeaderRecords || 1,
+            processAsDict.DataSource?.AsciiQuoteCharacter || '',
+            processAsDict.DataSource?.AsciiThousandSeparator || ',',
+            processAsDict.DataSource?.DataSourceNameForClient || '',
+            processAsDict.DataSource?.DataSourceNameForServer || '',
+            processAsDict.DataSource?.Password || '',
+            processAsDict.DataSource?.UserName || '',
+            processAsDict.DataSource?.Query || '',
+            processAsDict.DataSource?.UsesUnicode !== false,
+            processAsDict.DataSource?.View || '',
+            processAsDict.DataSource?.Subset || '',
+            processAsDict.DataSource?.JsonRootPointer || '',
+            processAsDict.DataSource?.JsonVariableMapping || ''
+        );
+    }
+
+    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,
+            HasSecurityAccess: this._hasSecurityAccess,
+            UIData: this._uiData,
+            Parameters: this._parameters,
+            Variables: this._variables,
+            VariablesUIData: this._variablesUiData,
+            PrologProcedure: this._prologProcedure,
+            MetadataProcedure: this._metadataProcedure,
+            DataProcedure: this._dataProcedure,
+            EpilogProcedure: this._epilogProcedure
+        };
+
+        // Add DataSource information
+        body.DataSource = {
+            Type: this._datasourceType,
+            AsciiDecimalSeparator: this._datasourceAsciiDecimalSeparator,
+            AsciiDelimiterChar: this._datasourceAsciiDelimiterChar,
+            AsciiDelimiterType: this._datasourceAsciiDelimiterType,
+            AsciiHeaderRecords: this._datasourceAsciiHeaderRecords,
+            AsciiQuoteCharacter: this._datasourceAsciiQuoteCharacter,
+            AsciiThousandSeparator: this._datasourceAsciiThousandSeparator,
+            DataSourceNameForClient: this._datasourceDataSourceNameForClient,
+            DataSourceNameForServer: this._datasourceDataSourceNameForServer,
+            Password: this._datasourcePassword,
+            UserName: this._datasourceUserName,
+            Query: this._datasourceQuery,
+            UsesUnicode: this._datasourceUsesUnicode,
+            View: this._datasourceView,
+            Subset: this._datasourceSubset,
+            JsonRootPointer: this._datasourceJsonRootPointer,
+            JsonVariableMapping: this._datasourceJsonVariableMapping
+        };
+
+        return body;
+    }
+}