cloud-ide-core 0.0.1

package/esm2022/lib/core/designation-management/index.mjs

@@ -0,0 +1,5 @@
+// Designation Management Components
+export * from './components/designation-list/designation-list.component';
+// Designation Management Services
+export * from './services/designation-management.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbG91ZC1pZGUtY29yZS9zcmMvbGliL2NvcmUvZGVzaWduYXRpb24tbWFuYWdlbWVudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvQ0FBb0M7QUFDcEMsY0FBYywwREFBMEQsQ0FBQztBQUV6RSxrQ0FBa0M7QUFDbEMsY0FBYywyQ0FBMkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIERlc2lnbmF0aW9uIE1hbmFnZW1lbnQgQ29tcG9uZW50c1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvZGVzaWduYXRpb24tbGlzdC9kZXNpZ25hdGlvbi1saXN0LmNvbXBvbmVudCc7XHJcblxyXG4vLyBEZXNpZ25hdGlvbiBNYW5hZ2VtZW50IFNlcnZpY2VzXHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZGVzaWduYXRpb24tbWFuYWdlbWVudC5zZXJ2aWNlJzsgIl19

package/esm2022/lib/core/designation-management/services/designation-management.service.mjs

@@ -0,0 +1,194 @@
+import { Injectable } from '@angular/core';
+import { throwError, BehaviorSubject } from 'rxjs';
+import { catchError, tap } from 'rxjs/operators';
+import { cidePath, coreRoutesUrl, generateStringFromObject, hostManagerRoutesUrl, MDesignationInsertUpdatePayload, } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class DesignationManagementService {
+    constructor(http) {
+        this.http = http;
+        this.apiUrl = `${coreRoutesUrl?.designation}`;
+        this.designationListSubject = new BehaviorSubject([]);
+        this.designationList$ = this.designationListSubject.asObservable();
+        console.log('DesignationManagementService initialized - using real API');
+    }
+    /**
+     * Get designation list from API
+     */
+    getDesignationList(body) {
+        const query = generateStringFromObject(body);
+        return this.http?.get(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, query]))
+            .pipe(tap((response) => {
+            if (response?.success) {
+                this.designationListSubject.next(response?.data || []);
+            }
+        }), catchError(error => {
+            console.error('DesignationManagementService API error:', error);
+            return this.handleError(error);
+        }));
+    }
+    /**
+     * Get designation list from cache (if available)
+     */
+    getDesignationListFromCache() {
+        return this.designationListSubject.value;
+    }
+    /**
+     * Create new designation
+     * POST ${coreRoutesUrl?.designation} - payload: MDesignationInsertUpdatePayload, response: designationInsertUpdateControllerResponse
+     */
+    createDesignation(designation) {
+        console.log('Creating designation:', designation);
+        // Create proper payload using MDesignationInsertUpdatePayload
+        const payload = new MDesignationInsertUpdatePayload(designation);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation]);
+        return this.http.post(url, payload)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDesignationList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Update existing designation
+     * POST ${coreRoutesUrl?.designation} - payload: MDesignationInsertUpdatePayload, response: designationInsertUpdateControllerResponse
+     */
+    updateDesignation(id, designation) {
+        console.log('Updating designation:', id, designation);
+        // Create proper payload using MDesignationInsertUpdatePayload
+        const payload = new MDesignationInsertUpdatePayload(designation);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation]);
+        return this.http.post(url, payload)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDesignationList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Get designation by ID
+     * GET ${coreRoutesUrl?.designation}/byId/:query - payload: MDesignationGetByIdPayload, response: designationByIdControllerResponse
+     */
+    getDesignationById(id) {
+        console.log('Getting designation by ID:', id);
+        const payload = { sydsg_id: id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, 'byId', query]);
+        return this.http.get(url)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Delete designation
+     * DELETE ${coreRoutesUrl?.designation}/:query - payload: MDesignationDeletePayload, response: designationDeleteControllerResponse
+     */
+    deleteDesignation(id) {
+        const payload = { sydsg_id: id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDesignationList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Delete multiple designations
+     */
+    deleteMultipleDesignations(ids) {
+        console.log('Deleting multiple designations:', ids);
+        const payload = { ids };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDesignationList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Toggle designation active status
+     */
+    toggleDesignationStatus(id) {
+        console.log('Toggling designation status:', id);
+        const payload = { id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, query]);
+        return this.http.put(url, {})
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDesignationList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Find designation by ID
+     */
+    findDesignationById(id, items = this.designationListSubject.value) {
+        for (const item of items) {
+            if (item._id === id) {
+                return item;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get parent designations for dropdown selection
+     */
+    getParentDesignations(excludeId) {
+        const allItems = [];
+        const flattenItems = (items, level = 0) => {
+            items.forEach(item => {
+                if (item._id !== excludeId) {
+                    allItems.push({
+                        ...item,
+                        sydsg_name: '  '.repeat(level) + item.sydsg_name
+                    });
+                }
+            });
+        };
+        flattenItems(this.designationListSubject.value);
+        return allItems;
+    }
+    /**
+     * Refresh designation list from server
+     */
+    refreshDesignationList() {
+        const defaultBody = {
+            pageIndex: 1,
+            pageSize: 10
+        };
+        this.getDesignationList(defaultBody).subscribe({
+            next: () => {
+                console.log('Designation list refreshed successfully');
+            },
+            error: (error) => {
+                console.error('Error refreshing designation list:', error);
+            }
+        });
+    }
+    /**
+     * Handle errors
+     */
+    handleError(error) {
+        let errorMessage = 'An error occurred';
+        if (error instanceof Error) {
+            errorMessage = error.message;
+        }
+        else if (typeof error === 'string') {
+            errorMessage = error;
+        }
+        console.error('Designation Management Service Error:', errorMessage);
+        return throwError(() => new Error(errorMessage));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: DesignationManagementService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: DesignationManagementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: DesignationManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"designation-management.service.js","sourceRoot":"","sources":["../../../../../../../projects/cloud-ide-core/src/lib/core/designation-management/services/designation-management.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, throwError, BehaviorSubject } from 'rxjs';\nimport { catchError, tap } from 'rxjs/operators';\nimport { \n  cidePath, \n  coreRoutesUrl, \n  generateStringFromObject, \n  hostManagerRoutesUrl, \n  ICoreSydsg, \n  MDesignationDeletePayload, \n  MDesignationGetByIdPayload, \n  MDesignationInsertUpdatePayload,\n  designationByIdControllerResponse, \n  designationDeleteControllerResponse, \n  designationControllerResponse,\n  designationInsertUpdateControllerResponse,\n  MDesignation,\n} from 'cloud-ide-lms-model';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DesignationManagementService {\n  private apiUrl = `${coreRoutesUrl?.designation}`;\n  private designationListSubject = new BehaviorSubject<ICoreSydsg[]>([]);\n  public designationList$ = this.designationListSubject.asObservable();\n\n  constructor(private http: HttpClient) {\n    console.log('DesignationManagementService initialized - using real API');\n  }\n\n  /**\n   * Get designation list from API\n   */\n  getDesignationList(body: MDesignation): Observable<designationControllerResponse> {\n    const query = generateStringFromObject(body);\n    return this.http?.get<designationControllerResponse>(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, query]))\n      .pipe(\n        tap((response: designationControllerResponse) => {\n          if (response?.success) {\n            this.designationListSubject.next(response?.data || []);\n          }\n        }),\n        catchError(error => {\n          console.error('DesignationManagementService API error:', error);\n          return this.handleError(error);\n        })\n      );\n  }\n\n  /**\n   * Get designation list from cache (if available)\n   */\n  getDesignationListFromCache(): ICoreSydsg[] {\n    return this.designationListSubject.value;\n  }\n\n  /**\n   * Create new designation\n   * POST ${coreRoutesUrl?.designation} - payload: MDesignationInsertUpdatePayload, response: designationInsertUpdateControllerResponse\n   */\n  createDesignation(designation: ICoreSydsg): Observable<designationInsertUpdateControllerResponse> {\n    console.log('Creating designation:', designation);\n    \n    // Create proper payload using MDesignationInsertUpdatePayload\n    const payload = new MDesignationInsertUpdatePayload(designation);\n    \n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation]);\n    return this.http.post<designationInsertUpdateControllerResponse>(url, payload)\n      .pipe(\n        tap((response: designationInsertUpdateControllerResponse) => {\n          if (response.success) {\n            this.refreshDesignationList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Update existing designation\n   * POST ${coreRoutesUrl?.designation} - payload: MDesignationInsertUpdatePayload, response: designationInsertUpdateControllerResponse\n   */\n  updateDesignation(id: string, designation: ICoreSydsg): Observable<designationInsertUpdateControllerResponse> {\n    console.log('Updating designation:', id, designation);\n    \n    // Create proper payload using MDesignationInsertUpdatePayload\n    const payload = new MDesignationInsertUpdatePayload(designation);\n    \n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation]);\n    return this.http.post<designationInsertUpdateControllerResponse>(url, payload)\n      .pipe(\n        tap((response: designationInsertUpdateControllerResponse) => {\n          if (response.success) {\n            this.refreshDesignationList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Get designation by ID\n   * GET ${coreRoutesUrl?.designation}/byId/:query - payload: MDesignationGetByIdPayload, response: designationByIdControllerResponse\n   */\n  getDesignationById(id: string): Observable<designationByIdControllerResponse> {\n    console.log('Getting designation by ID:', id);\n    const payload: MDesignationGetByIdPayload = { sydsg_id: id };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, 'byId', query]);\n    return this.http.get<designationByIdControllerResponse>(url)\n      .pipe(\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Delete designation\n   * DELETE ${coreRoutesUrl?.designation}/:query - payload: MDesignationDeletePayload, response: designationDeleteControllerResponse\n   */\n  deleteDesignation(id: string): Observable<designationDeleteControllerResponse> {\n    const payload: MDesignationDeletePayload = { sydsg_id: id };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, query]);\n    return this.http.delete<designationDeleteControllerResponse>(url)\n      .pipe(\n        tap((response: designationDeleteControllerResponse) => {\n          if (response.success) {\n            this.refreshDesignationList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Delete multiple designations\n   */\n  deleteMultipleDesignations(ids: string[]): Observable<{ success: boolean; message?: string; data?: unknown }> {\n    console.log('Deleting multiple designations:', ids);\n    const payload = { ids };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, query]);\n    return this.http.delete<{ success: boolean; message?: string; data?: unknown }>(url)\n      .pipe(\n        tap((response: { success: boolean; message?: string; data?: unknown }) => {\n          if (response.success) {\n            this.refreshDesignationList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Toggle designation active status\n   */\n  toggleDesignationStatus(id: string): Observable<designationControllerResponse> {\n    console.log('Toggling designation status:', id);\n    const payload = { id };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.designation, query]);\n    return this.http.put<designationControllerResponse>(url, {})\n      .pipe(\n        tap((response: designationControllerResponse) => {\n          if (response.success) {\n            this.refreshDesignationList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Find designation by ID\n   */\n  findDesignationById(id: string, items: ICoreSydsg[] = this.designationListSubject.value): ICoreSydsg | null {\n    for (const item of items) {\n      if (item._id === id) {\n        return item;\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Get parent designations for dropdown selection\n   */\n  getParentDesignations(excludeId?: string): ICoreSydsg[] {\n    const allItems: ICoreSydsg[] = [];\n\n    const flattenItems = (items: ICoreSydsg[], level: number = 0) => {\n      items.forEach(item => {\n        if (item._id !== excludeId) {\n          allItems.push({\n            ...item,\n            sydsg_name: '  '.repeat(level) + item.sydsg_name\n          });\n        }\n      });\n    };\n\n    flattenItems(this.designationListSubject.value);\n    return allItems;\n  }\n\n  /**\n   * Refresh designation list from server\n   */\n  private refreshDesignationList(): void {\n    const defaultBody = {\n      pageIndex: 1,\n      pageSize: 10\n    };\n    this.getDesignationList(defaultBody).subscribe({\n      next: () => {\n        console.log('Designation list refreshed successfully');\n      },\n      error: (error) => {\n        console.error('Error refreshing designation list:', error);\n      }\n    });\n  }\n\n  /**\n   * Handle errors\n   */\n  private handleError(error: unknown): Observable<never> {\n    let errorMessage = 'An error occurred';\n\n    if (error instanceof Error) {\n      errorMessage = error.message;\n    } else if (typeof error === 'string') {\n      errorMessage = error;\n    }\n\n    console.error('Designation Management Service Error:', errorMessage);\n    return throwError(() => new Error(errorMessage));\n  }\n} "]}