@techextensor/tab-sdk 0.0.0

package/projects/tab-sdk/src/lib/tab-sdk.service.ts

@@ -0,0 +1,84 @@
+import { Injectable, Injector } from '@angular/core';
+import { MetadataHelper } from '@techextensor/tab-core-utility';
+import { UiService } from './ui/ui.service';
+import { AuthUtilService } from './auth/auth.service';
+import { FormService } from './ui/form.service';
+import { TransitionService } from './workflow/transition.service';
+import { AppService } from './app/app.service';
+import { FileService } from './app/file.service';
+import { ReportService } from './app/report.service';
+import { ReleaseService } from './app/release.service';
+import { AnalyticsService } from './app/analytics.service';
+import { TranslatorService } from './app/translator.service';
+import { CrudService } from './crud/crud.service';
+import { HttpService } from './http/http.service';
+import { StoreService } from './store/store.service';
+import { UtilService } from './util/util.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class TabSdk {
+  public static app: AppService;
+  public static auth: AuthUtilService;
+  public static ui: UiService;
+  public static form: FormService;
+  public static transition: TransitionService;
+  public static metadataUtils: MetadataHelper;
+  public static file: FileService;
+  public static report: ReportService;
+  public static release: ReleaseService;
+  public static analytics: AnalyticsService;
+  public static translator: TranslatorService;
+  public static crud: CrudService;
+  public static http: HttpService;
+  public static store: StoreService;
+  public static util: any;
+
+
+  /**
+   * Initialize the SDK with necessary services
+   */
+  public static init(injector: Injector, context: any): void {
+    // Expose to window for global access if needed
+    (window as any).TabSdk = TabSdk;
+
+    // Initialize services
+    this.app = injector.get(AppService);
+    this.auth = injector.get(AuthUtilService);
+    this.ui = injector.get(UiService);
+    this.form = injector.get(FormService);
+    this.transition = injector.get(TransitionService);
+    this.metadataUtils = injector.get(MetadataHelper);
+    this.file = injector.get(FileService);
+    this.report = injector.get(ReportService);
+    this.release = injector.get(ReleaseService);
+    this.analytics = injector.get(AnalyticsService);
+    this.translator = injector.get(TranslatorService);
+    this.crud = injector.get(CrudService);
+    this.http = injector.get(HttpService);
+    this.store = injector.get(StoreService);
+
+    // Initialize util service with context
+    const utilService = injector.get(UtilService);
+    this.util = utilService.init(context);
+
+    // Freeze the global object to prevent modifications
+    Object.freeze(this);
+    
+    Object.freeze(this.app);
+    Object.freeze(this.auth);
+    Object.freeze(this.ui);
+    Object.freeze(this.form);
+    Object.freeze(this.transition);
+    Object.freeze(this.file);
+    Object.freeze(this.report);
+    Object.freeze(this.release);
+    Object.freeze(this.analytics);
+    Object.freeze(this.translator);
+    Object.freeze(this.crud);
+    Object.freeze(this.http);
+    Object.freeze(this.store);
+    Object.freeze(this.util);
+  }
+}

package/projects/tab-sdk/src/lib/ui/form.service.ts

