@sunbird-cb/access-settings 0.0.1-cbrelease-4.8.26

package/esm2022/lib/_services/access-control.service.mjs

@@ -0,0 +1,195 @@
+import { Injectable, signal } from "@angular/core";
+import { toNumber } from "lodash";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const ENDPOINTS = {
+    SEARCH_USER_WITH_ADMIN: (query) => `/apis/proxies/v8/user/v1/autocomplete/${query}`,
+    SEARCH_USER: `/apis/proxies/v8/user/v1/admin/search`,
+    SEARCH_ORG: "/apis/proxies/v8/org/v1/admin/search",
+    VALIDATE_USER: "/apis/proxies/v8/user/v1/search",
+    GROUPS: "/apis/proxies/v8/user/v1/groups",
+    CADRE_CONFIG: "/apis/proxies/v8/data/v2/system/settings/get/cadreConfig",
+    DESIGNATION_LIST: "/apis/proxies/v8/designation/search",
+    SEARCH_V4: "/apis/proxies/v8/sunbirdigot/v4/search",
+    CREATE_USERGROUPS_CONTROL: "/apis/proxies/v8/accessSetttings/v1/upsert",
+    GET_ACCESS_CONTROL: (id) => `/apis/proxies/v8/accessSetttings/read/${id}`,
+    ACTION_CONTENT_V3: `apis/proxies/v8/action/content/v3/`
+};
+export class AccessControlService {
+    constructor(http) {
+        this.http = http;
+        this.accessControlConfig = signal(null);
+        this.holdServiceCadrebatch = signal({
+            service: [],
+            batch: [],
+            cadre: []
+        });
+    }
+    fetchUserListWithAdmin(queryString) {
+        return this.http.get(ENDPOINTS.SEARCH_USER_WITH_ADMIN(queryString));
+    }
+    fetchUserList(query, pagination, userIds) {
+        let request = {
+            filters: {
+                "profileDetails.profileStatus": ["VERIFIED", "NOT-VERIFIED"],
+                status: 1
+            },
+            limit: pagination.limit || 5,
+            offset: pagination.offset || 0,
+            query: query,
+            sort_by: {
+                firstName: "asc"
+            }
+        };
+        if (userIds?.length) {
+            request.filters = { ...request.filters, userId: userIds };
+        }
+        return this.http.post(ENDPOINTS.SEARCH_USER, { request: request });
+    }
+    fetchOrgList(query, pagination) {
+        const request = {
+            request: {
+                filters: {},
+                sort_by: {
+                    channel: "asc"
+                },
+                fields: ["channel", "identifier"],
+                // limit: pagination.limit || 5,
+                // offset: pagination.offset || 0,
+                query: query
+            }
+        };
+        return this.http.post(ENDPOINTS.SEARCH_ORG, request);
+    }
+    validateUser(request) {
+        return this.http.post(ENDPOINTS.VALIDATE_USER, request);
+    }
+    fetchGroupsList() {
+        return this.http.get(ENDPOINTS.GROUPS);
+    }
+    fetchCadreConfig() {
+        return this.http.get(ENDPOINTS.CADRE_CONFIG);
+    }
+    fetchDesignation(query) {
+        const payload = {
+            filterCriteriaMap: {
+                status: "Active"
+            },
+            requestedFields: ["designation", "id"],
+            searchString: query
+        };
+        return this.http.post(ENDPOINTS.DESIGNATION_LIST, payload);
+    }
+    fetchDesignationsWithOrg(categories, query) {
+        const payload = {
+            request: {
+                filters: {
+                    status: "Live",
+                    category: "designation",
+                    categories: categories,
+                    objectType: "Term"
+                },
+                fields: ["identifier", "name"],
+                query: query,
+                sort_by: {
+                    lastUpdatedOn: "desc",
+                    objectType: "Term"
+                },
+                facets: []
+            }
+        };
+        return this.http.post(ENDPOINTS.SEARCH_V4, payload);
+    }
+    applyUserGroupAccessControl(request) {
+        return this.http.put(ENDPOINTS.CREATE_USERGROUPS_CONTROL, request);
+    }
+    fetchUserGroupAccessControl(id) {
+        return this.http.get(ENDPOINTS.GET_ACCESS_CONTROL(id));
+    }
+    updateContentV3(meta, id) {
+        return this.http.patch(`${ENDPOINTS.ACTION_CONTENT_V3}update/${id}`, meta);
+    }
+    downloadFile(data, filename = "data") {
+        const csvData = this.convertToCSV(data, ["email", "status", "mobile", "message"]);
+        const blob = new Blob([`\ufeff${csvData}`], { type: "text/csv;charset=utf-8;" });
+        const dwldLink = document.createElement("a");
+        const url = URL.createObjectURL(blob);
+        const isSafariBrowser = navigator.userAgent.indexOf("Safari") !== -1 && navigator.userAgent.indexOf("Chrome") === -1;
+        if (isSafariBrowser) {
+            // if Safari open in new window to save file with random filename.
+            dwldLink.setAttribute("target", "_blank");
+        }
+        dwldLink.setAttribute("href", url);
+        dwldLink.setAttribute("download", `${filename}.csv`);
+        dwldLink.style.visibility = "hidden";
+        document.body.appendChild(dwldLink);
+        dwldLink.click();
+        document.body.removeChild(dwldLink);
+    }
+    convertToCSV(objArray, headerList) {
+        const array = typeof objArray !== "object" ? JSON.parse(objArray) : objArray;
+        let str = "";
+        let row = "S.No,";
+        for (const index in headerList) {
+            if (headerList[index]) {
+                row += `${headerList[index]} ,`;
+            }
+        }
+        row = row.slice(0, -1);
+        str += `${row}\r\n`;
+        // for (let i = 0; i < array.length; i += 1) {
+        for (const iIndex in array) {
+            if (array[iIndex]) {
+                let line = `${toNumber(iIndex) + 1} `;
+                for (const index in headerList) {
+                    if (headerList[index]) {
+                        const head = headerList[index];
+                        line += `, ${array[iIndex][head]}`;
+                    }
+                }
+                str += `${line}\r\n`;
+            }
+        }
+        return str;
+    }
+    createRequestContent(apiResponse, accessSettingsEnabled) {
+        return {
+            request: {
+                content: {
+                    appIcon: apiResponse.appIcon || "",
+                    posterImage: apiResponse.posterImage || "",
+                    code: apiResponse.code || "",
+                    contentType: apiResponse.contentType || "",
+                    createdBy: apiResponse.createdBy || "",
+                    creatorContacts: apiResponse.creatorContacts || [],
+                    creatorIDs: apiResponse.creatorIDs || [],
+                    createdFor: apiResponse.createdFor || [],
+                    creator: apiResponse.creator || "",
+                    framework: apiResponse.framework || "",
+                    mimeType: apiResponse.mimeType || "",
+                    name: apiResponse.name || "",
+                    organisation: apiResponse.organisation || [],
+                    isExternal: apiResponse.isExternal || false,
+                    primaryCategory: apiResponse.primaryCategory || "",
+                    courseCategory: apiResponse.courseCategory || "",
+                    license: apiResponse.license || "",
+                    ownershipType: apiResponse.ownershipType || [],
+                    cumulativeTracking: apiResponse.cumulativeTracking || false,
+                    language: apiResponse.language || [],
+                    accessSetting: apiResponse.accessSetting || "",
+                    versionKey: apiResponse.versionKey || "",
+                    accessSettingsEnabled: accessSettingsEnabled || false
+                }
+            }
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessControlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"access-control.service.js","sourceRoot":"","sources":["../../../../../../library/sunbird-cb/access-settings/src/lib/_services/access-control.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\nimport { Injectable, signal, WritableSignal } from \"@angular/core\";\nimport { Observable } from \"rxjs\";\nimport { IUserGroupRequest, NsAccessControlConfig } from \"../_models/access-control.model\";\nimport { toNumber } from \"lodash\";\n\nconst ENDPOINTS = {\n  SEARCH_USER_WITH_ADMIN: (query: string) => `/apis/proxies/v8/user/v1/autocomplete/${query}`,\n  SEARCH_USER: `/apis/proxies/v8/user/v1/admin/search`,\n  SEARCH_ORG: \"/apis/proxies/v8/org/v1/admin/search\",\n  VALIDATE_USER: \"/apis/proxies/v8/user/v1/search\",\n  GROUPS: \"/apis/proxies/v8/user/v1/groups\",\n  CADRE_CONFIG: \"/apis/proxies/v8/data/v2/system/settings/get/cadreConfig\",\n  DESIGNATION_LIST: \"/apis/proxies/v8/designation/search\",\n  SEARCH_V4: \"/apis/proxies/v8/sunbirdigot/v4/search\",\n  CREATE_USERGROUPS_CONTROL: \"/apis/proxies/v8/accessSetttings/v1/upsert\",\n  GET_ACCESS_CONTROL: (id: string) => `/apis/proxies/v8/accessSetttings/read/${id}`,\n  ACTION_CONTENT_V3: `apis/proxies/v8/action/content/v3/`\n};\n\n@Injectable({\n  providedIn: \"root\"\n})\nexport class AccessControlService {\n  accessControlConfig: WritableSignal<NsAccessControlConfig.IAccessControlConfig>;\n  holdServiceCadrebatch: WritableSignal<{\n    service: { id: string; name: string }[];\n    batch: number[];\n    cadre: { id: string; name: string }[];\n  }>;\n\n  constructor(private readonly http: HttpClient) {\n    this.accessControlConfig = signal<NsAccessControlConfig.IAccessControlConfig>(null);\n    this.holdServiceCadrebatch = signal({\n      service: [],\n      batch: [],\n      cadre: []\n    });\n  }\n\n  fetchUserListWithAdmin(queryString: string): Observable<any> {\n    return this.http.get<any>(ENDPOINTS.SEARCH_USER_WITH_ADMIN(queryString));\n  }\n\n  fetchUserList(query: string, pagination: { limit: number; offset: number }, userIds?: string[]): Observable<any> {\n    let request: any = {\n      filters: {\n        \"profileDetails.profileStatus\": [\"VERIFIED\", \"NOT-VERIFIED\"],\n        status: 1\n      },\n      limit: pagination.limit || 5,\n      offset: pagination.offset || 0,\n      query: query,\n      sort_by: {\n        firstName: \"asc\"\n      }\n    };\n    if (userIds?.length) {\n      request.filters = { ...request.filters, userId: userIds };\n    }\n    return this.http.post<any>(ENDPOINTS.SEARCH_USER, { request: request });\n  }\n\n  fetchOrgList(query: string, pagination?: { limit: number; offset: number }): Observable<any> {\n    const request = {\n      request: {\n        filters: {},\n        sort_by: {\n          channel: \"asc\"\n        },\n        fields: [\"channel\", \"identifier\"],\n        // limit: pagination.limit || 5,\n        // offset: pagination.offset || 0,\n        query: query\n      }\n    };\n    return this.http.post<any>(ENDPOINTS.SEARCH_ORG, request);\n  }\n\n  validateUser(request: any): Observable<any> {\n    return this.http.post<any>(ENDPOINTS.VALIDATE_USER, request);\n  }\n\n  fetchGroupsList(): Observable<any> {\n    return this.http.get<any>(ENDPOINTS.GROUPS);\n  }\n\n  fetchCadreConfig(): Observable<any> {\n    return this.http.get<any>(ENDPOINTS.CADRE_CONFIG);\n  }\n\n  fetchDesignation(query: string): Observable<any> {\n    const payload = {\n      filterCriteriaMap: {\n        status: \"Active\"\n      },\n      requestedFields: [\"designation\", \"id\"],\n      searchString: query\n    };\n    return this.http.post<any>(ENDPOINTS.DESIGNATION_LIST, payload);\n  }\n\n  fetchDesignationsWithOrg(categories: string[], query: string): Observable<any> {\n    const payload = {\n      request: {\n        filters: {\n          status: \"Live\",\n          category: \"designation\",\n          categories: categories,\n          objectType: \"Term\"\n        },\n        fields: [\"identifier\", \"name\"],\n        query: query,\n        sort_by: {\n          lastUpdatedOn: \"desc\",\n          objectType: \"Term\"\n        },\n        facets: []\n      }\n    };\n    return this.http.post<any>(ENDPOINTS.SEARCH_V4, payload);\n  }\n\n  applyUserGroupAccessControl(request: IUserGroupRequest): Observable<any> {\n    return this.http.put<any>(ENDPOINTS.CREATE_USERGROUPS_CONTROL, request);\n  }\n\n  fetchUserGroupAccessControl(id: string): Observable<any> {\n    return this.http.get<any>(ENDPOINTS.GET_ACCESS_CONTROL(id));\n  }\n\n  updateContentV3(meta: any, id: string): Observable<any> {\n    return this.http.patch<any>(`${ENDPOINTS.ACTION_CONTENT_V3}update/${id}`, meta);\n  }\n\n  downloadFile(data: any, filename = \"data\") {\n    const csvData = this.convertToCSV(data, [\"email\", \"status\", \"mobile\", \"message\"]);\n    const blob = new Blob([`\\ufeff${csvData}`], { type: \"text/csv;charset=utf-8;\" });\n    const dwldLink = document.createElement(\"a\");\n    const url = URL.createObjectURL(blob);\n    const isSafariBrowser = navigator.userAgent.indexOf(\"Safari\") !== -1 && navigator.userAgent.indexOf(\"Chrome\") === -1;\n    if (isSafariBrowser) {\n      // if Safari open in new window to save file with random filename.\n      dwldLink.setAttribute(\"target\", \"_blank\");\n    }\n    dwldLink.setAttribute(\"href\", url);\n    dwldLink.setAttribute(\"download\", `${filename}.csv`);\n    dwldLink.style.visibility = \"hidden\";\n    document.body.appendChild(dwldLink);\n    dwldLink.click();\n    document.body.removeChild(dwldLink);\n  }\n\n  convertToCSV(objArray: any, headerList: any) {\n    const array = typeof objArray !== \"object\" ? JSON.parse(objArray) : objArray;\n    let str = \"\";\n    let row = \"S.No,\";\n\n    for (const index in headerList) {\n      if (headerList[index]) {\n        row += `${headerList[index]} ,`;\n      }\n    }\n    row = row.slice(0, -1);\n    str += `${row}\\r\\n`;\n    // for (let i = 0; i < array.length; i += 1) {\n    for (const iIndex in array) {\n      if (array[iIndex]) {\n        let line = `${toNumber(iIndex) + 1} `;\n        for (const index in headerList) {\n          if (headerList[index]) {\n            const head = headerList[index];\n\n            line += `, ${array[iIndex][head]}`;\n          }\n        }\n        str += `${line}\\r\\n`;\n      }\n    }\n    return str;\n  }\n\n  createRequestContent(apiResponse: any, accessSettingsEnabled: boolean) {\n    return {\n      request: {\n        content: {\n          appIcon: apiResponse.appIcon || \"\",\n          posterImage: apiResponse.posterImage || \"\",\n          code: apiResponse.code || \"\",\n          contentType: apiResponse.contentType || \"\",\n          createdBy: apiResponse.createdBy || \"\",\n          creatorContacts: apiResponse.creatorContacts || [],\n          creatorIDs: apiResponse.creatorIDs || [],\n          createdFor: apiResponse.createdFor || [],\n          creator: apiResponse.creator || \"\",\n          framework: apiResponse.framework || \"\",\n          mimeType: apiResponse.mimeType || \"\",\n          name: apiResponse.name || \"\",\n          organisation: apiResponse.organisation || [],\n          isExternal: apiResponse.isExternal || false,\n          primaryCategory: apiResponse.primaryCategory || \"\",\n          courseCategory: apiResponse.courseCategory || \"\",\n          license: apiResponse.license || \"\",\n          ownershipType: apiResponse.ownershipType || [],\n          cumulativeTracking: apiResponse.cumulativeTracking || false,\n          language: apiResponse.language || [],\n          accessSetting: apiResponse.accessSetting || \"\",\n          versionKey: apiResponse.versionKey || \"\",\n          accessSettingsEnabled: accessSettingsEnabled || false\n        }\n      }\n    };\n  }\n}\n"]}

package/esm2022/lib/_services/cadre-mapping.service.mjs

@@ -0,0 +1,164 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class CadreMappingService {
+    constructor() {
+        this.allCadres = new Map();
+        this.allServices = new Map();
+        this.cadreToServiceMap = new Map();
+        this.serviceToCadresMap = new Map();
+        this.batchYearToCadresMap = new Map();
+        this.batchYearToServicesMap = new Map();
+    }
+    addToMapSet(map, key, value) {
+        if (!map.has(key)) {
+            map.set(key, new Set());
+        }
+        map.get(key)?.add(value);
+    }
+    initialize(data) {
+        // Clear existing data
+        this.allCadres.clear();
+        this.allServices.clear();
+        this.cadreToServiceMap.clear();
+        this.serviceToCadresMap.clear();
+        this.batchYearToCadresMap.clear();
+        this.batchYearToServicesMap.clear();
+        // Build lookups
+        data?.civilServiceType?.civilServiceTypeList.forEach(cst => {
+            if (cst) {
+                cst.serviceList.forEach(service => {
+                    const { id: serviceId, commonBatchStartYear, commonBatchEndYear } = service;
+                    this.allServices.set(serviceId, service);
+                    // Add years to service-batch map
+                    for (let y = commonBatchStartYear; y <= commonBatchEndYear; y++) {
+                        this.addToMapSet(this.batchYearToServicesMap, y, serviceId);
+                    }
+                    service.cadreList?.forEach(cadre => {
+                        const { id: cadreId, startBatchYear, endBatchYear } = cadre;
+                        this.allCadres.set(cadreId, cadre);
+                        // Map cadre <-> service
+                        this.addToMapSet(this.cadreToServiceMap, cadreId, serviceId);
+                        this.addToMapSet(this.serviceToCadresMap, serviceId, cadreId);
+                        // Add years to cadre-batch map
+                        for (let y = startBatchYear; y <= endBatchYear; y++) {
+                            this.addToMapSet(this.batchYearToCadresMap, y, cadreId);
+                        }
+                    });
+                });
+            }
+        });
+    }
+    getAllBatchYears() {
+        return Array.from(this.batchYearToCadresMap.keys()).sort((a, b) => a - b);
+    }
+    getAllCadres() {
+        return Array.from(this.allCadres.values()).map(c => ({
+            id: c.id,
+            name: c.name
+        }));
+    }
+    getAllServices() {
+        return Array.from(this.allServices.values()).map(s => ({
+            id: s.id,
+            name: s.name
+        }));
+    }
+    getServicesByCadres(cadreIds) {
+        const serviceIdsSet = new Set();
+        cadreIds.forEach(cadreId => {
+            const services = this.cadreToServiceMap.get(cadreId) || new Set();
+            services.forEach(serviceId => serviceIdsSet.add(serviceId));
+        });
+        return Array.from(serviceIdsSet).map(id => {
+            const s = this.allServices.get(id);
+            return { id: s.id, name: s.name };
+        });
+    }
+    getCadresByServices(serviceIds) {
+        const cadreIdsSet = new Set();
+        serviceIds.forEach(serviceId => {
+            const cadres = this.serviceToCadresMap.get(serviceId) || new Set();
+            cadres.forEach(cadreId => cadreIdsSet.add(cadreId));
+        });
+        return Array.from(cadreIdsSet).map(id => {
+            const c = this.allCadres.get(id);
+            return { id: c.id, name: c.name };
+        });
+    }
+    getCadresByBatchYears(years) {
+        const cadreIdsSet = new Set();
+        years.forEach(year => {
+            const cadres = this.batchYearToCadresMap.get(year) || new Set();
+            cadres.forEach(cadreId => cadreIdsSet.add(cadreId));
+        });
+        return Array.from(cadreIdsSet).map(id => {
+            const c = this.allCadres.get(id);
+            return { id: c.id, name: c.name };
+        });
+    }
+    getServicesByBatchYears(years) {
+        const serviceIdsSet = new Set();
+        years.forEach(year => {
+            const services = this.batchYearToServicesMap.get(year) || new Set();
+            services.forEach(serviceId => serviceIdsSet.add(serviceId));
+        });
+        return Array.from(serviceIdsSet).map(id => {
+            const s = this.allServices.get(id);
+            return { id: s.id, name: s.name };
+        });
+    }
+    getServicesByCadresAndBatch(cadreIds, year) {
+        const services = this.getServicesByCadres(cadreIds);
+        return services.filter(service => {
+            const fullService = this.allServices.get(service.id);
+            return year >= fullService.commonBatchStartYear && year <= fullService.commonBatchEndYear;
+        });
+    }
+    getCadresByServicesAndBatch(serviceIds, year) {
+        const cadres = this.getCadresByServices(serviceIds);
+        return cadres.filter(cadre => {
+            const fullCadre = this.allCadres.get(cadre.id);
+            return year >= fullCadre.startBatchYear && year <= fullCadre.endBatchYear;
+        });
+    }
+    getBatchYearsByCadres(cadreIds) {
+        const batchYearsSet = new Set();
+        cadreIds.forEach(cadreId => {
+            const cadre = this.allCadres.get(cadreId);
+            if (cadre) {
+                for (let y = cadre.startBatchYear; y <= cadre.endBatchYear; y++) {
+                    batchYearsSet.add(y);
+                }
+            }
+        });
+        return Array.from(batchYearsSet).sort((a, b) => a - b);
+    }
+    getBatchYearsByServices(serviceIds) {
+        const batchYearsSet = new Set();
+        serviceIds.forEach(serviceId => {
+            const service = this.allServices.get(serviceId);
+            if (service) {
+                for (let y = service.commonBatchStartYear; y <= service.commonBatchEndYear; y++) {
+                    batchYearsSet.add(y);
+                }
+            }
+        });
+        return Array.from(batchYearsSet).sort((a, b) => a - b);
+    }
+    getBatchYearsByServicesAndCadres(serviceIds, cadreIds) {
+        const serviceYears = this.getBatchYearsByServices(serviceIds);
+        const cadreYears = this.getBatchYearsByCadres(cadreIds);
+        // Find intersection of years
+        const commonYears = serviceYears.filter(year => cadreYears.includes(year));
+        return commonYears.sort((a, b) => a - b);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CadreMappingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CadreMappingService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CadreMappingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cadre-mapping.service.js","sourceRoot":"","sources":["../../../../../../library/sunbird-cb/access-settings/src/lib/_services/cadre-mapping.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\ninterface CivilServiceData {\n  civilServiceType: {\n    civilServiceTypeList: Array<{\n      id: string;\n      name: string;\n      serviceList: Array<{\n        id: string;\n        name: string;\n        commonBatchStartYear: number;\n        commonBatchEndYear: number;\n        cadreList?: Array<{\n          id: string;\n          name: string;\n          startBatchYear: number;\n          endBatchYear: number;\n        }>;\n      }>;\n    }>;\n  };\n}\n\n@Injectable({\n  providedIn: \"root\"\n})\nexport class CadreMappingService {\n  private allCadres = new Map<string, any>();\n  private allServices = new Map<string, any>();\n  private cadreToServiceMap = new Map<string, Set<string>>();\n  private serviceToCadresMap = new Map<string, Set<string>>();\n  private batchYearToCadresMap = new Map<number, Set<string>>();\n  private batchYearToServicesMap = new Map<number, Set<string>>();\n\n  private addToMapSet(map: Map<any, Set<any>>, key: any, value: any) {\n    if (!map.has(key)) {\n      map.set(key, new Set());\n    }\n    map.get(key)?.add(value);\n  }\n\n  initialize(data: CivilServiceData) {\n    // Clear existing data\n    this.allCadres.clear();\n    this.allServices.clear();\n    this.cadreToServiceMap.clear();\n    this.serviceToCadresMap.clear();\n    this.batchYearToCadresMap.clear();\n    this.batchYearToServicesMap.clear();\n\n    // Build lookups\n    data?.civilServiceType?.civilServiceTypeList.forEach(cst => {\n      if (cst) {\n        cst.serviceList.forEach(service => {\n          const { id: serviceId, commonBatchStartYear, commonBatchEndYear } = service;\n          this.allServices.set(serviceId, service);\n  \n          // Add years to service-batch map\n          for (let y = commonBatchStartYear; y <= commonBatchEndYear; y++) {\n            this.addToMapSet(this.batchYearToServicesMap, y, serviceId);\n          }\n  \n          service.cadreList?.forEach(cadre => {\n            const { id: cadreId, startBatchYear, endBatchYear } = cadre;\n            this.allCadres.set(cadreId, cadre);\n  \n            // Map cadre <-> service\n            this.addToMapSet(this.cadreToServiceMap, cadreId, serviceId);\n            this.addToMapSet(this.serviceToCadresMap, serviceId, cadreId);\n  \n            // Add years to cadre-batch map\n            for (let y = startBatchYear; y <= endBatchYear; y++) {\n              this.addToMapSet(this.batchYearToCadresMap, y, cadreId);\n            }\n          });\n        });\n      }\n    });\n  }\n\n  getAllBatchYears(): number[] {\n    return Array.from(this.batchYearToCadresMap.keys()).sort((a, b) => a - b);\n  }\n\n  getAllCadres(): Array<{ id: string; name: string }> {\n    return Array.from(this.allCadres.values()).map(c => ({\n      id: c.id,\n      name: c.name\n    }));\n  }\n\n  getAllServices(): Array<{ id: string; name: string }> {\n    return Array.from(this.allServices.values()).map(s => ({\n      id: s.id,\n      name: s.name\n    }));\n  }\n\n  getServicesByCadres(cadreIds: string[]): Array<{ id: string; name: string }> {\n    const serviceIdsSet = new Set<string>();\n    cadreIds.forEach(cadreId => {\n      const services = this.cadreToServiceMap.get(cadreId) || new Set();\n      services.forEach(serviceId => serviceIdsSet.add(serviceId));\n    });\n\n    return Array.from(serviceIdsSet).map(id => {\n      const s = this.allServices.get(id);\n      return { id: s.id, name: s.name };\n    });\n  }\n\n  getCadresByServices(serviceIds: string[]): Array<{ id: string; name: string }> {\n    const cadreIdsSet = new Set<string>();\n    serviceIds.forEach(serviceId => {\n      const cadres = this.serviceToCadresMap.get(serviceId) || new Set();\n      cadres.forEach(cadreId => cadreIdsSet.add(cadreId));\n    });\n\n    return Array.from(cadreIdsSet).map(id => {\n      const c = this.allCadres.get(id);\n      return { id: c.id, name: c.name };\n    });\n  }\n\n  getCadresByBatchYears(years: number[]): Array<{ id: string; name: string }> {\n    const cadreIdsSet = new Set<string>();\n    years.forEach(year => {\n      const cadres = this.batchYearToCadresMap.get(year) || new Set();\n      cadres.forEach(cadreId => cadreIdsSet.add(cadreId));\n    });\n\n    return Array.from(cadreIdsSet).map(id => {\n      const c = this.allCadres.get(id);\n      return { id: c.id, name: c.name };\n    });\n  }\n\n  getServicesByBatchYears(years: number[]): Array<{ id: string; name: string }> {\n    const serviceIdsSet = new Set<string>();\n    years.forEach(year => {\n      const services = this.batchYearToServicesMap.get(year) || new Set();\n      services.forEach(serviceId => serviceIdsSet.add(serviceId));\n    });\n\n    return Array.from(serviceIdsSet).map(id => {\n      const s = this.allServices.get(id);\n      return { id: s.id, name: s.name };\n    });\n  }\n\n  getServicesByCadresAndBatch(cadreIds: string[], year: number): Array<{ id: string; name: string }> {\n    const services = this.getServicesByCadres(cadreIds);\n    return services.filter(service => {\n      const fullService = this.allServices.get(service.id);\n      return year >= fullService.commonBatchStartYear && year <= fullService.commonBatchEndYear;\n    });\n  }\n\n  getCadresByServicesAndBatch(serviceIds: string[], year: number): Array<{ id: string; name: string }> {\n    const cadres = this.getCadresByServices(serviceIds);\n    return cadres.filter(cadre => {\n      const fullCadre = this.allCadres.get(cadre.id);\n      return year >= fullCadre.startBatchYear && year <= fullCadre.endBatchYear;\n    });\n  }\n\n  getBatchYearsByCadres(cadreIds: string[]): number[] {\n    const batchYearsSet = new Set<number>();\n    cadreIds.forEach(cadreId => {\n      const cadre = this.allCadres.get(cadreId);\n      if (cadre) {\n        for (let y = cadre.startBatchYear; y <= cadre.endBatchYear; y++) {\n          batchYearsSet.add(y);\n        }\n      }\n    });\n    return Array.from(batchYearsSet).sort((a, b) => a - b);\n  }\n\n  getBatchYearsByServices(serviceIds: string[]): number[] {\n    const batchYearsSet = new Set<number>();\n    serviceIds.forEach(serviceId => {\n      const service = this.allServices.get(serviceId);\n      if (service) {\n        for (let y = service.commonBatchStartYear; y <= service.commonBatchEndYear; y++) {\n          batchYearsSet.add(y);\n        }\n      }\n    });\n    return Array.from(batchYearsSet).sort((a, b) => a - b);\n  }\n\n  getBatchYearsByServicesAndCadres(serviceIds: string[], cadreIds: string[]): number[] {\n    const serviceYears = this.getBatchYearsByServices(serviceIds);\n    const cadreYears = this.getBatchYearsByCadres(cadreIds);\n\n    // Find intersection of years\n    const commonYears = serviceYears.filter(year => cadreYears.includes(year));\n    return commonYears.sort((a, b) => a - b);\n  }\n}\n"]}

package/esm2022/lib/access-settings.component.mjs

@@ -0,0 +1,13 @@
+import { Component } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AccessSettingsComponent {
+    constructor() { }
+    ngOnInit() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessSettingsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AccessSettingsComponent, selector: "sb-uic-access-settings", ngImport: i0, template: ` <p>access settings works!</p> `, isInline: true, styles: ["::ng-deep .mdc-tooltip{--mdc-plain-tooltip-container-color: #616161;--mdc-plain-tooltip-supporting-text-color: #ffffff;--mdc-plain-tooltip-container-shape: 4px;--mdc-plain-tooltip-container-size: 340px;--mdc-plain-tooltip-supporting-text-padding: 8px}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessSettingsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "sb-uic-access-settings", template: ` <p>access settings works!</p> `, styles: ["::ng-deep .mdc-tooltip{--mdc-plain-tooltip-container-color: #616161;--mdc-plain-tooltip-supporting-text-color: #ffffff;--mdc-plain-tooltip-container-shape: 4px;--mdc-plain-tooltip-container-size: 340px;--mdc-plain-tooltip-supporting-text-padding: 8px}\n"] }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjZXNzLXNldHRpbmdzLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnJhcnkvc3VuYmlyZC1jYi9hY2Nlc3Mtc2V0dGluZ3Mvc3JjL2xpYi9hY2Nlc3Mtc2V0dGluZ3MuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUM7O0FBZWxELE1BQU0sT0FBTyx1QkFBdUI7SUFDbEMsZ0JBQWUsQ0FBQztJQUVoQixRQUFRLEtBQUksQ0FBQzsrR0FIRix1QkFBdUI7bUdBQXZCLHVCQUF1Qiw4REFYeEIsaUNBQWlDOzs0RkFXaEMsdUJBQXVCO2tCQWJuQyxTQUFTOytCQUNFLHdCQUF3QixZQUN4QixpQ0FBaUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIE9uSW5pdCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogXCJzYi11aWMtYWNjZXNzLXNldHRpbmdzXCIsXG4gIHRlbXBsYXRlOiBgIDxwPmFjY2VzcyBzZXR0aW5ncyB3b3JrcyE8L3A+IGAsXG4gIHN0eWxlczogW2BcbiAgICA6Om5nLWRlZXAgLm1kYy10b29sdGlwIHtcbiAgICAgIC0tbWRjLXBsYWluLXRvb2x0aXAtY29udGFpbmVyLWNvbG9yOiAjNjE2MTYxO1xuICAgICAgLS1tZGMtcGxhaW4tdG9vbHRpcC1zdXBwb3J0aW5nLXRleHQtY29sb3I6ICNmZmZmZmY7XG4gICAgICAtLW1kYy1wbGFpbi10b29sdGlwLWNvbnRhaW5lci1zaGFwZTogNHB4O1xuICAgICAgLS1tZGMtcGxhaW4tdG9vbHRpcC1jb250YWluZXItc2l6ZTogMzQwcHg7XG4gICAgICAtLW1kYy1wbGFpbi10b29sdGlwLXN1cHBvcnRpbmctdGV4dC1wYWRkaW5nOiA4cHg7XG4gICAgfVxuICBgXVxufSlcbmV4cG9ydCBjbGFzcyBBY2Nlc3NTZXR0aW5nc0NvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gIGNvbnN0cnVjdG9yKCkge31cblxuICBuZ09uSW5pdCgpIHt9XG59XG4iXX0=

package/esm2022/lib/access-settings.module.mjs

@@ -0,0 +1,21 @@
+import { NgModule } from "@angular/core";
+import { AccessSettingsComponent } from "./access-settings.component";
+import { SnackbarComponent } from "./components/snackbar/snackbar.component";
+import { MatIconModule } from "@angular/material/icon";
+import { CommonModule } from "@angular/common";
+import * as i0 from "@angular/core";
+export class AccessSettingsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessSettingsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AccessSettingsModule, declarations: [AccessSettingsComponent, SnackbarComponent], imports: [MatIconModule, CommonModule], exports: [AccessSettingsComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessSettingsModule, imports: [MatIconModule, CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AccessSettingsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AccessSettingsComponent, SnackbarComponent],
+                    imports: [MatIconModule, CommonModule],
+                    exports: [AccessSettingsComponent]
+                }]
+        }] });
+export * from "./access-settings.component";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjZXNzLXNldHRpbmdzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnJhcnkvc3VuYmlyZC1jYi9hY2Nlc3Mtc2V0dGluZ3Mvc3JjL2xpYi9hY2Nlc3Mtc2V0dGluZ3MubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDdEUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sMENBQTBDLENBQUM7QUFDN0UsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7QUFNL0MsTUFBTSxPQUFPLG9CQUFvQjsrR0FBcEIsb0JBQW9CO2dIQUFwQixvQkFBb0IsaUJBSmhCLHVCQUF1QixFQUFFLGlCQUFpQixhQUMvQyxhQUFhLEVBQUUsWUFBWSxhQUMzQix1QkFBdUI7Z0hBRXRCLG9CQUFvQixZQUhyQixhQUFhLEVBQUUsWUFBWTs7NEZBRzFCLG9CQUFvQjtrQkFMaEMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyx1QkFBdUIsRUFBRSxpQkFBaUIsQ0FBQztvQkFDMUQsT0FBTyxFQUFFLENBQUMsYUFBYSxFQUFFLFlBQVksQ0FBQztvQkFDdEMsT0FBTyxFQUFFLENBQUMsdUJBQXVCLENBQUM7aUJBQ25DOztBQUVELGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBBY2Nlc3NTZXR0aW5nc0NvbXBvbmVudCB9IGZyb20gXCIuL2FjY2Vzcy1zZXR0aW5ncy5jb21wb25lbnRcIjtcbmltcG9ydCB7IFNuYWNrYmFyQ29tcG9uZW50IH0gZnJvbSBcIi4vY29tcG9uZW50cy9zbmFja2Jhci9zbmFja2Jhci5jb21wb25lbnRcIjtcbmltcG9ydCB7IE1hdEljb25Nb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvbWF0ZXJpYWwvaWNvblwiO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbQWNjZXNzU2V0dGluZ3NDb21wb25lbnQsIFNuYWNrYmFyQ29tcG9uZW50XSxcbiAgaW1wb3J0czogW01hdEljb25Nb2R1bGUsIENvbW1vbk1vZHVsZV0sXG4gIGV4cG9ydHM6IFtBY2Nlc3NTZXR0aW5nc0NvbXBvbmVudF1cbn0pXG5leHBvcnQgY2xhc3MgQWNjZXNzU2V0dGluZ3NNb2R1bGUge31cbmV4cG9ydCAqIGZyb20gXCIuL2FjY2Vzcy1zZXR0aW5ncy5jb21wb25lbnRcIjtcbiJdfQ==