tm1npm 1.0.0

package/src/objects/User.ts

@@ -0,0 +1,198 @@
+import { TM1Object } from './TM1Object';
+import { CaseAndSpaceInsensitiveSet, formatUrl } from '../utils/Utils';
+
+export enum UserType {
+    User = 0,
+    SecurityAdmin = 1,
+    DataAdmin = 2,
+    Admin = 3,
+    OperationsAdmin = 4
+}
+
+export class User extends TM1Object {
+    /** Abstraction of a TM1 User
+     * 
+     */
+
+    private _name: string;
+    private _groups: CaseAndSpaceInsensitiveSet;
+    private _friendlyName?: string;
+    private _password?: string;
+    private _enabled?: boolean;
+    private _userType: UserType = UserType.User;
+
+    constructor(
+        name: string,
+        groups: Iterable<string>,
+        friendlyName?: string,
+        password?: string,
+        userType?: UserType | string,
+        enabled?: boolean
+    ) {
+        super();
+        this._name = name;
+        this._groups = new CaseAndSpaceInsensitiveSet();
+        for (const group of groups) {
+            this._groups.add(group);
+        }
+        this._friendlyName = friendlyName;
+        this._password = password;
+        this._enabled = enabled;
+        
+        // determine user_type
+        if (userType === undefined) {
+            if (this._groups.has(UserType.Admin.toString())) {
+                this.userType = UserType.Admin;
+            } else if (this._groups.has(UserType.SecurityAdmin.toString())) {
+                this.userType = UserType.SecurityAdmin;
+            } else if (this._groups.has(UserType.DataAdmin.toString())) {
+                this.userType = UserType.DataAdmin;
+            } else if (this._groups.has(UserType.OperationsAdmin.toString())) {
+                this.userType = UserType.OperationsAdmin;
+            } else {
+                this.userType = UserType.User;
+            }
+        } else {
+            this.userType = userType;
+        }
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set name(value: string) {
+        this._name = value;
+    }
+
+    public get userType(): UserType {
+        return this._userType;
+    }
+
+    public set userType(value: UserType | string) {
+        if (typeof value === 'string') {
+            // Parse string to UserType enum
+            const lowerValue = value.replace(/\s+/g, '').toLowerCase();
+            for (const [key, enumValue] of Object.entries(UserType)) {
+                if (key.toLowerCase() === lowerValue) {
+                    this._userType = enumValue as UserType;
+                    break;
+                }
+            }
+            if (this._userType === undefined) {
+                throw new Error(`Invalid element type=${value}`);
+            }
+        } else {
+            this._userType = value;
+        }
+
+        // update groups as well, since TM1 doesn't react to change in user_type property
+        if (this._userType !== UserType.User) {
+            this.addGroup(this._userType.toString());
+        }
+    }
+
+    public get friendlyName(): string | undefined {
+        return this._friendlyName;
+    }
+
+    public set friendlyName(value: string | undefined) {
+        this._friendlyName = value;
+    }
+
+    public get password(): string | undefined {
+        return this._password;
+    }
+
+    public set password(value: string | undefined) {
+        this._password = value;
+    }
+
+    public get isAdmin(): boolean {
+        return this._groups.has("ADMIN");
+    }
+
+    public get isDataAdmin(): boolean {
+        return this._groups.has("Admin") || this._groups.has("DataAdmin");
+    }
+
+    public get isSecurityAdmin(): boolean {
+        return this._groups.has("Admin") || this._groups.has("SecurityAdmin");
+    }
+
+    public get isOpsAdmin(): boolean {
+        return this._groups.has("Admin") || this._groups.has("OperationsAdmin");
+    }
+
+    public get groups(): string[] {
+        return Array.from(this._groups);
+    }
+
+    public get enabled(): boolean | undefined {
+        return this._enabled;
+    }
+
+    public set enabled(value: boolean | undefined) {
+        this._enabled = value;
+    }
+
+    public addGroup(groupName: string): void {
+        this._groups.add(groupName);
+    }
+
+    public removeGroup(groupName: string): void {
+        this._groups.delete(groupName);
+    }
+
+    public static fromJSON(userAsJson: string): User {
+        /** Alternative constructor
+         *
+         * :param user_as_json: user as JSON string
+         * :return: user, an instance of this class
+         */
+        const userAsDict = JSON.parse(userAsJson);
+        return User.fromDict(userAsDict);
+    }
+
+    public static fromDict(userAsDict: any): User {
+        /** Alternative constructor
+         *
+         * :param user_as_dict: user as dict
+         * :return: user, an instance of this class
+         */
+        return new User(
+            userAsDict.Name,
+            userAsDict.Groups.map((group: any) => group.Name),
+            userAsDict.FriendlyName,
+            undefined, // password not included in dict
+            userAsDict.Type,
+            userAsDict.Enabled
+        );
+    }
+
+    public get body(): string {
+        return this.constructBody();
+    }
+
+    public constructBody(): string {
+        /**
+         * construct body (json) from the class attributes
+         * :return: String, TM1 JSON representation of a user
+         */
+        const bodyAsDict: any = {};
+        bodyAsDict.Name = this.name;
+        bodyAsDict.FriendlyName = this.friendlyName || this.name;
+        bodyAsDict.Enabled = this._enabled;
+        bodyAsDict.Type = this._userType.toString();
+        
+        if (this.password) {
+            bodyAsDict.Password = this._password;
+        }
+        
+        bodyAsDict['Groups@odata.bind'] = this.groups.map(group => 
+            formatUrl("Groups('{}')", group)
+        );
+        
+        return JSON.stringify(bodyAsDict);
+    }
+}

package/src/objects/View.ts

@@ -0,0 +1,43 @@
+import { TM1Object } from './TM1Object';
+
+export abstract class View extends TM1Object {
+    /** Abstraction of TM1 View
+     *     serves as a parentclass for .Objects.MDXView and .Objects.NativeView
+     *
+     */
+
+    protected _cube: string;
+    protected _name: string;
+
+    constructor(cube: string, name: string) {
+        super();
+        this._cube = cube;
+        this._name = name;
+    }
+
+    public abstract get body(): string;
+
+    public get cube(): string {
+        return this._cube;
+    }
+
+    public get name(): string {
+        return this._name;
+    }
+
+    public set cube(value: string) {
+        this._cube = value;
+    }
+
+    public set name(value: string) {
+        this._name = value;
+    }
+
+    public get mdx(): string {
+        throw new Error("NotImplementedError");
+    }
+}
+
+// Re-export the concrete classes
+export { MDXView } from './MDXView';
+export { NativeView } from './NativeView';

package/src/objects/index.ts

@@ -0,0 +1,36 @@
+// Export all object implementations
+export { TM1Object } from './TM1Object';
+export { Dimension } from './Dimension';
+export { Hierarchy } from './Hierarchy';
+export { Element } from './Element';
+export { ElementAttribute } from './ElementAttribute';
+export { Cube } from './Cube';
+export { Process } from './Process';
+export { ProcessParameter } from './ProcessParameter';
+export { ProcessVariable } from './ProcessVariable';
+export { User } from './User';
+export { Subset } from './Subset';
+export { MDXView } from './MDXView';
+export { NativeView } from './NativeView';
+export { View } from './View';
+export { ViewAxisSelection, ViewTitleSelection } from './Axis';
+export { Chore } from './Chore';
+export { ChoreTask } from './ChoreTask';
+export { ChoreStartTime } from './ChoreStartTime';
+export { Annotation } from './Annotation';
+export { Rules } from './Rules';
+export { Server } from './Server';
+
+// Git objects
+export { Git } from './Git';
+export { GitCommit } from './GitCommit';
+export { GitRemote } from './GitRemote';
+export { GitPlan } from './GitPlan';
+
+// Process debug
+export { ProcessDebugBreakpoint } from './ProcessDebugBreakpoint';
+
+// Re-export enum types
+export { ElementType } from './Element';
+export { UserType } from './User';
+export { BreakPointType, HitMode } from './ProcessDebugBreakpoint';

package/src/services/AnnotationService.ts

@@ -0,0 +1,107 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { Annotation } from '../objects/Annotation';
+import { formatUrl, CaseAndSpaceInsensitiveDict } from '../utils/Utils';
+
+export class AnnotationService extends ObjectService {
+    /** Service to handle Object Updates for TM1 CellAnnotations
+     * 
+     */
+
+    constructor(rest: RestService) {
+        super(rest);
+    }
+
+    public async getAll(cubeName: string): Promise<Annotation[]> {
+        /** get all annotations from given cube as a List.
+         *
+         * :param cube_name:
+         */
+        const url = formatUrl("/Cubes('{}')/Annotations?$expand=DimensionalContext($select=Name)", cubeName);
+        const response = await this.rest.get(url);
+
+        const annotationsAsDict = response.data.value;
+        const annotations = annotationsAsDict.map((element: any) => 
+            Annotation.fromJSON(JSON.stringify(element)));
+        return annotations;
+    }
+
+    public async create(annotation: Annotation): Promise<AxiosResponse> {
+        /** create an Annotation
+         *
+         * :param annotation: instance of .Annotation
+         */
+        const url = "/Annotations";
+
+        // Import here to avoid circular dependency
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { CubeService } = require('./CubeService');
+        const cubeService = new CubeService(this.rest);
+        const cubeDimensions = await cubeService.getDimensionNames(
+            annotation.objectName,
+            true // skip_sandbox_dimension
+        );
+
+        const response = await this.rest.post(url, 
+            JSON.stringify(annotation.constructBodyForPost(cubeDimensions)));
+        return response;
+    }
+
+    public async createMany(annotations: Iterable<Annotation>): Promise<AxiosResponse> {
+        /** create an Annotation
+         *
+         * :param annotations: instances of .Annotation
+         */
+        const payload: any[] = [];
+        const cubeDimensions = new CaseAndSpaceInsensitiveDict<string[]>();
+
+        for (const annotation of annotations) {
+            let dimensionNames = cubeDimensions.get(annotation.objectName);
+            if (!dimensionNames) {
+                // Import here to avoid circular dependency
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const { CubeService } = require('./CubeService');
+                const cubeService = new CubeService(this.rest);
+                dimensionNames = await cubeService.getDimensionNames(
+                    annotation.objectName,
+                    true // skip_sandbox_dimension
+                );
+                cubeDimensions.set(annotation.objectName, dimensionNames || []);
+            }
+            payload.push(annotation.constructBodyForPost(dimensionNames || []));
+        }
+
+        const response = await this.rest.post("/Annotations", JSON.stringify(payload));
+        return response;
+    }
+
+    public async get(annotationId: string): Promise<Annotation> {
+        /** get an annotation from any cube through its unique id
+         *
+         * :param annotation_id: String, the id of the annotation
+         */
+        const request = formatUrl("/Annotations('{}')?$expand=DimensionalContext($select=Name)", annotationId);
+        const response = await this.rest.get(request);
+        return Annotation.fromJSON(JSON.stringify(response.data));
+    }
+
+    public async update(annotation: Annotation): Promise<AxiosResponse> {
+        /** update Annotation.
+         * updateable attributes: commentValue
+         *
+         * :param annotation: instance of .Annotation
+         */
+        const url = formatUrl("/Annotations('{}')", annotation.id || '');
+        return await this.rest.patch(url, annotation.body);
+    }
+
+    public async delete(annotationId: string): Promise<AxiosResponse> {
+        /** delete Annotation
+         *
+         * :param annotation_id: string, the id of the annotation
+         */
+        const url = formatUrl("/Annotations('{}')", annotationId);
+        return await this.rest.delete(url);
+    }
+}

package/src/services/ApplicationService.ts

@@ -0,0 +1,279 @@
+import { AxiosResponse } from 'axios';
+import { RestService } from './RestService';
+import { ObjectService } from './ObjectService';
+import { 
+    DocumentApplication,
+    ApplicationTypes,
+    CubeApplication,
+    ChoreApplication,
+    FolderApplication,
+    LinkApplication,
+    ProcessApplication,
+    DimensionApplication,
+    SubsetApplication,
+    ViewApplication,
+    Application
+} from '../objects/Application';
+import { formatUrl, verifyVersion } from '../utils/Utils';
+
+export class ApplicationService extends ObjectService {
+    /** Service to Read and Write TM1 Applications
+     */
+
+    constructor(tm1Rest: RestService) {
+        /**
+         *
+         * :param tm1_rest:
+         */
+        super(tm1Rest);
+    }
+
+    public async getAllPublicRootNames(): Promise<string[]> {
+        const url = "/Contents('Applications')/Contents";
+        const response = await this.rest.get(url);
+        const applications = response.data.value.map((application: any) => application.Name);
+        return applications;
+    }
+
+    public async getAllPrivateRootNames(): Promise<string[]> {
+        const url = "/Contents('Applications')/PrivateContents";
+        const response = await this.rest.get(url);
+        const applications = response.data.value.map((application: any) => application.Name);
+        return applications;
+    }
+
+    public async getNames(path: string, isPrivate: boolean = false): Promise<string[]> {
+        /** Retrieve Planning Analytics Application names in given path
+         *
+         * :param path: path with forward slashes
+         * :param private: boolean
+         * :return: list of application names
+         */
+        const contents = isPrivate ? 'PrivateContents' : 'Contents';
+        let mid = "";
+        if (path.trim() !== '') {
+            mid = path.split('/').map(element => 
+                formatUrl("/Contents('{}')", element)).join('');
+        }
+        const baseUrl = "/api/v1/Contents('Applications')" + mid + "/" + contents;
+
+        const response = await this.rest.get(baseUrl);
+        const applications = response.data.value.map((application: any) => application.Name);
+        
+        return applications;
+    }
+
+    public async get(
+        path: string,
+        applicationType: string | ApplicationTypes,
+        name: string,
+        isPrivate: boolean = false
+    ): Promise<Application> {
+        /** Retrieve Planning Analytics Application
+         *
+         * :param path: path with forward slashes
+         * :param application_type: str or ApplicationType from Enum
+         * :param name:
+         * :param private:
+         * :return:
+         */
+        // Parse application type if string
+        let appType: ApplicationTypes;
+        if (typeof applicationType === 'string') {
+            appType = ApplicationTypes[applicationType as keyof typeof ApplicationTypes];
+            if (appType === undefined) {
+                throw new Error(`Invalid application type: ${applicationType}`);
+            }
+        } else {
+            appType = applicationType;
+        }
+
+        // documents require special treatment
+        if (appType === ApplicationTypes.DOCUMENT) {
+            return await this.getDocument(path, name, isPrivate);
+        }
+
+        if (appType !== ApplicationTypes.FOLDER && !verifyVersion('12', this.version)) {
+            name += this.getApplicationTypeSuffix(appType);
+        }
+
+        const contents = isPrivate ? 'PrivateContents' : 'Contents';
+        let mid = "";
+        if (path.trim() !== '') {
+            mid = path.split('/').map(element => 
+                formatUrl("/Contents('{}')", element)).join('');
+        }
+
+        const baseUrl = formatUrl(
+            "/Contents('Applications')" + mid + "/" + contents + "('{}')",
+            name);
+
+        if (appType === ApplicationTypes.CUBE) {
+            const response = await this.rest.get(baseUrl + "?$expand=Cube($select=Name)");
+            return new CubeApplication(name, path);
+
+        } else if (appType === ApplicationTypes.CHORE) {
+            const response = await this.rest.get(baseUrl + "?$expand=Chore($select=Name)");
+            return new ChoreApplication(name, path);
+
+        } else if (appType === ApplicationTypes.DIMENSION) {
+            const response = await this.rest.get(baseUrl + "?$expand=Dimension($select=Name)");
+            return new DimensionApplication(name, path);
+
+        } else if (appType === ApplicationTypes.FOLDER) {
+            const response = await this.rest.get(baseUrl);
+            return new FolderApplication(name, path);
+
+        } else if (appType === ApplicationTypes.LINK) {
+            const response = await this.rest.get(baseUrl);
+            return new LinkApplication(name, path);
+
+        } else if (appType === ApplicationTypes.PROCESS) {
+            const response = await this.rest.get(baseUrl + "?$expand=Process($select=Name)");
+            return new ProcessApplication(name, path);
+
+        } else if (appType === ApplicationTypes.SUBSET) {
+            const response = await this.rest.get(baseUrl + "?$expand=Subset($select=Name;$expand=Hierarchy($select=Name;$expand=Dimension($select=Name)))");
+            const subset = response.data.Subset;
+            return new SubsetApplication(name, path);
+
+        } else if (appType === ApplicationTypes.VIEW) {
+            const response = await this.rest.get(baseUrl + "?$expand=View($select=Name;$expand=Cube($select=Name))");
+            const view = response.data.View;
+            return new ViewApplication(name, path);
+
+        } else {
+            throw new Error(`Unsupported application type: ${appType}`);
+        }
+    }
+
+    public async getDocument(path: string, name: string, isPrivate: boolean = false): Promise<DocumentApplication> {
+        /** Get Document Application
+         *
+         * :param path: path with forward slashes
+         * :param name: name of the document
+         * :param private: boolean
+         * :return: DocumentApplication instance
+         */
+        const contents = isPrivate ? 'PrivateContents' : 'Contents';
+        let mid = "";
+        if (path.trim() !== '') {
+            mid = path.split('/').map(element => 
+                formatUrl("/Contents('{}')", element)).join('');
+        }
+
+        const baseUrl = formatUrl(
+            "/Contents('Applications')" + mid + "/" + contents + "('{}')",
+            name);
+
+        const response = await this.rest.get(baseUrl);
+        return new DocumentApplication(name, path);
+    }
+
+    public async create(application: Application, isPrivate: boolean = false): Promise<AxiosResponse> {
+        /** Create Planning Analytics Application
+         *
+         * :param application: instance of Application
+         * :param private: boolean
+         * :return: response
+         */
+        const contents = isPrivate ? 'PrivateContents' : 'Contents';
+        let mid = "";
+        if (application.path.trim() !== '') {
+            mid = application.path.split('/').map(element => 
+                formatUrl("/Contents('{}')", element)).join('');
+        }
+
+        const url = "/Contents('Applications')" + mid + "/" + contents;
+        return await this.rest.post(url, application.body);
+    }
+
+    public async update(application: Application, isPrivate: boolean = false): Promise<AxiosResponse> {
+        /** Update Planning Analytics Application
+         *
+         * :param application: instance of Application
+         * :param private: boolean
+         * :return: response
+         */
+        const contents = isPrivate ? 'PrivateContents' : 'Contents';
+        let mid = "";
+        if (application.path.trim() !== '') {
+            mid = application.path.split('/').map(element => 
+                formatUrl("/Contents('{}')", element)).join('');
+        }
+
+        const url = formatUrl(
+            "/Contents('Applications')" + mid + "/" + contents + "('{}')",
+            application.name);
+        return await this.rest.patch(url, application.body);
+    }
+
+    public async delete(path: string, applicationType: ApplicationTypes, name: string, isPrivate: boolean = false): Promise<AxiosResponse> {
+        /** Delete Planning Analytics Application
+         *
+         * :param path: path with forward slashes
+         * :param application_type: ApplicationType from Enum
+         * :param name: name of the application
+         * :param private: boolean
+         * :return: response
+         */
+        if (applicationType !== ApplicationTypes.FOLDER && !verifyVersion('12', this.version)) {
+            name += this.getApplicationTypeSuffix(applicationType);
+        }
+
+        const contents = isPrivate ? 'PrivateContents' : 'Contents';
+        let mid = "";
+        if (path.trim() !== '') {
+            mid = path.split('/').map(element => 
+                formatUrl("/Contents('{}')", element)).join('');
+        }
+
+        const url = formatUrl(
+            "/Contents('Applications')" + mid + "/" + contents + "('{}')",
+            name);
+        return await this.rest.delete(url);
+    }
+
+    public async exists(path: string, applicationType: ApplicationTypes, name: string, isPrivate: boolean = false): Promise<boolean> {
+        /** Check if Planning Analytics Application exists
+         *
+         * :param path: path with forward slashes
+         * :param application_type: ApplicationType from Enum
+         * :param name: name of the application
+         * :param private: boolean
+         * :return: boolean
+         */
+        try {
+            await this.get(path, applicationType, name, isPrivate);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    private getApplicationTypeSuffix(applicationType: ApplicationTypes): string {
+        switch (applicationType) {
+            case ApplicationTypes.CUBE:
+                return '.cube';
+            case ApplicationTypes.CHORE:
+                return '.chore';
+            case ApplicationTypes.DIMENSION:
+                return '.dimension';
+            case ApplicationTypes.PROCESS:
+                return '.process';
+            case ApplicationTypes.SUBSET:
+                return '.subset';
+            case ApplicationTypes.VIEW:
+                return '.view';
+            case ApplicationTypes.LINK:
+                return '.url';
+            default:
+                return '';
+        }
+    }
+
+    private get version(): string {
+        // This would need to be implemented to get TM1 server version
+        return '12.0.0'; // Default to v12 for now
+    }
+}