@@ -0,0 +1,92 @@
+import { inject, Injectable } from '@angular/core';
+import { BuildFormComponentType, CommonApiResponse, GetScreenConfig, ProcessRequestPayload, TabFormioService, TemplateHelper, TemplateParsePayload } from '@techextensor/tab-core-utility';
+import { firstValueFrom } from 'rxjs';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class FormService {
+    private readonly _tabFormioService: TabFormioService = inject(TabFormioService);
+    private readonly _templateHelper: TemplateHelper = inject(TemplateHelper);
+
+    /**
+     * Retrieves a screen by its ID.
+     *
+     * @param screenId The ID of the screen to retrieve.
+     * @param config Optional configuration object for the request.
+     * @returns A promise of the response from the server.
+     */
+    async getScreen(screenId: string, config?: GetScreenConfig): Promise<CommonApiResponse> {
+        const response = await firstValueFrom(
+            this._tabFormioService.getScreen(screenId, config)
+        );
+        return response;
+    }
+
+    /**
+     * Retrieves the data for a screen by its ID.
+     *
+     * @param screenId The ID of the screen to retrieve the data for.
+     * @param requestPayload The request payload to send to the server.
+     * @returns A promise of the response from the server.
+     */
+    async getScreenData(screenId: string, requestPayload: any): Promise<CommonApiResponse> {
+        // Send the request to the server and get the response.
+        const response = await firstValueFrom(
+            this._tabFormioService.getScreenData(screenId, requestPayload)
+        );
+
+        // Return the response from the server.
+        return response;
+    }
+
+    /**
+     * Processes a request using the provided request payload.
+     *
+     * @param requestPayload The payload to be processed.
+     * @returns A promise of the response from the server.
+     */
+    async processRequest(requestPayload: ProcessRequestPayload): Promise<CommonApiResponse> {
+        // Send the request payload to the server and await the response.
+        const response = await firstValueFrom(
+            this._tabFormioService.processRequest(requestPayload)
+        );
+
+        // Return the server's response.
+        return response;
+    }
+
+    /**
+     * Builds Form.io components for the specified app object ID and type.
+     *
+     * @param appObjectId The ID of the app object to build the components for.
+     * @param type The type of components to build.
+     * @returns A promise of the response from the server.
+     */
+    async buildFormIOComponents(appObjectId: string, type: BuildFormComponentType): Promise<CommonApiResponse> {
+        // Send the request to the server to build the components.
+        const response = await firstValueFrom(
+            this._tabFormioService.buildFormIOComponents(appObjectId, type)
+        );
+
+        // Return the response from the server.
+        return response;
+    }
+
+    /**
+     * Parses a template using the provided request payload.
+     *
+     * @param requestPayload The payload containing the template to be parsed.
+     * @param onFailedParseOnServer If the parsing should be done on the server.
+     * @returns A promise of the response from the server.
+     */
+    async parseTemplate(requestPayload: TemplateParsePayload, onFailedParseOnServer = false): Promise<CommonApiResponse> {
+        // Send the request to the server to parse the template.
+        const response = await firstValueFrom(
+            this._templateHelper.templateParseUniversal(requestPayload, onFailedParseOnServer)
+        );
+
+        // Return the response from the server.
+        return response;
+    }
+}

package/projects/tab-sdk/src/lib/ui/ui.service.ts

