cloud-ide-core 0.0.1

package/esm2022/lib/core/grade-level-management/index.mjs

@@ -0,0 +1,5 @@
+// Grade Level Management Components
+export * from './components/grade-level-list/grade-level-list.component';
+// Grade Level Management Services
+export * from './services/grade-level-management.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbG91ZC1pZGUtY29yZS9zcmMvbGliL2NvcmUvZ3JhZGUtbGV2ZWwtbWFuYWdlbWVudC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvQ0FBb0M7QUFDcEMsY0FBYywwREFBMEQsQ0FBQztBQUV6RSxrQ0FBa0M7QUFDbEMsY0FBYywyQ0FBMkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdyYWRlIExldmVsIE1hbmFnZW1lbnQgQ29tcG9uZW50c1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudHMvZ3JhZGUtbGV2ZWwtbGlzdC9ncmFkZS1sZXZlbC1saXN0LmNvbXBvbmVudCc7XHJcblxyXG4vLyBHcmFkZSBMZXZlbCBNYW5hZ2VtZW50IFNlcnZpY2VzXHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZ3JhZGUtbGV2ZWwtbWFuYWdlbWVudC5zZXJ2aWNlJzsgIl19

package/esm2022/lib/core/grade-level-management/services/grade-level-management.service.mjs

