cloud-ide-core 0.0.1

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

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

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

@@ -0,0 +1,187 @@
+import { Injectable } from '@angular/core';
+import { throwError, BehaviorSubject } from 'rxjs';
+import { catchError, tap } from 'rxjs/operators';
+import { cidePath, coreRoutesUrl, generateStringFromObject, hostManagerRoutesUrl } from 'cloud-ide-lms-model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class DepartmentManagementService {
+    constructor(http) {
+        this.http = http;
+        this.departmentListSubject = new BehaviorSubject([]);
+        this.departmentList$ = this.departmentListSubject.asObservable();
+        console.log('DepartmentManagementService initialized - using real API');
+    }
+    /**
+     * Get department list from API
+     */
+    getDepartmentList(body) {
+        const query = generateStringFromObject(body);
+        return this.http?.get(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, query]))
+            .pipe(tap((response) => {
+            if (response?.success) {
+                this.departmentListSubject.next(response?.data || []);
+            }
+        }), catchError(error => {
+            console.error('DepartmentManagementService API error:', error);
+            return this.handleError(error);
+        }));
+    }
+    /**
+     * Get department list from cache (if available)
+     */
+    getDepartmentListFromCache() {
+        return this.departmentListSubject.value;
+    }
+    /**
+     * Create new department
+     * POST ${coreRoutesUrl?.department} - payload: MDepartmentInsertUpdatePayload, response: departmentInsertUpdateControllerResponse
+     */
+    createDepartment(department) {
+        console.log('Creating department:', department);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department]);
+        return this.http.post(url, department)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDepartmentList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Update existing department
+     * POST ${coreRoutesUrl?.department} - payload: MDepartmentInsertUpdatePayload, response: departmentInsertUpdateControllerResponse
+     */
+    updateDepartment(id, department) {
+        console.log('Updating department:', id, department);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department]);
+        return this.http.post(url, department)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDepartmentList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Get department by ID
+     * GET ${coreRoutesUrl?.department}/byId/:query - payload: MDepartmentGetByIdPayload, response: departmentByIdControllerResponse
+     */
+    getDepartmentById(id) {
+        console.log('Getting department by ID:', id);
+        const payload = { sydept_id: id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, 'byId', query]);
+        return this.http.get(url)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Delete department
+     * DELETE ${coreRoutesUrl?.department}/:query - payload: MDepartmentDeletePayload, response: departmentDeleteControllerResponse
+     */
+    deleteDepartment(id) {
+        const payload = { sydept_id: id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDepartmentList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Delete multiple departments
+     */
+    deleteMultipleDepartments(ids) {
+        console.log('Deleting multiple departments:', ids);
+        const payload = { ids };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDepartmentList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Toggle department active status
+     */
+    toggleDepartmentStatus(payload) {
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, 'toggleStatus', query]);
+        return this.http.put(url, {})
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshDepartmentList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Find department by ID
+     */
+    findDepartmentById(id, items = this.departmentListSubject.value) {
+        for (const item of items) {
+            if (item._id === id) {
+                return item;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get parent departments for dropdown selection
+     */
+    getParentDepartments(excludeId) {
+        const allItems = [];
+        const flattenItems = (items, level = 0) => {
+            items.forEach(item => {
+                if (item._id !== excludeId) {
+                    allItems.push({
+                        ...item,
+                        sydept_name: '  '.repeat(level) + item.sydept_name
+                    });
+                }
+            });
+        };
+        flattenItems(this.departmentListSubject.value);
+        return allItems;
+    }
+    /**
+     * Refresh department list from server
+     */
+    refreshDepartmentList() {
+        const defaultBody = {
+            pageIndex: 1,
+            pageSize: 10
+        };
+        this.getDepartmentList(defaultBody).subscribe({
+            next: () => {
+                console.log('Department list refreshed successfully');
+            },
+            error: (error) => {
+                console.error('Error refreshing department 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('Department 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: DepartmentManagementService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: DepartmentManagementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: DepartmentManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"department-management.service.js","sourceRoot":"","sources":["../../../../../../../projects/cloud-ide-core/src/lib/core/department-management/services/department-management.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Observable, throwError, BehaviorSubject } from 'rxjs';\r\nimport { catchError, tap } from 'rxjs/operators';\r\nimport { \r\n  cidePath, \r\n  coreRoutesUrl, \r\n  generateStringFromObject, \r\n  hostManagerRoutesUrl, \r\n  ICoreSydept, \r\n  MDepartmentDeletePayload, \r\n  MDepartmentGetByIdPayload, \r\n  departmentByIdControllerResponse, \r\n  departmentDeleteControllerResponse, \r\n  departmentControllerResponse,\r\n  MDepartment,\r\n  MDepartmentToggleStatusPayload,\r\n  departmentToggleStatusControllerResponse\r\n} from 'cloud-ide-lms-model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class DepartmentManagementService {\r\n  private departmentListSubject = new BehaviorSubject<ICoreSydept[]>([]);\r\n  public departmentList$ = this.departmentListSubject.asObservable();\r\n\r\n  constructor(private http: HttpClient) {\r\n    console.log('DepartmentManagementService initialized - using real API');\r\n  }\r\n\r\n  /**\r\n   * Get department list from API\r\n   */\r\n  getDepartmentList(body: MDepartment): Observable<departmentControllerResponse> {\r\n    const query = generateStringFromObject(body);\r\n    return this.http?.get<departmentControllerResponse>(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, query]))\r\n      .pipe(\r\n        tap((response: departmentControllerResponse) => {\r\n          if (response?.success) {\r\n            this.departmentListSubject.next(response?.data || []);\r\n          }\r\n        }),\r\n        catchError(error => {\r\n          console.error('DepartmentManagementService API error:', error);\r\n          return this.handleError(error);\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Get department list from cache (if available)\r\n   */\r\n  getDepartmentListFromCache(): ICoreSydept[] {\r\n    return this.departmentListSubject.value;\r\n  }\r\n\r\n  /**\r\n   * Create new department\r\n   * POST ${coreRoutesUrl?.department} - payload: MDepartmentInsertUpdatePayload, response: departmentInsertUpdateControllerResponse\r\n   */\r\n  createDepartment(department: ICoreSydept): Observable<departmentControllerResponse> {\r\n    console.log('Creating department:', department);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department]);\r\n    return this.http.post<departmentControllerResponse>(url, department)\r\n      .pipe(\r\n        tap((response: departmentControllerResponse) => {\r\n          if (response.success) {\r\n            this.refreshDepartmentList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Update existing department\r\n   * POST ${coreRoutesUrl?.department} - payload: MDepartmentInsertUpdatePayload, response: departmentInsertUpdateControllerResponse\r\n   */\r\n  updateDepartment(id: string, department: ICoreSydept): Observable<departmentControllerResponse> {\r\n    console.log('Updating department:', id, department);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department]);\r\n    return this.http.post<departmentControllerResponse>(url, department)\r\n      .pipe(\r\n        tap((response: departmentControllerResponse) => {\r\n          if (response.success) {\r\n            this.refreshDepartmentList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Get department by ID\r\n   * GET ${coreRoutesUrl?.department}/byId/:query - payload: MDepartmentGetByIdPayload, response: departmentByIdControllerResponse\r\n   */\r\n  getDepartmentById(id: string): Observable<departmentByIdControllerResponse> {\r\n    console.log('Getting department by ID:', id);\r\n    const payload: MDepartmentGetByIdPayload = { sydept_id: id };\r\n    const query = generateStringFromObject(payload);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, 'byId', query]);\r\n    return this.http.get<departmentByIdControllerResponse>(url)\r\n      .pipe(\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Delete department\r\n   * DELETE ${coreRoutesUrl?.department}/:query - payload: MDepartmentDeletePayload, response: departmentDeleteControllerResponse\r\n   */\r\n  deleteDepartment(id: string): Observable<departmentDeleteControllerResponse> {\r\n    const payload: MDepartmentDeletePayload = { sydept_id: id };\r\n    const query = generateStringFromObject(payload);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, query]);\r\n    return this.http.delete<departmentDeleteControllerResponse>(url)\r\n      .pipe(\r\n        tap((response: departmentDeleteControllerResponse) => {\r\n          if (response.success) {\r\n            this.refreshDepartmentList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Delete multiple departments\r\n   */\r\n  deleteMultipleDepartments(ids: string[]): Observable<{ success: boolean; message?: string; data?: unknown }> {\r\n    console.log('Deleting multiple departments:', ids);\r\n    const payload = { ids };\r\n    const query = generateStringFromObject(payload);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, query]);\r\n    return this.http.delete<{ success: boolean; message?: string; data?: unknown }>(url)\r\n      .pipe(\r\n        tap((response: { success: boolean; message?: string; data?: unknown }) => {\r\n          if (response.success) {\r\n            this.refreshDepartmentList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Toggle department active status\r\n   */\r\n  toggleDepartmentStatus(payload: MDepartmentToggleStatusPayload): Observable<departmentToggleStatusControllerResponse> {\r\n    const query = generateStringFromObject(payload); \r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.department, 'toggleStatus', query]);\r\n    return this.http.put<departmentToggleStatusControllerResponse>(url, {})\r\n      .pipe(\r\n        tap((response: departmentToggleStatusControllerResponse) => {\r\n          if (response.success) {\r\n            this.refreshDepartmentList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Find department by ID\r\n   */\r\n  findDepartmentById(id: string, items: ICoreSydept[] = this.departmentListSubject.value): ICoreSydept | null {\r\n    for (const item of items) {\r\n      if (item._id === id) {\r\n        return item;\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Get parent departments for dropdown selection\r\n   */\r\n  getParentDepartments(excludeId?: string): ICoreSydept[] {\r\n    const allItems: ICoreSydept[] = [];\r\n\r\n    const flattenItems = (items: ICoreSydept[], level: number = 0) => {\r\n      items.forEach(item => {\r\n        if (item._id !== excludeId) {\r\n          allItems.push({\r\n            ...item,\r\n            sydept_name: '  '.repeat(level) + item.sydept_name\r\n          });\r\n        }\r\n      });\r\n    };\r\n\r\n    flattenItems(this.departmentListSubject.value);\r\n    return allItems;\r\n  }\r\n\r\n  /**\r\n   * Refresh department list from server\r\n   */\r\n  private refreshDepartmentList(): void {\r\n    const defaultBody = {\r\n      pageIndex: 1,\r\n      pageSize: 10\r\n    };\r\n    this.getDepartmentList(defaultBody).subscribe({\r\n      next: () => {\r\n        console.log('Department list refreshed successfully');\r\n      },\r\n      error: (error) => {\r\n        console.error('Error refreshing department list:', error);\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Handle errors\r\n   */\r\n  private handleError(error: unknown): Observable<never> {\r\n    let errorMessage = 'An error occurred';\r\n\r\n    if (error instanceof Error) {\r\n      errorMessage = error.message;\r\n    } else if (typeof error === 'string') {\r\n      errorMessage = error;\r\n    }\r\n\r\n    console.error('Department Management Service Error:', errorMessage);\r\n    return throwError(() => new Error(errorMessage));\r\n  }\r\n} "]}