@@ -0,0 +1,404 @@
+import { inject, Injectable } from '@angular/core';
+import {
+    ScreenOpenOptions,
+    NavigationOptions,
+    BaseScreenOptions,
+    NavigateToSubdomainOptions
+} from '../interface/ui.interface';
+import { NavigationType, ScreenDisplayMode } from '../enum/ui.enum';
+import { TabSdk } from '../tab-sdk.service';
+import { BaseNotificationOptions, ConfirmationOptions, ConfirmationService, NotificationOptions, NotificationService, NotificationType } from '@techextensor/tab-core-utility';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class UiService {
+    private readonly _notificationService: NotificationService = inject(NotificationService);
+    private readonly _confirmationService: ConfirmationService = inject(ConfirmationService);
+
+    /**
+     * Open a screen with the given options. The mode determines how the screen is
+     * displayed.
+     *
+     * @param options The options for opening the screen.
+     */
+    openScreen(options: ScreenOpenOptions): void {
+        const { mode, ...otherOptions } = options;
+
+        switch (mode) {
+            case ScreenDisplayMode.Sidebar:
+                this.showSidebar(otherOptions);
+                break;
+
+            case ScreenDisplayMode.Popup:
+                this.showDialog(otherOptions);
+                break;
+
+            case ScreenDisplayMode.SameTab:
+                this.navigateTo(otherOptions);
+                break;
+
+            case ScreenDisplayMode.NewTab:
+                this.openInNewTab(otherOptions);
+                break;
+        }
+    }
+
+    /**
+     * Opens a screen in a sidebar.
+     *
+     * @param options The options for opening the sidebar.
+     */
+    showSidebar(options: BaseScreenOptions): void {
+        const otherConfiguration = {
+            ...(options.title && { title: options.title }),
+            ...(options.width && { width: options.width }),
+            ...(options.height && { height: options.height }),
+            ...(options.customClass && { customClass: options.customClass }),
+            ...(options.refresher && { refresher: options.refresher }),
+            ...(options.closer && { closer: options.closer })
+        };
+
+        TabSdk.util?.openScreen(
+            ScreenDisplayMode.Sidebar,
+            options.screenId,
+            options.reqtokens || undefined,
+            options.submission || undefined,
+            Object.keys(otherConfiguration).length > 0 ? otherConfiguration : undefined
+        );
+    }
+
+    /**
+     * Opens a screen in a popup dialog.
+     *
+     * @param options The options for opening the dialog.
+     */
+    showDialog(options: BaseScreenOptions): void {
+        const otherConfiguration = {
+            ...(options.title && { title: options.title }),
+            ...(options.width && { width: options.width }),
+            ...(options.height && { height: options.height }),
+            ...(options.customClass && { customClass: options.customClass }),
+            ...(options.refresher && { refresher: options.refresher }),
+            ...(options.closer && { closer: options.closer })
+        };
+
+        TabSdk.util?.openScreen(
+            ScreenDisplayMode.Popup,
+            options.screenId,
+            options.reqtokens || undefined,
+            options.submission || undefined,
+            Object.keys(otherConfiguration).length > 0 ? otherConfiguration : undefined
+        );
+    }
+
+    /**
+     * Navigates to a screen within the same tab.
+     *
+     * @param options - The options for navigation, including screenId and optional reqtokens.
+     */
+    navigateTo(options: NavigationOptions): void {
+        TabSdk.util?.openScreen(
+            ScreenDisplayMode.SameTab,
+            options.screenId,
+            options.reqtokens || undefined
+        );
+    }
+
+    /**
+     * Navigates to a screen in a new tab.
+     *
+     * @param options The options for navigation, including screenId and optional reqtokens.
+     */
+    openInNewTab(options: NavigationOptions): void {
+        TabSdk.util?.openScreen(
+            ScreenDisplayMode.NewTab,
+            options.screenId,
+            options.reqtokens || undefined
+        );
+    }
+
+    /**
+     * Navigates to the specified URL.
+     *
+     * @param url - The URL to navigate to.
+     */
+    navigateToUrl(params: { url: string, extras?: any, replaceUrl?: boolean }): void {
+        TabSdk.util?.navigateTo({
+            ...params,
+            type: NavigationType.NavigateToUrl
+        })
+    }
+
+    /**
+     * Navigates to a specified subdomain using the provided options.
+     *
+     * @param options - The options for navigation, including subDomain, appCode, and url.
+     */
+    navigateToSubdomain(options: NavigateToSubdomainOptions): void {
+        TabSdk.util?.navigateTo({
+            ...options,
+            type: NavigationType.NavigateToSubdomain
+        })
+    }
+
+    /**
+     * Retrieves the active screen ID from the current URL.
+     *
+     * @returns The screen ID if present in the URL, otherwise undefined.
+     */
+    getActiveUrlScreenId(): string | undefined {
+        // Split the URL pathname into parts using the '/' character as a delimiter
+        const urlParts = window?.location?.pathname?.split('/');
+        // Extract the screen ID part and remove any query parameters
+        const screenId = urlParts?.length > 1 ? urlParts?.[urlParts?.length - 1]?.split('?')[0] : undefined;
+        // Return the screen ID or undefined if not found
+        return screenId;
+    }
+
+    /**
+     * Retrieves the active redirect URL by combining the active screen ID and any query parameters.
+     *
+     * @returns The constructed redirect URL or undefined if no screen ID is present.
+     */
+    getActiveRedirectUrl(): string | undefined {
+        // Get the active screen ID from the current URL
+        const screenId = this.getActiveUrlScreenId();
+        let redirectURL;
+
+        // Check if the current URL contains a screen ID
+        if (screenId) {
+            // Initialize the redirect URL with the screen ID
+            redirectURL = screenId;
+
+            // Parse the current URL's query parameters
+            const queryParams = new URLSearchParams(window.location.search);
+
+            // If there are query parameters, append them to the redirect URL
+            if (queryParams.toString()) {
+                redirectURL += `&${queryParams.toString()}`;
+            }
+        }
+
+        // Return the constructed redirect URL or undefined
+        return redirectURL;
+    }
+
+    /**
+     * Show a notification to the user.
+     *
+     * @param options The options for the notification.
+     */
+    notify(options: NotificationOptions) {
+        return this._notificationService.notify({
+            type: options.type,
+            message: TabSdk.translator.translate(options.message),
+            ...(options?.title ? { title: TabSdk.translator.translate(options.title) } : {}),
+            ...(options?.configuration ? { configuration: options.configuration } : {}),
+        });
+    }
+
+    /**
+     * Displays a success notification to the user.
+     *
+     * @param options - The options for the notification, including message, title, and configuration.
+     */
+    showSuccess(options: BaseNotificationOptions) {
+        return this.notify({
+            ...options,
+            type: NotificationType.Success,
+            title: options?.title ?? 'Success'
+        });
+    }
+
+    /**
+     * Displays a warning notification to the user.
+     *
+     * @param options - The options for the notification, including message, title, and configuration.
+     */
+    showWarning(options: BaseNotificationOptions) {
+        return this.notify({
+            ...options,
+            type: NotificationType.Warning,
+            title: options?.title ?? 'Warning'
+        });
+    }
+
+    /**
+     * Displays an info notification to the user.
+     *
+     * @param options - The options for the notification, including message, title, and configuration.
+     */
+    showInfo(options: BaseNotificationOptions) {
+        return this.notify({
+            ...options,
+            type: NotificationType.Info,
+            title: options?.title ?? 'Info'
+        });
+    }
+
+    /**
+     * Displays an error notification to the user.
+     *
+     * @param options - The options for the notification, including message, title, and configuration.
+     */
+    showError(options: BaseNotificationOptions) {
+        return this.notify({
+            ...options,
+            type: NotificationType.Error,
+            title: options?.title ?? 'Error'
+        });
+    }
+
+    /**
+     * Clears a notification by ID.
+     *
+     * @param notificationId - The ID of the notification to clear.
+     * @returns The cleared notification, or null if the notification doesn't exist.
+     */
+    clearNotification(notificationId: number) {
+        return this._notificationService.clearNotification(notificationId);
+    }
+
+    /**
+     * Displays a confirmation dialog to the user and returns a promise that resolves
+     * to a boolean indicating whether the user confirmed the action.
+     *
+     * @param options - The options for the confirmation dialog, including title, message,
+     * confirmText, cancelText, and visibility of buttons.
+     * @returns A promise that resolves to true if the user confirms, false otherwise.
+     */
+    confirm(options?: ConfirmationOptions): Promise<boolean> {
+        return new Promise((resolve) => {
+            this._confirmationService.confirm(options)
+                ?.subscribe((isConfirmed: boolean) => {
+                    resolve(isConfirmed);
+                });
+        });
+    }
+
+    /**
+     * Displays a confirmation dialog to the user with a title and message that indicates
+     * the user is about to delete an item. The confirmation dialog has a "Delete" and "Cancel"
+     * button.
+     *
+     * @param options - The options for the confirmation dialog, including the item name and
+     * optional message.
+     * @returns A promise that resolves to true if the user confirms, false otherwise.
+     */
+    confirmDelete(options?: ConfirmationOptions): Promise<boolean> {
+        return this.confirm({
+            title: options?.title ?? `Are you sure you want to delete this record`,
+            message: options?.message ?? `You are about to delete the selected record. Are you sure you want to proceed?`,
+            primaryOption: 'Delete',
+        });
+    }
+
+    /**
+     * Displays a confirmation dialog to the user with a title and message that indicates
+     * the user is about to discard changes to an item. The confirmation dialog has a "Discard"
+     * and "Cancel" button.
+     *
+     * @param options - The options for the confirmation dialog, including the item name and
+     * optional message.
+     * @returns A promise that resolves to true if the user confirms, false otherwise.
+     */
+    confirmDiscard(options?: ConfirmationOptions): Promise<boolean> {
+        return this.confirm({
+            title: `Are you sure you want to discard your changes`,
+            message: options?.message ?? `You are about to discard your changes. Are you sure you want to proceed?`,
+            primaryOption: 'Discard',
+        });
+    }
+
+    /**
+     * Closes the confirmation dialog.
+     *
+     * This method can be used to manually close the confirmation dialog.
+     */
+    closeConfirmationDialog() {
+        // Close the confirmation dialog
+        this._confirmationService.closeDialog();
+    }
+
+    /**
+     * Retrieves the confirmation emitter from the confirmation service.
+     * 
+     * @returns The confirmation emitter used for emitting confirmation events.
+     */
+    getConformationEmitter() {
+        return this._confirmationService.getConformationEmitter();
+    }
+
+    /**
+     * Retrieves the dialog emitter from the confirmation service.
+     *
+     * The dialog emitter is an RxJS Subject that emits whenever a confirmation dialog is
+     * opened or closed. The value emitted is a boolean indicating whether a dialog is
+     * currently open.
+     *
+     * @returns The dialog emitter used for emitting confirmation dialog events.
+     */
+    getDialogEmitter() {
+        return this._confirmationService.getDialogEmitter();
+    }
+
+    /**
+     * Retrieves the remove emitter from the confirmation service.
+     * 
+     * The remove emitter is an RxJS Subject that emits whenever a removal confirmation
+     * dialog is opened or closed. The value emitted is a boolean indicating whether a
+     * removal dialog is currently open.
+     * 
+     * @returns The remove emitter used for emitting removal confirmation dialog events.
+     */
+    getRemoveEmitter() {
+        return this._confirmationService.getRemoveEmitter();
+    }
+
+    /**
+     * Copies the provided text to the clipboard and displays a success notification.
+     *
+     * @param text - The text to be copied to the clipboard.
+     */
+    copyToClipboard(text: string) {
+        // Create a temporary input element to hold the text
+        const tempInput = document.createElement("input");
+
+        // Set the input's value to the text to be copied
+        tempInput.value = text;
+
+        // Append the temporary input to the document body
+        document.body.appendChild(tempInput);
+
+        // Select the text in the input element
+        tempInput.select();
+
+        // Execute the copy command
+        document.execCommand("copy");
+
+        // Remove the temporary input from the document body
+        document.body.removeChild(tempInput);
+
+        // Show a success notification
+        this.showSuccess({
+            message: "",
+            title: "Copied to clipboard!",
+            configuration: {
+                timeOut: 1000,
+                positionClass: 'toast-top-center',
+                easing: 'ease-in',
+                easeTime: 300,
+                extendedTimeOut: 2000,
+            }
+        });
+    }
+
+    /**
+     * Copies the current URL to the clipboard and displays a success notification.
+     */
+    copyCurrentUrlToClipboard() {
+        // Use the copyToClipboard method to copy the current window URL
+        this.copyToClipboard(window.location.href);
+    }
+}

