tm1npm 1.0.0

package/src/services/MessageLogService.ts

@@ -0,0 +1,211 @@
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { Process } from '../objects/Process';
+import { ProcessService } from './ProcessService';
+import { 
+    verifyVersion, 
+    deprecatedInVersion, 
+    odataTrackChangesHeader, 
+    requireOpsAdmin,
+    requireDataAdmin,
+    formatUrl,
+    CaseAndSpaceInsensitiveDict,
+    CaseAndSpaceInsensitiveSet,
+    utcLocalizeTime
+} from '../utils/Utils';
+
+export class MessageLogService extends ObjectService {
+
+    private lastDeltaRequest?: string;
+
+    constructor(rest: RestService) {
+        super(rest);
+        if (verifyVersion("12.0.0", rest.version || "11.0.0")) {
+            // warn only due to use in Monitoring Service
+            console.warn("Message Logs are not available in this version of TM1, removed as of 12.0.0");
+        }
+        this.lastDeltaRequest = undefined;
+    }
+
+    @deprecatedInVersion("12.0.0")
+    public async initializeDeltaRequests(filter?: string): Promise<void> {
+        let url = "/TailMessageLog()";
+        if (filter) {
+            url += `?$filter=${filter}`;
+        }
+        const response = await this.rest.get(url);
+        // Read the next delta-request-url from the response
+        const responseText = typeof response.data === 'string' ? response.data : JSON.stringify(response.data);
+        this.lastDeltaRequest = responseText.substring(
+            responseText.lastIndexOf("MessageLogEntries/!delta('"),
+            responseText.length - 2
+        );
+    }
+
+    @deprecatedInVersion("12.0.0")
+    public async executeDeltaRequest(): Promise<any[]> {
+        if (!this.lastDeltaRequest) {
+            throw new Error("Delta request not initialized. Call initializeDeltaRequests first.");
+        }
+        
+        const response = await this.rest.get("/" + this.lastDeltaRequest);
+        const responseText = typeof response.data === 'string' ? response.data : JSON.stringify(response.data);
+        this.lastDeltaRequest = responseText.substring(
+            responseText.lastIndexOf("MessageLogEntries/!delta('"),
+            responseText.length - 2
+        );
+        return response.data.value;
+    }
+
+    @deprecatedInVersion("12.0.0")
+    
+    public async getEntries(
+        reverse: boolean = true,
+        since?: Date,
+        until?: Date,
+        top?: number,
+        logger?: string,
+        level?: string,
+        msgContains?: string | string[],
+        msgContainsOperator: string = 'and'
+    ): Promise<any[]> {
+        /**
+         * :param reverse: Boolean
+         * :param since: of type datetime. If it doesn't have tz information, UTC is assumed.
+         * :param until: of type datetime. If it doesn't have tz information, UTC is assumed.
+         * :param top: Integer
+         * :param logger: string, eg TM1.Server, TM1.Chore, TM1.Mdx.Interface, TM1.Process
+         * :param level: string, ERROR, WARNING, INFO, DEBUG, UNKNOWN
+         * :param msg_contains: iterable, find substring in log message; list of substrings will be queried as AND statement
+         * :param msg_contains_operator: 'and' or 'or'
+         *
+         * :return: Dict of server log
+         */
+        const msgContainsOperatorLower = msgContainsOperator.trim().toLowerCase();
+        if (msgContainsOperatorLower !== "and" && msgContainsOperatorLower !== "or") {
+            throw new Error("'msg_contains_operator' must be either 'and' or 'or'");
+        }
+
+        const reverseOrder = reverse ? 'desc' : 'asc';
+        let url = `/MessageLogEntries?$orderby=TimeStamp ${reverseOrder}`;
+
+        if (since || until || logger || level || msgContains) {
+            const logFilters: string[] = [];
+
+            if (since) {
+                // If since doesn't have tz information, UTC is assumed
+                const sinceUtc = this.ensureUtc(since);
+                logFilters.push(formatUrl(
+                    "TimeStamp ge {}", 
+                    sinceUtc.toISOString().replace(/\.\d{3}Z$/, 'Z')
+                ));
+            }
+
+            if (until) {
+                // If until doesn't have tz information, UTC is assumed
+                const untilUtc = this.ensureUtc(until);
+                logFilters.push(formatUrl(
+                    "TimeStamp le {}", 
+                    untilUtc.toISOString().replace(/\.\d{3}Z$/, 'Z')
+                ));
+            }
+
+            if (logger) {
+                logFilters.push(formatUrl("Logger eq '{}'", logger));
+            }
+
+            if (level) {
+                const levelDict = new CaseAndSpaceInsensitiveDict([
+                    ['ERROR', 1], ['WARNING', 2], ['INFO', 3], ['DEBUG', 4], ['UNKNOWN', 5]
+                ]);
+                const levelIndex = levelDict.get(level);
+                if (levelIndex) {
+                    logFilters.push(`Level eq ${levelIndex}`);
+                }
+            }
+
+            if (msgContains) {
+                if (typeof msgContains === 'string') {
+                    logFilters.push(formatUrl(
+                        "contains(toupper(Message),toupper('{}'))", msgContains
+                    ));
+                } else {
+                    const msgFilters = msgContains.map(wildcard =>
+                        formatUrl("contains(toupper(Message),toupper('{}'))", wildcard)
+                    );
+                    logFilters.push(`(${msgFilters.join(` ${msgContainsOperatorLower} `)})`);
+                }
+            }
+
+            url += `&$filter=${logFilters.join(" and ")}`;
+        }
+
+        if (top) {
+            url += `&$top=${top}`;
+        }
+
+        const response = await this.rest.get(url);
+        return response.data.value;
+    }
+
+    
+    public async createEntry(level: string, message: string): Promise<void> {
+        /**
+         * :param level: string, FATAL, ERROR, WARN, INFO, DEBUG
+         * :param message: string
+         * :return:
+         */
+
+        const validLevels = new CaseAndSpaceInsensitiveSet(
+            ['FATAL', 'ERROR', 'WARN', 'INFO', 'DEBUG']
+        );
+        if (!validLevels.has(level)) {
+            throw new Error(`Invalid level: '${level}'`);
+        }
+
+        const processService = new ProcessService(this.rest);
+        
+        // Execute TI code directly instead of creating a process
+        const tiCode = `LogOutput('${level}', '${message}');`;
+        const response = await processService.executeTiCode([tiCode]);
+        const success = response.status === 200;
+
+        if (!success) {
+            throw new Error(
+                `Failed to write to TM1 Message Log through unbound process. Status: '${response.status}'`
+            );
+        }
+    }
+
+    
+    @deprecatedInVersion("12.0.0")
+    public async getLastProcessMessage(processName: string): Promise<string | null> {
+        /** Get the latest message log entry for a process
+         *
+         *    :param process_name: name of the process
+         *    :return: String - the message, for instance: "Ausführung normal beendet, verstrichene Zeit 0.03  Sekunden"
+         */
+        const url = formatUrl(
+            "/MessageLog()?$orderby='TimeStamp'&$filter=Logger eq 'TM1.Process' and contains(Message, '{}')",
+            processName
+        );
+        const response = await this.rest.get(url);
+        const responseAsList = response.data.value;
+        if (responseAsList.length > 0) {
+            const messageLogEntry = responseAsList[0];
+            return messageLogEntry.Message;
+        }
+        return null;
+    }
+
+    private ensureUtc(date: Date): Date {
+        /** Ensure date is treated as UTC if no timezone info
+         *
+         * :param date: Date object
+         * :return: Date object with UTC timezone
+         */
+        // In JavaScript, Date objects are always timezone-aware (local timezone)
+        // To treat as UTC, we need to adjust for the timezone offset
+        return new Date(date.getTime() - (date.getTimezoneOffset() * 60000));
+    }
+}

