cloud-ide-core 0.0.1 → 1.0.1

package/esm2022/lib/core/general-master-management/services/general-master-type.service.mjs

@@ -0,0 +1,203 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+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";
+export class GeneralMasterTypeService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.generalMasterTypeListSubject = new BehaviorSubject([]);
+        this.generalMasterTypeList$ = this.generalMasterTypeListSubject.asObservable();
+        console.log('GeneralMasterTypeService initialized - using real API');
+    }
+    /**
+     * Get general master type list from API
+     */
+    getTypeList(body) {
+        const query = generateStringFromObject(body);
+        return this.http?.get(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, query]))
+            .pipe(tap((response) => {
+            if (response?.success) {
+                this.generalMasterTypeListSubject.next(response?.data || []);
+            }
+        }), catchError(error => {
+            console.error('GeneralMasterTypeService API error:', error);
+            return this.handleError(error);
+        }));
+    }
+    /**
+     * Get general master type list from cache (if available)
+     */
+    getTypeListFromCache() {
+        return this.generalMasterTypeListSubject.value;
+    }
+    /**
+     * Create or update general master type
+     * POST ${coreRoutesUrl?.generalMasterType} - payload: IGeneralMasterTypeCreateUpdatePayload, response: generalMasterTypeInsertUpdateControllerResponse
+     * If type._id exists, it will update; otherwise, it will create a new type
+     */
+    saveType(type) {
+        const isUpdate = !!type._id;
+        console.log(`${isUpdate ? 'Updating' : 'Creating'} general master type:`, type);
+        // Create proper payload - backend will determine create vs update based on _id presence
+        const payload = {
+            ...(type._id && { _id: type._id }), // Only include _id if it exists
+            sygmt_code: type.sygmt_code,
+            sygmt_title: type.sygmt_title,
+            sygmt_desc: type.sygmt_desc,
+            sygmt_isactive: type.sygmt_isactive,
+            sygmt_configuration: type.sygmt_configuration,
+            sygmt_id_sygmt: type.sygmt_id_sygmt
+        };
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType]);
+        return this.http.post(url, payload)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshTypeList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Get general master type by ID
+     * GET ${coreRoutesUrl?.generalMasterType}/byId/:query - payload: { sygmt_id: string }, response: generalMasterTypeByIdControllerResponse
+     */
+    getTypeById(id) {
+        console.log('Getting general master type by ID:', id);
+        const payload = { sygmt_id: id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, 'byId', query]);
+        return this.http.get(url)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Delete general master type
+     * DELETE ${coreRoutesUrl?.generalMasterType}/:query - payload: { sygmt_id: string }, response: generalMasterTypeDeleteControllerResponse
+     */
+    deleteType(id) {
+        const payload = { sygmt_id: id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshTypeList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Delete multiple general master types
+     */
+    deleteMultipleTypes(ids) {
+        console.log('Deleting multiple general master types:', ids);
+        const payload = { ids };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshTypeList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Toggle general master type active status
+     */
+    toggleTypeStatus(payload) {
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, query]);
+        return this.http.put(url, {})
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshTypeList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Check if type code exists
+     */
+    checkTypeCodeExists(code, excludeId) {
+        const payload = { code };
+        if (excludeId) {
+            payload['excludeId'] = excludeId;
+        }
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, 'checkCodeExists', query]);
+        return this.http.get(url)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Get hierarchical tree structure
+     */
+    getTypeTree() {
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, 'tree']);
+        return this.http.get(url)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Find general master type by ID
+     */
+    findTypeById(id, items = this.generalMasterTypeListSubject.value) {
+        for (const item of items) {
+            if (item._id === id) {
+                return item;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get parent general master types for dropdown selection
+     */
+    getParentTypes(excludeId) {
+        const allItems = [];
+        const flattenItems = (items, level = 0) => {
+            items.forEach(item => {
+                if (item._id !== excludeId) {
+                    allItems.push({
+                        ...item,
+                        sygmt_title: '  '.repeat(level) + item.sygmt_title
+                    });
+                }
+            });
+        };
+        flattenItems(this.generalMasterTypeListSubject.value);
+        return allItems;
+    }
+    /**
+     * Refresh general master type list from server
+     */
+    refreshTypeList() {
+        const defaultBody = {};
+        this.getTypeList(defaultBody).subscribe({
+            next: () => {
+                console.log('General master type list refreshed successfully');
+            },
+            error: (error) => {
+                console.error('Error refreshing general master type 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('General Master Type Service Error:', errorMessage);
+        return throwError(() => new Error(errorMessage));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: GeneralMasterTypeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: GeneralMasterTypeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: GeneralMasterTypeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"general-master-type.service.js","sourceRoot":"","sources":["../../../../../../../projects/cloud-ide-core/src/lib/core/general-master-management/services/general-master-type.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } 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  generalMasterTypeListControllerResponse,\n  generalMasterTypeByIdControllerResponse,\n  generalMasterTypeInsertUpdateControllerResponse,\n  generalMasterTypeDeleteControllerResponse,\n  generalMasterTypeToggleStatusControllerResponse,\n  MGeneralMasterType,\n  MGeneralMasterTypeToggleStatusPayload,\n  ICoreSygmt\n} from 'cloud-ide-lms-model';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class GeneralMasterTypeService {\n  private http = inject(HttpClient);\n  private generalMasterTypeListSubject = new BehaviorSubject<ICoreSygmt[]>([]);\n  public generalMasterTypeList$ = this.generalMasterTypeListSubject.asObservable();\n\n  constructor() {\n    console.log('GeneralMasterTypeService initialized - using real API');\n  }\n\n  /**\n   * Get general master type list from API\n   */\n  getTypeList(body: MGeneralMasterType): Observable<generalMasterTypeListControllerResponse> {\n    const query = generateStringFromObject(body);\n    return this.http?.get<generalMasterTypeListControllerResponse>(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, query]))\n      .pipe(\n        tap((response: generalMasterTypeListControllerResponse) => {\n          if (response?.success) {\n            this.generalMasterTypeListSubject.next(response?.data || []);\n          }\n        }),\n        catchError(error => {\n          console.error('GeneralMasterTypeService API error:', error);\n          return this.handleError(error);\n        })\n      );\n  }\n\n  /**\n   * Get general master type list from cache (if available)\n   */\n  getTypeListFromCache(): ICoreSygmt[] {\n    return this.generalMasterTypeListSubject.value;\n  }\n\n  /**\n   * Create or update general master type\n   * POST ${coreRoutesUrl?.generalMasterType} - payload: IGeneralMasterTypeCreateUpdatePayload, response: generalMasterTypeInsertUpdateControllerResponse\n   * If type._id exists, it will update; otherwise, it will create a new type\n   */\n  saveType(type: ICoreSygmt): Observable<generalMasterTypeInsertUpdateControllerResponse> {\n    const isUpdate = !!type._id;\n    console.log(`${isUpdate ? 'Updating' : 'Creating'} general master type:`, type);\n    \n    // Create proper payload - backend will determine create vs update based on _id presence\n    const payload: ICoreSygmt = {\n      ...(type._id && { _id: type._id }), // Only include _id if it exists\n      sygmt_code: type.sygmt_code,\n      sygmt_title: type.sygmt_title,\n      sygmt_desc: type.sygmt_desc,\n      sygmt_isactive: type.sygmt_isactive,\n      sygmt_configuration: type.sygmt_configuration,\n      sygmt_id_sygmt: type.sygmt_id_sygmt\n    };\n    \n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType]);\n    return this.http.post<generalMasterTypeInsertUpdateControllerResponse>(url, payload)\n      .pipe(\n        tap((response: generalMasterTypeInsertUpdateControllerResponse) => {\n          if (response.success) {\n            this.refreshTypeList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Get general master type by ID\n   * GET ${coreRoutesUrl?.generalMasterType}/byId/:query - payload: { sygmt_id: string }, response: generalMasterTypeByIdControllerResponse\n   */\n  getTypeById(id: string): Observable<generalMasterTypeByIdControllerResponse> {\n    console.log('Getting general master type by ID:', id);\n    const payload = { sygmt_id: id };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, 'byId', query]);\n    return this.http.get<generalMasterTypeByIdControllerResponse>(url)\n      .pipe(\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Delete general master type\n   * DELETE ${coreRoutesUrl?.generalMasterType}/:query - payload: { sygmt_id: string }, response: generalMasterTypeDeleteControllerResponse\n   */\n  deleteType(id: string): Observable<generalMasterTypeDeleteControllerResponse> {\n    const payload = { sygmt_id: id };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, query]);\n    return this.http.delete<generalMasterTypeDeleteControllerResponse>(url)\n      .pipe(\n        tap((response: generalMasterTypeDeleteControllerResponse) => {\n          if (response.success) {\n            this.refreshTypeList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Delete multiple general master types\n   */\n  deleteMultipleTypes(ids: string[]): Observable<{ success: boolean; message?: string; data?: unknown }> {\n    console.log('Deleting multiple general master types:', ids);\n    const payload = { ids };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, 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.refreshTypeList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Toggle general master type active status\n   */\n  toggleTypeStatus(payload: MGeneralMasterTypeToggleStatusPayload): Observable<generalMasterTypeToggleStatusControllerResponse> {\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, query]);\n    return this.http.put<generalMasterTypeToggleStatusControllerResponse>(url, {})\n      .pipe(\n        tap((response: generalMasterTypeToggleStatusControllerResponse) => {\n          if (response.success) {\n            this.refreshTypeList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Check if type code exists\n   */\n  checkTypeCodeExists(code: string, excludeId?: string): Observable<{ success: boolean; message: string; exists: boolean }> {\n    const payload: Record<string, string> = { code };\n    if (excludeId) {\n      payload['excludeId'] = excludeId;\n    }\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, 'checkCodeExists', query]);\n    return this.http.get<{ success: boolean; message: string; exists: boolean }>(url)\n      .pipe(\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Get hierarchical tree structure\n   */\n  getTypeTree(): Observable<generalMasterTypeListControllerResponse> {\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMasterType, 'tree']);\n    return this.http.get<generalMasterTypeListControllerResponse>(url)\n      .pipe(\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Find general master type by ID\n   */\n  findTypeById(id: string, items: ICoreSygmt[] = this.generalMasterTypeListSubject.value): ICoreSygmt | 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 general master types for dropdown selection\n   */\n  getParentTypes(excludeId?: string): ICoreSygmt[] {\n    const allItems: ICoreSygmt[] = [];\n\n    const flattenItems = (items: ICoreSygmt[], level: number = 0) => {\n      items.forEach(item => {\n        if (item._id !== excludeId) {\n          allItems.push({\n            ...item,\n            sygmt_title: '  '.repeat(level) + item.sygmt_title\n          });\n        }\n      });\n    };\n\n    flattenItems(this.generalMasterTypeListSubject.value);\n    return allItems;\n  }\n\n  /**\n   * Refresh general master type list from server\n   */\n  private refreshTypeList(): void {\n    const defaultBody: MGeneralMasterType = {};\n    this.getTypeList(defaultBody).subscribe({\n      next: () => {\n        console.log('General master type list refreshed successfully');\n      },\n      error: (error) => {\n        console.error('Error refreshing general master type 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('General Master Type Service Error:', errorMessage);\n    return throwError(() => new Error(errorMessage));\n  }\n} "]}

package/esm2022/lib/core/general-master-management/services/general-master.service.mjs

@@ -0,0 +1,166 @@
+import { Injectable, inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+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";
+export class GeneralMasterService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.generalMasterListSubject = new BehaviorSubject([]);
+        this.generalMasterList$ = this.generalMasterListSubject.asObservable();
+        console.log('GeneralMasterService initialized - using real API');
+    }
+    /**
+     * Get general master list from API
+     */
+    getMasterList(payload) {
+        const query = generateStringFromObject(payload);
+        return this.http?.get(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, query]))
+            .pipe(tap((response) => {
+            if (response?.success) {
+                this.generalMasterListSubject.next(response?.data || []);
+            }
+        }), catchError(error => {
+            console.error('GeneralMasterService API error:', error);
+            return this.handleError(error);
+        }));
+    }
+    /**
+     * Get general master list from cache (if available)
+     */
+    getMasterListFromCache() {
+        return this.generalMasterListSubject.value;
+    }
+    /**
+     * Save general master (create or update)
+     * POST ${coreRoutesUrl?.generalMaster} - payload: ICoreSygms, response: generalMasterInsertUpdateControllerResponse
+     */
+    saveMaster(master) {
+        const isUpdate = !!master._id;
+        console.log(`${isUpdate ? 'Updating' : 'Creating'} general master:`, master);
+        // Create proper payload
+        const payload = {
+            ...(master._id && { _id: master._id }), // Only include _id if it exists
+            sygms_code: master.sygms_code,
+            sygms_id_sygmt: master.sygms_id_sygmt,
+            sygms_title: master.sygms_title,
+            sygms_desc: master.sygms_desc,
+            sygms_isactive: master.sygms_isactive,
+            sygms_id_sygms: master.sygms_id_sygms,
+            sygms_configuration: master.sygms_configuration,
+            sygms_entity_id_syen: master.sygms_entity_id_syen
+        };
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster]);
+        return this.http.post(url, payload)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshMasterList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Create new general master (backward compatibility)
+     */
+    createMaster(master) {
+        return this.saveMaster(master);
+    }
+    /**
+     * Update existing general master (backward compatibility)
+     */
+    updateMaster(id, master) {
+        return this.saveMaster({ ...master, _id: id });
+    }
+    /**
+     * Get general master by ID
+     * GET ${coreRoutesUrl?.generalMaster}/byId/:query - payload: { sygms_id: string }, response: generalMasterByIdControllerResponse
+     */
+    getMasterById(id) {
+        console.log('Getting general master by ID:', id);
+        const payload = { sygms_id: id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, 'byId', query]);
+        return this.http.get(url)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Delete general master
+     * DELETE ${coreRoutesUrl?.generalMaster}/:query - payload: { sygms_id: string }, response: generalMasterDeleteControllerResponse
+     */
+    deleteMaster(id) {
+        const payload = { sygms_id: id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshMasterList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Toggle general master active status
+     */
+    toggleMasterStatus(id) {
+        console.log('Toggling general master status:', id);
+        const payload = { id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, query]);
+        return this.http.put(url, {})
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshMasterList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Check if master code exists
+     */
+    checkMasterCodeExists(code, typeId, excludeId) {
+        const payload = { code, typeId };
+        if (excludeId) {
+            payload['excludeId'] = excludeId;
+        }
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, 'checkCodeExists', query]);
+        return this.http.get(url)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Refresh general master list from server
+     */
+    refreshMasterList() {
+        const defaultPayload = {};
+        this.getMasterList(defaultPayload).subscribe({
+            next: () => {
+                console.log('General master list refreshed successfully');
+            },
+            error: (error) => {
+                console.error('Error refreshing general master 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('General Master Service Error:', errorMessage);
+        return throwError(() => new Error(errorMessage));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: GeneralMasterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: GeneralMasterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: GeneralMasterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"general-master.service.js","sourceRoot":"","sources":["../../../../../../../projects/cloud-ide-core/src/lib/core/general-master-management/services/general-master.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } 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  generalMasterListControllerResponse,\n  generalMasterByIdControllerResponse,\n  generalMasterInsertUpdateControllerResponse,\n  generalMasterDeleteControllerResponse,\n  generalMasterToggleStatusControllerResponse,\n  ICoreSygms,\n  IGeneralMasterListRequest,\n} from 'cloud-ide-lms-model';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class GeneralMasterService {\n  private http = inject(HttpClient);\n  private generalMasterListSubject = new BehaviorSubject<ICoreSygms[]>([]);\n  public generalMasterList$ = this.generalMasterListSubject.asObservable();\n\n  constructor() {\n    console.log('GeneralMasterService initialized - using real API');\n  }\n\n  /**\n   * Get general master list from API\n   */\n  getMasterList(payload: IGeneralMasterListRequest): Observable<generalMasterListControllerResponse> {\n    const query = generateStringFromObject(payload);\n    return this.http?.get<generalMasterListControllerResponse>(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, query]))\n      .pipe(\n        tap((response: generalMasterListControllerResponse) => {\n          if (response?.success) {\n            this.generalMasterListSubject.next(response?.data || []);\n          }\n        }),\n        catchError(error => {\n          console.error('GeneralMasterService API error:', error);\n          return this.handleError(error);\n        })\n      );\n  }\n\n  /**\n   * Get general master list from cache (if available)\n   */\n  getMasterListFromCache(): ICoreSygms[] {\n    return this.generalMasterListSubject.value;\n  }\n\n  /**\n   * Save general master (create or update)\n   * POST ${coreRoutesUrl?.generalMaster} - payload: ICoreSygms, response: generalMasterInsertUpdateControllerResponse\n   */\n  saveMaster(master: ICoreSygms): Observable<generalMasterInsertUpdateControllerResponse> {\n    const isUpdate = !!master._id;\n    console.log(`${isUpdate ? 'Updating' : 'Creating'} general master:`, master);\n    \n    // Create proper payload\n    const payload: ICoreSygms = {\n      ...(master._id && { _id: master._id }), // Only include _id if it exists\n      sygms_code: master.sygms_code,\n      sygms_id_sygmt: master.sygms_id_sygmt,\n      sygms_title: master.sygms_title,\n      sygms_desc: master.sygms_desc,\n      sygms_isactive: master.sygms_isactive,\n      sygms_id_sygms: master.sygms_id_sygms,\n      sygms_configuration: master.sygms_configuration,\n      sygms_entity_id_syen: master.sygms_entity_id_syen\n    };\n    \n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster]);\n    return this.http.post<generalMasterInsertUpdateControllerResponse>(url, payload)\n      .pipe(\n        tap((response: generalMasterInsertUpdateControllerResponse) => {\n          if (response.success) {\n            this.refreshMasterList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Create new general master (backward compatibility)\n   */\n  createMaster(master: ICoreSygms): Observable<generalMasterInsertUpdateControllerResponse> {\n    return this.saveMaster(master);\n  }\n\n  /**\n   * Update existing general master (backward compatibility)\n   */\n  updateMaster(id: string, master: ICoreSygms): Observable<generalMasterInsertUpdateControllerResponse> {\n    return this.saveMaster({ ...master, _id: id });\n  }\n\n  /**\n   * Get general master by ID\n   * GET ${coreRoutesUrl?.generalMaster}/byId/:query - payload: { sygms_id: string }, response: generalMasterByIdControllerResponse\n   */\n  getMasterById(id: string): Observable<generalMasterByIdControllerResponse> {\n    console.log('Getting general master by ID:', id);\n    const payload = { sygms_id: id };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, 'byId', query]);\n    return this.http.get<generalMasterByIdControllerResponse>(url)\n      .pipe(\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Delete general master\n   * DELETE ${coreRoutesUrl?.generalMaster}/:query - payload: { sygms_id: string }, response: generalMasterDeleteControllerResponse\n   */\n  deleteMaster(id: string): Observable<generalMasterDeleteControllerResponse> {\n    const payload = { sygms_id: id };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, query]);\n    return this.http.delete<generalMasterDeleteControllerResponse>(url)\n      .pipe(\n        tap((response: generalMasterDeleteControllerResponse) => {\n          if (response.success) {\n            this.refreshMasterList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Toggle general master active status\n   */\n  toggleMasterStatus(id: string): Observable<generalMasterToggleStatusControllerResponse> {\n    console.log('Toggling general master status:', id);\n    const payload = { id };\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, query]);\n    return this.http.put<generalMasterToggleStatusControllerResponse>(url, {})\n      .pipe(\n        tap((response: generalMasterToggleStatusControllerResponse) => {\n          if (response.success) {\n            this.refreshMasterList();\n          }\n        }),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Check if master code exists\n   */\n  checkMasterCodeExists(code: string, typeId: string, excludeId?: string): Observable<{ success: boolean; message: string; exists: boolean }> {\n    const payload: Record<string, string> = { code, typeId };\n    if (excludeId) {\n      payload['excludeId'] = excludeId;\n    }\n    const query = generateStringFromObject(payload);\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.generalMaster, 'checkCodeExists', query]);\n    return this.http.get<{ success: boolean; message: string; exists: boolean }>(url)\n      .pipe(\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Refresh general master list from server\n   */\n  private refreshMasterList(): void {\n    const defaultPayload: IGeneralMasterListRequest = {};\n    this.getMasterList(defaultPayload).subscribe({\n      next: () => {\n        console.log('General master list refreshed successfully');\n      },\n      error: (error) => {\n        console.error('Error refreshing general master 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('General Master Service Error:', errorMessage);\n    return throwError(() => new Error(errorMessage));\n  }\n} "]}