package/projects/tab-sdk/src/lib/util/util.service.ts

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class UtilService {
+    // Will store the services from context
+    private _context: any = null;
+    private _initialized = false;
+
+    /**
+     * Initializes the UtilService with context that contains service references
+     * 
+     * @param context The context object containing service references
+     * @returns A proxy that intercepts and delegates method calls to the appropriate service
+     */
+    init(context: any): any {
+        if (this._initialized) {
+            return this;
+        }
+
+        this._context = context;
+        this._initialized = true;
+
+        // Return a proxy that will intercept method calls
+        return new Proxy(this, {
+            get: (target: any, prop: string | symbol) => {
+                // First check if the property exists directly on UtilService
+                if (prop in target) {
+                    return (target as any)[prop];
+                }
+
+                // Convert symbol to string if needed
+                const propName = prop.toString();
+
+                // Check context services first
+                if (this._context && Object.keys(this._context).length > 0) {
+                    // Loop through each service in the context
+                    for (const serviceName of Object.keys(this._context)) {
+                        const service = this._context[serviceName];
+                        if (service && typeof service === 'object' && propName in service && typeof service[propName] === 'function') {
+                            // Return the bound function from the service
+                            return service[propName].bind(service);
+                        }
+                    }
+                }
+
+                // If property not found anywhere, return undefined
+                return undefined;
+            }
+        });
+    }
+}