package/src/services/MonitoringService.ts

@@ -0,0 +1,105 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { User } from '../objects/User';
+import { ThreadService } from './ThreadService';
+import { SessionService } from './SessionService';
+import { UserService } from './UserService';
+
+export class MonitoringService extends ObjectService {
+    /** Service to Query and Cancel Threads in TM1
+     */
+
+    public users: UserService;
+    public threads: ThreadService;
+    public session: SessionService;
+
+    constructor(rest: RestService) {
+        super(rest);
+        console.warn("Monitoring Service will be moved to a new location in a future version");
+        this.users = new UserService(rest);
+        this.threads = new ThreadService(rest);
+        this.session = new SessionService(rest);
+    }
+
+    public async getThreads(): Promise<any[]> {
+        /** Return a dict of the currently running threads from the TM1 Server
+         *
+         *    :return:
+         *        dict: the response
+         */
+        return await this.threads.getAll();
+    }
+
+    public async getActiveThreads(): Promise<any[]> {
+        /**Return a list of non-idle threads from the TM1 Server
+         *
+         *    :return:
+         *        list: TM1 threads as dict
+         */
+        return await this.threads.getActive();
+    }
+
+    public async cancelThread(threadId: number): Promise<AxiosResponse> {
+        /** Kill a running thread
+         * 
+         * :param thread_id: 
+         * :return: 
+         */
+        return await this.threads.cancel(threadId);
+    }
+
+    public async cancelAllRunningThreads(): Promise<any[]> {
+        return await this.threads.cancelAllRunning();
+    }
+
+    public async getActiveUsers(): Promise<User[]> {
+        /** Get the activate users in TM1
+         *
+         * :return: List of .User instances
+         */
+        return await this.users.getActive();
+    }
+
+    public async userIsActive(userName: string): Promise<boolean> {
+        /** Check if user is currently active in TM1
+         *
+         * :param user_name:
+         * :return: Boolean
+         */
+        return await this.users.isActive(userName);
+    }
+
+    public async disconnectUser(userName: string): Promise<AxiosResponse> {
+        /** Disconnect User
+         * 
+         * :param user_name: 
+         * :return: 
+         */
+        return await this.users.disconnect(userName);
+    }
+
+    public async getActiveSessionThreads(excludeIdle: boolean = true): Promise<any[]> {
+        return await this.session.getThreadsForCurrent(excludeIdle);
+    }
+
+    public async getSessions(includeUser: boolean = true, includeThreads: boolean = true): Promise<any[]> {
+        return await this.session.getAll(includeUser, includeThreads);
+    }
+
+    public async disconnectAllUsers(): Promise<string[]> {
+        return await this.users.disconnectAll();
+    }
+
+    public async closeSession(sessionId: string): Promise<AxiosResponse> {
+        return await this.session.close(sessionId);
+    }
+
+    public async closeAllSessions(): Promise<any[]> {
+        return await this.session.closeAll();
+    }
+
+    public async getCurrentUser(): Promise<User> {
+        return await this.users.getCurrent();
+    }
+}