@@ -0,0 +1,172 @@
+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 GradeLevelManagementService {
+    constructor(http) {
+        this.http = http;
+        this.apiUrl = `${coreRoutesUrl?.gradeLevel}`;
+        this.gradeLevelListSubject = new BehaviorSubject([]);
+        this.gradeLevelList$ = this.gradeLevelListSubject.asObservable();
+        console.log('GradeLevelManagementService initialized - using real API');
+    }
+    /**
+     * Get grade level list from API
+     */
+    getGradeLevelList(body) {
+        const query = generateStringFromObject(body);
+        return this.http?.get(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, query]))
+            .pipe(tap((response) => {
+            if (response?.success) {
+                this.gradeLevelListSubject.next(response?.data || []);
+            }
+        }), catchError(error => {
+            console.error('GradeLevelManagementService API error:', error);
+            return this.handleError(error);
+        }));
+    }
+    /**
+     * Get grade level list from cache (if available)
+     */
+    getGradeLevelListFromCache() {
+        return this.gradeLevelListSubject.value;
+    }
+    /**
+     * Create new grade level
+     * POST ${coreRoutesUrl?.gradeLevel} - payload: MGradeLevel, response: gradeLevelInsertUpdateControllerResponse
+     */
+    createGradeLevel(gradeLevel) {
+        console.log('Creating grade level:', gradeLevel);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel]);
+        return this.http.post(url, gradeLevel)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshGradeLevelList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Update existing grade level
+     * POST ${coreRoutesUrl?.gradeLevel} - payload: MGradeLevel, response: gradeLevelInsertUpdateControllerResponse
+     */
+    updateGradeLevel(id, gradeLevel) {
+        console.log('Updating grade level:', id, gradeLevel);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel]);
+        return this.http.post(url, gradeLevel)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshGradeLevelList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Get grade level by ID
+     * GET ${coreRoutesUrl?.gradeLevel}/byId/:query - payload: { id }, response: gradeLevelByIdControllerResponse
+     */
+    getGradeLevelById(id) {
+        console.log('Getting grade level by ID:', id);
+        const payload = { id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, 'byId', query]);
+        return this.http.get(url)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Delete grade level
+     * DELETE ${coreRoutesUrl?.gradeLevel}/:query - payload: { id }, response: { success: boolean }
+     */
+    deleteGradeLevel(id) {
+        const payload = { id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshGradeLevelList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Delete multiple grade levels
+     */
+    deleteMultipleGradeLevels(ids) {
+        console.log('Deleting multiple grade levels:', ids);
+        const payload = { ids };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, query]);
+        return this.http.delete(url)
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshGradeLevelList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Toggle grade level active status
+     */
+    toggleGradeLevelStatus(id) {
+        console.log('Toggling grade level status:', id);
+        const payload = { id };
+        const query = generateStringFromObject(payload);
+        const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, query]);
+        return this.http.put(url, {})
+            .pipe(tap((response) => {
+            if (response.success) {
+                this.refreshGradeLevelList();
+            }
+        }), catchError(this.handleError));
+    }
+    /**
+     * Find grade level by ID
+     */
+    findGradeLevelById(id, items = this.gradeLevelListSubject.value) {
+        for (const item of items) {
+            if (item._id === id) {
+                return item;
+            }
+        }
+        return null;
+    }
+    /**
+     * Refresh grade level list from server
+     */
+    refreshGradeLevelList() {
+        const defaultBody = {
+            pageIndex: 1,
+            pageSize: 10
+        };
+        this.getGradeLevelList(defaultBody).subscribe({
+            next: () => {
+                console.log('Grade level list refreshed successfully');
+            },
+            error: (error) => {
+                console.error('Error refreshing grade level 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('Grade Level 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: GradeLevelManagementService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: GradeLevelManagementService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: GradeLevelManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grade-level-management.service.js","sourceRoot":"","sources":["../../../../../../../projects/cloud-ide-core/src/lib/core/grade-level-management/services/grade-level-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  ICoreSydsgl, \r\n  gradeLevelControllerResponse, \r\n  gradeLevelByIdControllerResponse,\r\n  MGradeLevel\r\n} from 'cloud-ide-lms-model';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class GradeLevelManagementService {\r\n  private apiUrl = `${coreRoutesUrl?.gradeLevel}`;\r\n  private gradeLevelListSubject = new BehaviorSubject<ICoreSydsgl[]>([]);\r\n  public gradeLevelList$ = this.gradeLevelListSubject.asObservable();\r\n\r\n  constructor(private http: HttpClient) {\r\n    console.log('GradeLevelManagementService initialized - using real API');\r\n  }\r\n\r\n  /**\r\n   * Get grade level list from API\r\n   */\r\n  getGradeLevelList(body: MGradeLevel): Observable<gradeLevelControllerResponse> {\r\n    const query = generateStringFromObject(body);\r\n    return this.http?.get<gradeLevelControllerResponse>(cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, query]))\r\n      .pipe(\r\n        tap((response: gradeLevelControllerResponse) => {\r\n          if (response?.success) {\r\n            this.gradeLevelListSubject.next(response?.data || []);\r\n          }\r\n        }),\r\n        catchError(error => {\r\n          console.error('GradeLevelManagementService API error:', error);\r\n          return this.handleError(error);\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Get grade level list from cache (if available)\r\n   */\r\n  getGradeLevelListFromCache(): ICoreSydsgl[] {\r\n    return this.gradeLevelListSubject.value;\r\n  }\r\n\r\n  /**\r\n   * Create new grade level\r\n   * POST ${coreRoutesUrl?.gradeLevel} - payload: MGradeLevel, response: gradeLevelInsertUpdateControllerResponse\r\n   */\r\n  createGradeLevel(gradeLevel: ICoreSydsgl): Observable<gradeLevelControllerResponse> {\r\n    console.log('Creating grade level:', gradeLevel);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel]);\r\n    return this.http.post<gradeLevelControllerResponse>(url, gradeLevel)\r\n      .pipe(\r\n        tap((response: gradeLevelControllerResponse) => {\r\n          if (response.success) {\r\n            this.refreshGradeLevelList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Update existing grade level\r\n   * POST ${coreRoutesUrl?.gradeLevel} - payload: MGradeLevel, response: gradeLevelInsertUpdateControllerResponse\r\n   */\r\n  updateGradeLevel(id: string, gradeLevel: ICoreSydsgl): Observable<gradeLevelControllerResponse> {\r\n    console.log('Updating grade level:', id, gradeLevel);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel]);\r\n    return this.http.post<gradeLevelControllerResponse>(url, gradeLevel)\r\n      .pipe(\r\n        tap((response: gradeLevelControllerResponse) => {\r\n          if (response.success) {\r\n            this.refreshGradeLevelList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Get grade level by ID\r\n   * GET ${coreRoutesUrl?.gradeLevel}/byId/:query - payload: { id }, response: gradeLevelByIdControllerResponse\r\n   */\r\n  getGradeLevelById(id: string): Observable<gradeLevelByIdControllerResponse> {\r\n    console.log('Getting grade level by ID:', id);\r\n    const payload = { id };\r\n    const query = generateStringFromObject(payload);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, 'byId', query]);\r\n    return this.http.get<gradeLevelByIdControllerResponse>(url)\r\n      .pipe(\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Delete grade level\r\n   * DELETE ${coreRoutesUrl?.gradeLevel}/:query - payload: { id }, response: { success: boolean }\r\n   */\r\n  deleteGradeLevel(id: string): Observable<{ success: boolean; message?: string; data?: unknown }> {\r\n    const payload = { id };\r\n    const query = generateStringFromObject(payload);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, 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.refreshGradeLevelList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Delete multiple grade levels\r\n   */\r\n  deleteMultipleGradeLevels(ids: string[]): Observable<{ success: boolean; message?: string; data?: unknown }> {\r\n    console.log('Deleting multiple grade levels:', ids);\r\n    const payload = { ids };\r\n    const query = generateStringFromObject(payload);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, 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.refreshGradeLevelList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Toggle grade level active status\r\n   */\r\n  toggleGradeLevelStatus(id: string): Observable<gradeLevelControllerResponse> {\r\n    console.log('Toggling grade level status:', id);\r\n    const payload = { id };\r\n    const query = generateStringFromObject(payload);\r\n    const url = cidePath?.join([hostManagerRoutesUrl?.cideSuiteHost, coreRoutesUrl?.module, coreRoutesUrl?.gradeLevel, query]);\r\n    return this.http.put<gradeLevelControllerResponse>(url, {})\r\n      .pipe(\r\n        tap((response: gradeLevelControllerResponse) => {\r\n          if (response.success) {\r\n            this.refreshGradeLevelList();\r\n          }\r\n        }),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Find grade level by ID\r\n   */\r\n  findGradeLevelById(id: string, items: ICoreSydsgl[] = this.gradeLevelListSubject.value): ICoreSydsgl | 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   * Refresh grade level list from server\r\n   */\r\n  private refreshGradeLevelList(): void {\r\n    const defaultBody = {\r\n      pageIndex: 1,\r\n      pageSize: 10\r\n    };\r\n    this.getGradeLevelList(defaultBody).subscribe({\r\n      next: () => {\r\n        console.log('Grade level list refreshed successfully');\r\n      },\r\n      error: (error) => {\r\n        console.error('Error refreshing grade level 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('Grade Level Management Service Error:', errorMessage);\r\n    return throwError(() => new Error(errorMessage));\r\n  }\r\n} "]}