tm1npm 1.0.0

package/src/services/SecurityService.ts

@@ -0,0 +1,284 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { User } from '../objects/User';
+import { formatUrl, CaseAndSpaceInsensitiveSet, requireSecurityAdmin, requireAdmin } from '../utils/Utils';
+
+export class SecurityService extends ObjectService {
+    /** Service to handle Security stuff
+     * 
+     */
+
+    constructor(rest: RestService) {
+        super(rest);
+    }
+
+    public async determineActualUserName(userName: string): Promise<string> {
+        return await this.determineActualObjectName("Users", userName);
+    }
+
+    public async determineActualGroupName(groupName: string): Promise<string> {
+        return await this.determineActualObjectName("Groups", groupName);
+    }
+
+    
+    public async createUser(user: User): Promise<AxiosResponse> {
+        /** Create a user on TM1 Server
+         *
+         * :param user: instance of .User
+         * :return: response
+         */
+        const url = '/Users';
+        return await this.rest.post(url, user.body);
+    }
+
+    
+    public async createGroup(groupName: string): Promise<AxiosResponse> {
+        /** Create a Security group in the TM1 Server
+         *
+         * :param group_name:
+         * :return:
+         */
+        const url = '/Groups';
+        return await this.rest.post(url, JSON.stringify({ Name: groupName }));
+    }
+
+    public async getUser(userName: string): Promise<User> {
+        /** Get user from TM1 Server
+         *
+         * :param user_name:
+         * :return: instance of .User
+         */
+        const actualUserName = await this.determineActualUserName(userName);
+        const url = formatUrl(
+            "/Users('{}')?$select=Name,FriendlyName,Password,Type,Enabled&$expand=Groups",
+            actualUserName);
+        const response = await this.rest.get(url);
+        return User.fromDict(response.data);
+    }
+
+    public async getCurrentUser(): Promise<User> {
+        /** Get user and group assignments of this session
+         *
+         * :return: instance of .User
+         */
+        const url = "/ActiveUser?$select=Name,FriendlyName,Password,Type,Enabled&$expand=Groups";
+        const response = await this.rest.get(url);
+        return User.fromDict(response.data);
+    }
+
+    
+    public async updateUser(user: User): Promise<AxiosResponse> {
+        /** Update user on TM1 Server
+         *
+         * :param user: instance of .User
+         * :return: response
+         */
+        user.name = await this.determineActualUserName(user.name);
+        const currentGroups = await this.getGroups(user.name);
+        
+        for (const currentGroup of currentGroups) {
+            if (!user.groups.includes(currentGroup)) {
+                await this.removeUserFromGroup(currentGroup, user.name);
+            }
+        }
+        
+        const url = formatUrl("/Users('{}')", user.name);
+        return await this.rest.patch(url, user.body);
+    }
+
+    public async updateUserPassword(userName: string, password: string): Promise<AxiosResponse> {
+        const url = formatUrl("/Users('{}')", userName);
+        const body = { Password: password };
+        return await this.rest.patch(url, JSON.stringify(body));
+    }
+
+    
+    public async deleteUser(userName: string): Promise<AxiosResponse> {
+        /** Delete user on TM1 Server
+         *
+         * :param user_name:
+         * :return: response
+         */
+        const actualUserName = await this.determineActualUserName(userName);
+        const url = formatUrl("/Users('{}')", actualUserName);
+        return await this.rest.delete(url);
+    }
+
+    
+    public async deleteGroup(groupName: string): Promise<AxiosResponse> {
+        /** Delete a Security group in the TM1 Server
+         *
+         * :param group_name:
+         * :return: response
+         */
+        const actualGroupName = await this.determineActualGroupName(groupName);
+        const url = formatUrl("/Groups('{}')", actualGroupName);
+        return await this.rest.delete(url);
+    }
+
+    public async getUserNames(): Promise<string[]> {
+        /** Get all user names
+         *
+         * :return: List of user names
+         */
+        const url = "/Users?$select=Name";
+        const response = await this.rest.get(url);
+        return response.data.value.map((user: any) => user.Name);
+    }
+
+    public async getGroupNames(): Promise<string[]> {
+        /** Get all group names
+         *
+         * :return: List of group names
+         */
+        const url = "/Groups?$select=Name";
+        const response = await this.rest.get(url);
+        return response.data.value.map((group: any) => group.Name);
+    }
+
+    public async getAllUsers(): Promise<User[]> {
+        /** Get all users
+         *
+         * :return: List of User instances
+         */
+        const url = "/Users?$select=Name,FriendlyName,Password,Type,Enabled&$expand=Groups";
+        const response = await this.rest.get(url);
+        return response.data.value.map((userDict: any) => User.fromDict(userDict));
+    }
+
+    public async getGroups(userName?: string): Promise<string[]> {
+        /** Get groups for a user or all groups
+         *
+         * :param user_name: Optional user name
+         * :return: List of group names
+         */
+        if (userName) {
+            const actualUserName = await this.determineActualUserName(userName);
+            const url = formatUrl("/Users('{}')/Groups?$select=Name", actualUserName);
+            const response = await this.rest.get(url);
+            return response.data.value.map((group: any) => group.Name);
+        } else {
+            return await this.getGroupNames();
+        }
+    }
+
+    public async getUsersFromGroup(groupName: string): Promise<string[]> {
+        /** Get users that belong to a group
+         *
+         * :param group_name: name of the group
+         * :return: List of user names
+         */
+        const actualGroupName = await this.determineActualGroupName(groupName);
+        const url = formatUrl("/Groups('{}')/Users?$select=Name", actualGroupName);
+        const response = await this.rest.get(url);
+        return response.data.value.map((user: any) => user.Name);
+    }
+
+    
+    public async addUserToGroups(userName: string, groupNames: string[]): Promise<AxiosResponse[]> {
+        /** Add user to multiple groups
+         *
+         * :param user_name: name of the user
+         * :param group_names: list of group names
+         * :return: list of responses
+         */
+        const responses: AxiosResponse[] = [];
+        for (const groupName of groupNames) {
+            const response = await this.addUserToGroup(groupName, userName);
+            responses.push(response);
+        }
+        return responses;
+    }
+
+    
+    public async addUserToGroup(groupName: string, userName: string): Promise<AxiosResponse> {
+        /** Add user to a group
+         *
+         * :param group_name: name of the group
+         * :param user_name: name of the user
+         * :return: response
+         */
+        const actualGroupName = await this.determineActualGroupName(groupName);
+        const actualUserName = await this.determineActualUserName(userName);
+        
+        const url = formatUrl("/Groups('{}')/Users", actualGroupName);
+        const body = {
+            '@odata.id': `Users('${actualUserName}')`
+        };
+        return await this.rest.post(url, JSON.stringify(body));
+    }
+
+    
+    public async removeUserFromGroup(groupName: string, userName: string): Promise<AxiosResponse> {
+        /** Remove user from a group
+         *
+         * :param group_name: name of the group
+         * :param user_name: name of the user
+         * :return: response
+         */
+        const actualGroupName = await this.determineActualGroupName(groupName);
+        const actualUserName = await this.determineActualUserName(userName);
+        
+        const url = formatUrl("/Groups('{}')/Users('{}')", actualGroupName, actualUserName);
+        return await this.rest.delete(url);
+    }
+
+    
+    public async getSecurityRefreshTime(): Promise<number> {
+        /** Get security refresh time in seconds
+         *
+         * :return: security refresh time
+         */
+        const url = "/StaticConfiguration/ServerSettings('SecurityRefreshTime')";
+        const response = await this.rest.get(url);
+        return parseInt(response.data.Value);
+    }
+
+    public async userExists(userName: string): Promise<boolean> {
+        /** Check if user exists
+         *
+         * :param user_name: name of the user
+         * :return: True if user exists
+         */
+        try {
+            await this.getUser(userName);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    public async groupExists(groupName: string): Promise<boolean> {
+        /** Check if group exists
+         *
+         * :param group_name: name of the group
+         * :return: True if group exists
+         */
+        try {
+            const actualGroupName = await this.determineActualGroupName(groupName);
+            const url = formatUrl("/Groups('{}')", actualGroupName);
+            await this.rest.get(url);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    private async determineActualObjectName(objectClass: string, objectName: string): Promise<string> {
+        /** Determine the actual object name (case-sensitive) from TM1 Server
+         *
+         * :param object_class: 'Users' or 'Groups'
+         * :param object_name: name to look for
+         * :return: actual object name
+         */
+        const url = `/${objectClass}?$select=Name&$filter=tolower(Name) eq '${objectName.toLowerCase()}'`;
+        const response = await this.rest.get(url);
+        
+        if (response.data.value && response.data.value.length > 0) {
+            return response.data.value[0].Name;
+        }
+        
+        return objectName; // fallback to original name
+    }
+}

package/src/services/ServerService.ts

@@ -0,0 +1,313 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { TransactionLogService } from './TransactionLogService';
+import { MessageLogService } from './MessageLogService';
+import { AuditLogService } from './AuditLogService';
+import { LoggerService } from './LoggerService';
+import { ConfigurationService } from './ConfigurationService';
+import { ProcessService } from './ProcessService';
+import { 
+    requireAdmin, 
+    requireVersion, 
+    deprecatedInVersion,
+    requireDataAdmin,
+    requireOpsAdmin
+} from '../utils/Utils';
+
+export enum LogLevel {
+    FATAL = "fatal",
+    ERROR = "error", 
+    WARNING = "warning",
+    INFO = "info",
+    DEBUG = "debug",
+    OFF = "off"
+}
+
+export class ServerService extends ObjectService {
+    /** Service to query common information from the TM1 Server
+     */
+
+    public transactionLogs: TransactionLogService;
+    public messageLogs: MessageLogService;
+    public configuration: ConfigurationService;
+    public auditLogs: AuditLogService;
+    public loggers: LoggerService;
+
+    constructor(rest: RestService) {
+        super(rest);
+        console.warn("Server Service will be moved to a new location in a future version");
+        this.transactionLogs = new TransactionLogService(rest);
+        this.messageLogs = new MessageLogService(rest);
+        this.configuration = new ConfigurationService(rest);
+        this.auditLogs = new AuditLogService(rest);
+        this.loggers = new LoggerService(rest);
+    }
+
+    public async initializeTransactionLogDeltaRequests(filter?: string): Promise<void> {
+        return await this.transactionLogs.initializeDeltaRequests(filter);
+    }
+
+    public async executeTransactionLogDeltaRequest(): Promise<any[]> {
+        return await this.transactionLogs.executeDeltaRequest();
+    }
+
+    public async initializeAuditLogDeltaRequests(filter?: string): Promise<void> {
+        return await this.auditLogs.initializeDeltaRequests(filter);
+    }
+
+    public async executeAuditLogDeltaRequest(): Promise<any[]> {
+        return await this.auditLogs.executeDeltaRequest();
+    }
+
+    public async initializeMessageLogDeltaRequests(filter?: string): Promise<void> {
+        return await this.messageLogs.initializeDeltaRequests(filter);
+    }
+
+    public async executeMessageLogDeltaRequest(): Promise<any[]> {
+        return await this.messageLogs.executeDeltaRequest();
+    }
+
+    @deprecatedInVersion("12.0.0")
+    
+    public async getMessageLogEntries(
+        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
+         */
+
+        return await this.messageLogs.getEntries(
+            reverse,
+            since,
+            until,
+            top,
+            logger,
+            level,
+            msgContains,
+            msgContainsOperator
+        );
+    }
+
+    
+    public async writeToMessageLog(level: string, message: string): Promise<void> {
+        /**
+         * :param level: string, FATAL, ERROR, WARN, INFO, DEBUG
+         * :param message: string
+         * :return:
+         */
+
+        return await this.messageLogs.createEntry(level, message);
+    }
+
+    @deprecatedInVersion("12.0.0")
+    
+    public async getTransactionLogEntries(
+        reverse: boolean = true,
+        user?: string,
+        cube?: string,
+        since?: Date,
+        until?: Date,
+        top?: number,
+        elementTupleFilter?: Record<string, string>,
+        elementPositionFilter?: Record<number, Record<string, string>>
+    ): Promise<any[]> {
+        /**
+         * :param reverse: Boolean
+         * :param user: UserName
+         * :param cube: CubeName
+         * :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: int
+         * :param element_tuple_filter: of type dict. Element name as key and comparison operator as value
+         * :param element_position_filter: not yet implemented
+         * tuple={'Actual':'eq','2020': 'ge'}
+         * :return:
+         */
+        return await this.transactionLogs.getEntries(
+            reverse,
+            user,
+            cube,
+            since,
+            until,
+            top,
+            elementTupleFilter,
+            elementPositionFilter
+        );
+    }
+
+    
+    @deprecatedInVersion("12.0.0")
+    @requireVersion("11.6")
+    public async getAuditLogEntries(
+        user?: string,
+        objectType?: string,
+        objectName?: string,
+        since?: Date,
+        until?: Date,
+        top?: number
+    ): Promise<any[]> {
+        /**
+         * :param user: UserName
+         * :param object_type: ObjectType
+         * :param object_name: ObjectName
+         * :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: int
+         * :return:
+         */
+        return await this.auditLogs.getEntries(
+            user,
+            objectType,
+            objectName,
+            since,
+            until,
+            top
+        );
+    }
+
+    
+    @deprecatedInVersion("12.0.0")
+    public async getLastProcessMessageFromMessageLog(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"
+         */
+        return await this.messageLogs.getLastProcessMessage(processName);
+    }
+
+    public async getServerName(): Promise<string> {
+        /** Ask TM1 Server for its name
+         *
+         * :Returns:
+         *     String, the server name
+         */
+        return await this.configuration.getServerName();
+    }
+
+    public async getProductVersion(): Promise<string> {
+        /** Ask TM1 Server for its version
+         *
+         * :Returns:
+         *     String, the version
+         */
+        return await this.configuration.getProductVersion();
+    }
+
+    public async getAdminHost(): Promise<string> {
+        return await this.configuration.getAdminHost();
+    }
+
+    public async getDataDirectory(): Promise<string> {
+        return await this.configuration.getDataDirectory();
+    }
+
+    public async getConfiguration(): Promise<Record<string, any>> {
+        return await this.configuration.getAll();
+    }
+
+    public async getStaticConfiguration(): Promise<Record<string, any>> {
+        return await this.configuration.getStatic();
+    }
+
+    public async getActiveConfiguration(): Promise<Record<string, any>> {
+        /** Read effective(!) TM1 config settings as dictionary from TM1 Server
+         *
+         * :return: config as dictionary
+         */
+        return await this.configuration.getActive();
+    }
+
+    public async getApiMetadata(): Promise<Record<string, any>> {
+        /** Read effective(!) TM1 config settings as dictionary from TM1 Server
+         *
+         * :return: config as dictionary
+         */
+        return await this.rest.getApiMetadata();
+    }
+
+    public async updateStaticConfiguration(configuration: Record<string, any>): Promise<AxiosResponse> {
+        /** Update the .cfg file and triggers TM1 to re-read the file.
+         *
+         * :param configuration:
+         * :return: Response
+         */
+        return await this.configuration.updateStatic(configuration);
+    }
+
+    @deprecatedInVersion("12.0.0")
+    
+    public async saveData(): Promise<AxiosResponse> {
+        const ti = "SaveDataAll;";
+        const processService = new ProcessService(this.rest);
+        return await processService.executeTiCode([ti]);
+    }
+
+    
+    public async deletePersistentFeeders(): Promise<AxiosResponse> {
+        const ti = "DeleteAllPersistentFeeders;";
+        const processService = new ProcessService(this.rest);
+        return await processService.executeTiCode([ti]);
+    }
+
+    public async startPerformanceMonitor(): Promise<AxiosResponse> {
+        const config = {
+            "Administration": {"PerformanceMonitorOn": true}
+        };
+        return await this.configuration.updateStatic(config);
+    }
+
+    public async stopPerformanceMonitor(): Promise<AxiosResponse> {
+        const config = {
+            "Administration": {"PerformanceMonitorOn": false}
+        };
+        return await this.configuration.updateStatic(config);
+    }
+
+    public async activateAuditLog(): Promise<void> {
+        await this.auditLogs.activate();
+    }
+
+    
+    public async deactivateAuditLog(): Promise<AxiosResponse> {
+        const config = {'Administration': {'AuditLog': {'Enable': false}}};
+        return await this.updateStaticConfiguration(config);
+    }
+
+    
+    public async updateMessageLoggerLevel(logger: string, level: string): Promise<AxiosResponse> {
+        /**
+         * Updates tm1 message log levels
+         * :param logger:
+         * :param level:
+         * :return:
+         */
+        return await this.loggers.setLevel(logger, level);
+    }
+
+    
+    public async getAllMessageLoggerLevel(): Promise<any[]> {
+        /**
+         * Get tm1 message log levels
+         * :return:
+         */
+        return await this.loggers.getAll();
+    }
+}

package/src/services/SessionService.ts

@@ -0,0 +1,81 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { UserService } from './UserService';
+import { formatUrl, caseAndSpaceInsensitiveEquals, requireAdmin } from '../utils/Utils';
+
+export class SessionService extends ObjectService {
+    /** Service to Query and Cancel Threads in TM1
+     */
+
+    private users: UserService;
+
+    constructor(rest: RestService) {
+        super(rest);
+        this.users = new UserService(rest);
+    }
+
+    public async getAll(includeUser: boolean = true, includeThreads: boolean = true): Promise<any[]> {
+        let url = "/Sessions";
+        
+        if (includeUser || includeThreads) {
+            const expands: string[] = [];
+            if (includeUser) {
+                expands.push("User");
+            }
+            if (includeThreads) {
+                expands.push("Threads");
+            }
+            url += "?$expand=" + expands.join(",");
+        }
+
+        const response = await this.rest.get(url);
+        return response.data.value;
+    }
+
+    public async getCurrent(): Promise<any[]> {
+        const url = "/ActiveSession";
+        const response = await this.rest.get(url);
+        return response.data.value;
+    }
+
+    public async getThreadsForCurrent(excludeIdle: boolean = true): Promise<any[]> {
+        let url = "/ActiveSession/Threads?$filter=Function ne 'GET /ActiveSession/Threads'";
+        if (excludeIdle) {
+            url += " and State ne 'Idle'";
+        }
+
+        const response = await this.rest.get(url);
+        return response.data.value;
+    }
+
+    public async close(sessionId: string): Promise<AxiosResponse> {
+        const url = formatUrl("/Sessions('{}')/tm1.Close", sessionId);
+        return await this.rest.post(url);
+    }
+
+    
+    public async closeAll(): Promise<any[]> {
+        const currentUser = await this.users.getCurrent();
+        const sessions = await this.getAll();
+        const closedSessions: any[] = [];
+        
+        for (const session of sessions) {
+            if (!("User" in session)) {
+                continue;
+            }
+            if (session["User"] === null) {
+                continue;
+            }
+            if (!("Name" in session["User"])) {
+                continue;
+            }
+            if (caseAndSpaceInsensitiveEquals(currentUser.name, session["User"]["Name"])) {
+                continue;
+            }
+            await this.close(session['ID']);
+            closedSessions.push(session);
+        }
+        return closedSessions;
+    }
+}