package/src/services/ObjectService.ts

@@ -0,0 +1,21 @@
+import { RestService } from './RestService';
+
+export abstract class ObjectService {
+    protected rest: RestService;
+
+    constructor(rest: RestService) {
+        this.rest = rest;
+    }
+
+    protected formatUrl(template: string, ...args: string[]): string {
+        let url = template;
+        for (const arg of args) {
+            url = url.replace('{}', encodeURIComponent(arg));
+        }
+        return url;
+    }
+
+    protected caseAndSpaceInsensitiveEquals(str1: string, str2: string): boolean {
+        return str1.toLowerCase().replace(/\s+/g, '') === str2.toLowerCase().replace(/\s+/g, '');
+    }
+}

package/src/services/PowerBiService.ts

@@ -0,0 +1,85 @@
+import { RestService } from './RestService';
+import { CellService } from './CellService';
+import { ElementService } from './ElementService';
+
+export class PowerBiService {
+    private _tm1Rest: RestService;
+    public cells: CellService;
+    public elements: ElementService;
+
+    constructor(tm1Rest: RestService) {
+        /**
+         * :param tm1_rest: instance of RestService
+         */
+        this._tm1Rest = tm1Rest;
+        this.cells = new CellService(tm1Rest);
+        this.elements = new ElementService(tm1Rest);
+    }
+
+    public async executeMdx(mdx: string): Promise<any[]> {
+        /** Execute MDX and return data as array (equivalent to DataFrame)
+         * Note: In JavaScript/TypeScript, we return array of objects instead of pandas DataFrame
+         */
+        return await this.cells.executeMdxDataFrameShaped(mdx);
+    }
+
+    public async executeView(
+        cubeName: string,
+        viewName: string,
+        isPrivate: boolean,
+        useIterativeJson: boolean = false,
+        useBlob: boolean = false
+    ): Promise<any[]> {
+        /** Execute view and return data as array (equivalent to DataFrame)
+         * Note: In JavaScript/TypeScript, we return array of objects instead of pandas DataFrame
+         */
+        return await this.cells.executeViewDataFrameShaped(
+            cubeName,
+            viewName,
+            isPrivate,
+            useIterativeJson,
+            useBlob
+        );
+    }
+
+    public async getMemberProperties(
+        dimensionName?: string,
+        hierarchyName?: string,
+        memberSelection?: string[] | string,
+        skipConsolidations: boolean = true,
+        attributes?: string[],
+        skipParents: boolean = false,
+        levelNames?: string[],
+        parentAttribute?: string,
+        skipWeights: boolean = true,
+        useBlob: boolean = false
+    ): Promise<any[]> {
+        /**
+         * :param dimension_name: Name of the dimension
+         * :param hierarchy_name: Name of the hierarchy in the dimension
+         * :param member_selection: Selection of members. Array or valid MDX string
+         * :param skip_consolidations: Boolean flag to skip consolidations
+         * :param attributes: Selection of attributes. Array. If None retrieve all.
+         * :param level_names: List of labels for parent columns. If None use level names from TM1.
+         * :param skip_parents: Boolean Flag to skip parent columns.
+         * :param parent_attribute: Attribute to be displayed in parent columns. If None, parent name is used.
+         * :param skip_weights: include weight columns
+         * :param use_blob: Better performance on large sets and lower memory footprint in any case. Requires admin permissions
+         *
+         * :return: Array of objects (equivalent to pandas DataFrame)
+         */
+        if (!skipWeights && skipParents) {
+            throw new Error("skip_weights must not be false if skip_parents is true");
+        }
+
+        if (!dimensionName) {
+            throw new Error("dimensionName is required");
+        }
+
+        return await this.elements.getElementsDataframe(
+            dimensionName,
+            hierarchyName || dimensionName,
+            attributes
+        );
+    }
+}