package/projects/tab-sdk/src/lib/workflow/transition.service.ts

@@ -0,0 +1,40 @@
+import { inject, Injectable } from '@angular/core';
+import { CommonApiResponse, NextStatusPayload, TabBlueprintService, UpdateStatusPayload } from '@techextensor/tab-core-utility';
+import { firstValueFrom } from 'rxjs';
+import { TabSdk } from '../tab-sdk.service';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class TransitionService {
+    private readonly _tabBlueprintService: TabBlueprintService = inject(TabBlueprintService);
+
+    /**
+     * Retrieves the next status based on the provided payload.
+     *
+     * @param payload - The payload containing information to determine the next status.
+     * @returns A promise that resolves to the common API response.
+     */
+    async getNextStatus(payload: NextStatusPayload): Promise<CommonApiResponse> {
+        // Await the response from the getNextStatus method of the tabBlueprintService
+        const response = await firstValueFrom(
+            this._tabBlueprintService.getNextStatus(payload)
+        );
+        // Return the obtained response
+        return response;
+    }
+
+    /**
+     * Updates the status of an entity based on the provided payload.
+     *
+     * @param payload - The payload containing information to update the status.
+     * @returns A promise that resolves to the common API response.
+     */
+    async updateStatus(payload: UpdateStatusPayload): Promise<any> {
+        const response = await firstValueFrom(
+            TabSdk.util?.updateStatus(payload)
+        );
+        // Return the obtained response
+        return response;
+    }
+}

package/projects/tab-sdk/src/public-api.ts

@@ -0,0 +1,10 @@
+// SDK
+export * from './lib/tab-sdk.service';
+
+// Enums
+export * from './lib/enum/ui.enum';
+export * from './lib/enum/store.enum';
+
+// Interfaces
+export * from './lib/interface/ui.interface';
+export * from './lib/interface/http.interface';