tm1npm 1.0.0

package/lib/services/RestService.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestService = exports.AuthenticationMode = void 0;
+const axios_1 = __importDefault(require("axios"));
+const TM1Exception_1 = require("../exceptions/TM1Exception");
+var AuthenticationMode;
+(function (AuthenticationMode) {
+    AuthenticationMode[AuthenticationMode["BASIC"] = 1] = "BASIC";
+    AuthenticationMode[AuthenticationMode["WIA"] = 2] = "WIA";
+    AuthenticationMode[AuthenticationMode["CAM"] = 3] = "CAM";
+    AuthenticationMode[AuthenticationMode["CAM_SSO"] = 4] = "CAM_SSO";
+    AuthenticationMode[AuthenticationMode["IBM_CLOUD_API_KEY"] = 5] = "IBM_CLOUD_API_KEY";
+    AuthenticationMode[AuthenticationMode["SERVICE_TO_SERVICE"] = 6] = "SERVICE_TO_SERVICE";
+    AuthenticationMode[AuthenticationMode["PA_PROXY"] = 7] = "PA_PROXY";
+    AuthenticationMode[AuthenticationMode["BASIC_API_KEY"] = 8] = "BASIC_API_KEY";
+    AuthenticationMode[AuthenticationMode["ACCESS_TOKEN"] = 9] = "ACCESS_TOKEN";
+})(AuthenticationMode || (exports.AuthenticationMode = AuthenticationMode = {}));
+class RestService {
+    constructor(config) {
+        this.isConnected = false;
+        this.config = { ...config };
+        this.setupAxiosInstance();
+    }
+    setupAxiosInstance() {
+        const baseURL = this.buildBaseUrl();
+        this.axiosInstance = axios_1.default.create({
+            baseURL,
+            timeout: (this.config.timeout || 60) * 1000,
+            headers: {
+                ...RestService.HEADERS,
+                ...(this.config.sessionContext && { 'TM1-SessionContext': this.config.sessionContext })
+            }
+        });
+        this.setupInterceptors();
+    }
+    buildBaseUrl() {
+        if (this.config.baseUrl) {
+            return this.config.baseUrl;
+        }
+        const protocol = this.config.ssl ? 'https' : 'http';
+        const address = this.config.address || 'localhost';
+        const port = this.config.port || 8001;
+        return `${protocol}://${address}:${port}/api/v1`;
+    }
+    setupInterceptors() {
+        // Request interceptor
+        this.axiosInstance.interceptors.request.use((config) => {
+            if (this.sessionId) {
+                config.headers['TM1SessionId'] = this.sessionId;
+            }
+            if (this.sandboxName) {
+                config.headers['TM1-Sandbox'] = this.sandboxName;
+            }
+            return config;
+        }, (error) => Promise.reject(error));
+        // Response interceptor
+        this.axiosInstance.interceptors.response.use((response) => response, (error) => {
+            if (error.code === 'ECONNABORTED' || error.message.includes('timeout')) {
+                throw new TM1Exception_1.TM1TimeoutException(`Request timeout: ${error.message}`);
+            }
+            const response = error.response;
+            if (response) {
+                const message = this.extractErrorMessage(response);
+                throw new TM1Exception_1.TM1RestException(message, response);
+            }
+            throw new TM1Exception_1.TM1RestException(error.message);
+        });
+    }
+    extractErrorMessage(response) {
+        try {
+            if (response.data && response.data.error) {
+                if (response.data.error.message) {
+                    return response.data.error.message;
+                }
+                return JSON.stringify(response.data.error);
+            }
+            return `HTTP ${response.status}: ${response.statusText}`;
+        }
+        catch (_a) {
+            return `HTTP ${response.status}: ${response.statusText}`;
+        }
+    }
+    async connect() {
+        try {
+            // Basic authentication
+            if (this.config.user && this.config.password) {
+                const credentials = Buffer.from(`${this.config.user}:${this.config.password}`).toString('base64');
+                this.axiosInstance.defaults.headers.common['Authorization'] = `Basic ${credentials}`;
+            }
+            // Test connection
+            const response = await this.axiosInstance.get('/Configuration/ServerName');
+            // Extract session ID from response headers
+            const setCookie = response.headers['set-cookie'];
+            if (setCookie) {
+                for (const cookie of setCookie) {
+                    const match = cookie.match(/TM1SessionId=([^;]+)/);
+                    if (match) {
+                        this.sessionId = match[1];
+                        break;
+                    }
+                }
+            }
+            this.isConnected = true;
+        }
+        catch (error) {
+            throw new TM1Exception_1.TM1RestException(`Failed to connect to TM1: ${error}`);
+        }
+    }
+    async disconnect() {
+        if (this.isConnected && this.sessionId) {
+            try {
+                await this.axiosInstance.post('/ActiveSession/tm1.Close', {});
+            }
+            catch (error) {
+                // Ignore errors during disconnect
+            }
+            this.isConnected = false;
+            this.sessionId = undefined;
+        }
+    }
+    async get(url, config) {
+        return this.axiosInstance.get(url, config);
+    }
+    async post(url, data, config) {
+        return this.axiosInstance.post(url, data, config);
+    }
+    async patch(url, data, config) {
+        return this.axiosInstance.patch(url, data, config);
+    }
+    async put(url, data, config) {
+        return this.axiosInstance.put(url, data, config);
+    }
+    async delete(url, config) {
+        return this.axiosInstance.delete(url, config);
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    setSandbox(sandboxName) {
+        this.sandboxName = sandboxName;
+    }
+    getSandbox() {
+        return this.sandboxName;
+    }
+    isLoggedIn() {
+        return this.isConnected && !!this.sessionId;
+    }
+    async getApiMetadata() {
+        const response = await this.get("/$metadata");
+        return response.data;
+    }
+}
+exports.RestService = RestService;
+RestService.HEADERS = {
+    'Connection': 'keep-alive',
+    'User-Agent': 'tm1npm',
+    'Content-Type': 'application/json; odata.streaming=true; charset=utf-8',
+    'Accept': 'application/json;odata.metadata=none,text/plain',
+    'TM1-SessionContext': 'tm1npm'
+};
+RestService.DEFAULT_CONNECTION_POOL_SIZE = 10;
+RestService.DEFAULT_POOL_CONNECTIONS = 1;
+//# sourceMappingURL=RestService.js.map

package/lib/services/SandboxService.d.ts

@@ -0,0 +1,28 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { Sandbox } from '../objects/Sandbox';
+export declare class SandboxService extends ObjectService {
+    /** Service to handle sandboxes in TM1
+     *
+     */
+    constructor(rest: RestService);
+    get(sandboxName: string): Promise<Sandbox>;
+    getAll(): Promise<Sandbox[]>;
+    getAllNames(): Promise<string[]>;
+    create(sandbox: Sandbox): Promise<AxiosResponse>;
+    update(sandbox: Sandbox): Promise<AxiosResponse>;
+    delete(sandboxName: string): Promise<AxiosResponse>;
+    publish(sandboxName: string): Promise<AxiosResponse>;
+    reset(sandboxName: string): Promise<AxiosResponse>;
+    merge(sourceSandboxName: string, targetSandboxName: string): Promise<AxiosResponse>;
+    exists(sandboxName: string): Promise<boolean>;
+    getChanges(sandboxName: string): Promise<any>;
+    isEmpty(sandboxName: string): Promise<boolean>;
+    load(sandboxName: string): Promise<AxiosResponse>;
+    unload(sandboxName: string): Promise<AxiosResponse>;
+    getSandboxDimensionMembers(): Promise<string[]>;
+    createIfNotExists(sandbox: Sandbox): Promise<AxiosResponse | null>;
+    cloneSandbox(sourceSandboxName: string, targetSandboxName: string): Promise<AxiosResponse>;
+}
+//# sourceMappingURL=SandboxService.d.ts.map

package/lib/services/SandboxService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxService.d.ts","sourceRoot":"","sources":["../../src/services/SandboxService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAI7C,qBAAa,cAAe,SAAQ,aAAa;IAC7C;;OAEG;gBAES,IAAI,EAAE,WAAW;IAIhB,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAY1C,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAa5B,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAWhC,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC;IAUhD,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC;IAUhD,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAUnD,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAUpD,KAAK,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAUlD,KAAK,CAAC,iBAAiB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAcnF,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB7C,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAW7C,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAc9C,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAUjD,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAUnD,0BAA0B,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAU/C,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAYlE,YAAY,CAAC,iBAAiB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;CAgB1G"}

package/lib/services/SandboxService.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxService = void 0;
+const ObjectService_1 = require("./ObjectService");
+const Sandbox_1 = require("../objects/Sandbox");
+const TM1Exception_1 = require("../exceptions/TM1Exception");
+const Utils_1 = require("../utils/Utils");
+class SandboxService extends ObjectService_1.ObjectService {
+    /** Service to handle sandboxes in TM1
+     *
+     */
+    constructor(rest) {
+        super(rest);
+    }
+    async get(sandboxName) {
+        /** get a sandbox from TM1 Server
+         *
+         * :param sandbox_name: str
+         * :return: instance of .Sandbox
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')", sandboxName);
+        const response = await this.rest.get(url);
+        const sandbox = Sandbox_1.Sandbox.fromJSON(JSON.stringify(response.data));
+        return sandbox;
+    }
+    async getAll() {
+        /** get all sandboxes from TM1 Server
+         *
+         * :return: List of .Sandbox instances
+         */
+        const url = "/Sandboxes?$select=Name,IncludeInSandboxDimension,IsLoaded,IsActive,IsQueued";
+        const response = await this.rest.get(url);
+        const sandboxes = response.data.value.map((sandboxAsDict) => Sandbox_1.Sandbox.fromDict(sandboxAsDict));
+        return sandboxes;
+    }
+    async getAllNames() {
+        /** get all sandbox names
+         *
+         * :param kwargs:
+         * :return:
+         */
+        const url = "/Sandboxes?$select=Name";
+        const response = await this.rest.get(url);
+        return response.data.value.map((entry) => entry.Name);
+    }
+    async create(sandbox) {
+        /** create a new sandbox in TM1 Server
+         *
+         * :param sandbox: Sandbox
+         * :return: response
+         */
+        const url = "/Sandboxes";
+        return await this.rest.post(url, sandbox.body);
+    }
+    async update(sandbox) {
+        /** update a sandbox in TM1
+         *
+         * :param sandbox:
+         * :return: response
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')", sandbox.name);
+        return await this.rest.patch(url, sandbox.body);
+    }
+    async delete(sandboxName) {
+        /** delete a sandbox in TM1
+         *
+         * :param sandbox_name:
+         * :return: response
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')", sandboxName);
+        return await this.rest.delete(url);
+    }
+    async publish(sandboxName) {
+        /** publish existing sandbox to base
+         *
+         * :param sandbox_name: str
+         * :return: response
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')/tm1.Publish", sandboxName);
+        return await this.rest.post(url, "{}");
+    }
+    async reset(sandboxName) {
+        /** reset all changes in specified sandbox
+         *
+         * :param sandbox_name: str
+         * :return: response
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')/tm1.DiscardChanges", sandboxName);
+        return await this.rest.post(url, "{}");
+    }
+    async merge(sourceSandboxName, targetSandboxName) {
+        /** merge changes from source sandbox into target sandbox
+         *
+         * :param source_sandbox_name: str
+         * :param target_sandbox_name: str
+         * :return: response
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')/tm1.Merge", targetSandboxName);
+        const body = {
+            "Source@odata.bind": `Sandboxes('${sourceSandboxName}')`
+        };
+        return await this.rest.post(url, JSON.stringify(body));
+    }
+    async exists(sandboxName) {
+        /** check if sandbox exists
+         *
+         * :param sandbox_name: str
+         * :return: boolean
+         */
+        try {
+            await this.get(sandboxName);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof TM1Exception_1.TM1RestException && error.statusCode === 404) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async getChanges(sandboxName) {
+        /** get all changes in a sandbox
+         *
+         * :param sandbox_name: str
+         * :return: dict of changes
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')/Changes", sandboxName);
+        const response = await this.rest.get(url);
+        return response.data;
+    }
+    async isEmpty(sandboxName) {
+        /** check if sandbox is empty (has no changes)
+         *
+         * :param sandbox_name: str
+         * :return: boolean
+         */
+        try {
+            const changes = await this.getChanges(sandboxName);
+            return !changes || !changes.value || changes.value.length === 0;
+        }
+        catch (_a) {
+            return true;
+        }
+    }
+    async load(sandboxName) {
+        /** load sandbox into memory
+         *
+         * :param sandbox_name: str
+         * :return: response
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')/tm1.Load", sandboxName);
+        return await this.rest.post(url, "{}");
+    }
+    async unload(sandboxName) {
+        /** unload sandbox from memory
+         *
+         * :param sandbox_name: str
+         * :return: response
+         */
+        const url = (0, Utils_1.formatUrl)("/Sandboxes('{}')/tm1.Unload", sandboxName);
+        return await this.rest.post(url, "{}");
+    }
+    async getSandboxDimensionMembers() {
+        /** get all members of the }Sandboxes dimension
+         *
+         * :return: list of sandbox names
+         */
+        const url = "/Dimensions('}Sandboxes')/Hierarchies('}Sandboxes')/Elements?$select=Name";
+        const response = await this.rest.get(url);
+        return response.data.value.map((element) => element.Name);
+    }
+    async createIfNotExists(sandbox) {
+        /** create sandbox if it doesn't exist
+         *
+         * :param sandbox: Sandbox instance
+         * :return: response or null if already exists
+         */
+        if (await this.exists(sandbox.name)) {
+            return null;
+        }
+        return await this.create(sandbox);
+    }
+    async cloneSandbox(sourceSandboxName, targetSandboxName) {
+        /** clone a sandbox
+         *
+         * :param source_sandbox_name: str
+         * :param target_sandbox_name: str
+         * :return: response
+         */
+        const sourceSandbox = await this.get(sourceSandboxName);
+        const targetSandbox = new Sandbox_1.Sandbox(targetSandboxName, sourceSandbox.includeInSandboxDimension);
+        await this.create(targetSandbox);
+        return await this.merge(sourceSandboxName, targetSandboxName);
+    }
+}
+exports.SandboxService = SandboxService;
+//# sourceMappingURL=SandboxService.js.map

package/lib/services/SecurityService.d.ts

@@ -0,0 +1,33 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { User } from '../objects/User';
+export declare class SecurityService extends ObjectService {
+    /** Service to handle Security stuff
+     *
+     */
+    constructor(rest: RestService);
+    determineActualUserName(userName: string): Promise<string>;
+    determineActualGroupName(groupName: string): Promise<string>;
+    createUser(user: User): Promise<AxiosResponse>;
+    createGroup(groupName: string): Promise<AxiosResponse>;
+    getUser(userName: string): Promise<User>;
+    getCurrentUser(): Promise<User>;
+    updateUser(user: User): Promise<AxiosResponse>;
+    updateUserPassword(userName: string, password: string): Promise<AxiosResponse>;
+    deleteUser(userName: string): Promise<AxiosResponse>;
+    deleteGroup(groupName: string): Promise<AxiosResponse>;
+    getUserNames(): Promise<string[]>;
+    getGroupNames(): Promise<string[]>;
+    getAllUsers(): Promise<User[]>;
+    getGroups(userName?: string): Promise<string[]>;
+    getUsersFromGroup(groupName: string): Promise<string[]>;
+    addUserToGroups(userName: string, groupNames: string[]): Promise<AxiosResponse[]>;
+    addUserToGroup(groupName: string, userName: string): Promise<AxiosResponse>;
+    removeUserFromGroup(groupName: string, userName: string): Promise<AxiosResponse>;
+    getSecurityRefreshTime(): Promise<number>;
+    userExists(userName: string): Promise<boolean>;
+    groupExists(groupName: string): Promise<boolean>;
+    private determineActualObjectName;
+}
+//# sourceMappingURL=SecurityService.d.ts.map

package/lib/services/SecurityService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityService.d.ts","sourceRoot":"","sources":["../../src/services/SecurityService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAGvC,qBAAa,eAAgB,SAAQ,aAAa;IAC9C;;OAEG;gBAES,IAAI,EAAE,WAAW;IAIhB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI1D,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK5D,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC;IAW9C,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAUtD,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAW/B,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC;IAmB9C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAO9E,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAYpD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAWtD,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAUjC,aAAa,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAUlC,WAAW,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IAU9B,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAgB/C,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAavD,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAgBjF,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAkB3E,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAehF,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC;IAUzC,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAc9C,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;YAgB/C,yBAAyB;CAgB1C"}

package/lib/services/SecurityService.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityService = void 0;
+const ObjectService_1 = require("./ObjectService");
+const User_1 = require("../objects/User");
+const Utils_1 = require("../utils/Utils");
+class SecurityService extends ObjectService_1.ObjectService {
+    /** Service to handle Security stuff
+     *
+     */
+    constructor(rest) {
+        super(rest);
+    }
+    async determineActualUserName(userName) {
+        return await this.determineActualObjectName("Users", userName);
+    }
+    async determineActualGroupName(groupName) {
+        return await this.determineActualObjectName("Groups", groupName);
+    }
+    async createUser(user) {
+        /** Create a user on TM1 Server
+         *
+         * :param user: instance of .User
+         * :return: response
+         */
+        const url = '/Users';
+        return await this.rest.post(url, user.body);
+    }
+    async createGroup(groupName) {
+        /** 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 }));
+    }
+    async getUser(userName) {
+        /** Get user from TM1 Server
+         *
+         * :param user_name:
+         * :return: instance of .User
+         */
+        const actualUserName = await this.determineActualUserName(userName);
+        const url = (0, Utils_1.formatUrl)("/Users('{}')?$select=Name,FriendlyName,Password,Type,Enabled&$expand=Groups", actualUserName);
+        const response = await this.rest.get(url);
+        return User_1.User.fromDict(response.data);
+    }
+    async getCurrentUser() {
+        /** 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_1.User.fromDict(response.data);
+    }
+    async updateUser(user) {
+        /** 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 = (0, Utils_1.formatUrl)("/Users('{}')", user.name);
+        return await this.rest.patch(url, user.body);
+    }
+    async updateUserPassword(userName, password) {
+        const url = (0, Utils_1.formatUrl)("/Users('{}')", userName);
+        const body = { Password: password };
+        return await this.rest.patch(url, JSON.stringify(body));
+    }
+    async deleteUser(userName) {
+        /** Delete user on TM1 Server
+         *
+         * :param user_name:
+         * :return: response
+         */
+        const actualUserName = await this.determineActualUserName(userName);
+        const url = (0, Utils_1.formatUrl)("/Users('{}')", actualUserName);
+        return await this.rest.delete(url);
+    }
+    async deleteGroup(groupName) {
+        /** Delete a Security group in the TM1 Server
+         *
+         * :param group_name:
+         * :return: response
+         */
+        const actualGroupName = await this.determineActualGroupName(groupName);
+        const url = (0, Utils_1.formatUrl)("/Groups('{}')", actualGroupName);
+        return await this.rest.delete(url);
+    }
+    async getUserNames() {
+        /** 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) => user.Name);
+    }
+    async getGroupNames() {
+        /** 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) => group.Name);
+    }
+    async getAllUsers() {
+        /** 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) => User_1.User.fromDict(userDict));
+    }
+    async getGroups(userName) {
+        /** 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 = (0, Utils_1.formatUrl)("/Users('{}')/Groups?$select=Name", actualUserName);
+            const response = await this.rest.get(url);
+            return response.data.value.map((group) => group.Name);
+        }
+        else {
+            return await this.getGroupNames();
+        }
+    }
+    async getUsersFromGroup(groupName) {
+        /** 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 = (0, Utils_1.formatUrl)("/Groups('{}')/Users?$select=Name", actualGroupName);
+        const response = await this.rest.get(url);
+        return response.data.value.map((user) => user.Name);
+    }
+    async addUserToGroups(userName, groupNames) {
+        /** 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 = [];
+        for (const groupName of groupNames) {
+            const response = await this.addUserToGroup(groupName, userName);
+            responses.push(response);
+        }
+        return responses;
+    }
+    async addUserToGroup(groupName, userName) {
+        /** 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 = (0, Utils_1.formatUrl)("/Groups('{}')/Users", actualGroupName);
+        const body = {
+            '@odata.id': `Users('${actualUserName}')`
+        };
+        return await this.rest.post(url, JSON.stringify(body));
+    }
+    async removeUserFromGroup(groupName, userName) {
+        /** 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 = (0, Utils_1.formatUrl)("/Groups('{}')/Users('{}')", actualGroupName, actualUserName);
+        return await this.rest.delete(url);
+    }
+    async getSecurityRefreshTime() {
+        /** 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);
+    }
+    async userExists(userName) {
+        /** Check if user exists
+         *
+         * :param user_name: name of the user
+         * :return: True if user exists
+         */
+        try {
+            await this.getUser(userName);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    async groupExists(groupName) {
+        /** 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 = (0, Utils_1.formatUrl)("/Groups('{}')", actualGroupName);
+            await this.rest.get(url);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    async determineActualObjectName(objectClass, objectName) {
+        /** 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
+    }
+}
+exports.SecurityService = SecurityService;
+//# sourceMappingURL=SecurityService.js.map