@annalib/anna-core 7.2.4 → 7.2.6

package/esm2020/lib/anna-core-shared-lib/services/anna-generic-table.service.mjs

@@ -0,0 +1,124 @@
+// Angular import statements
+import { Injectable } from "@angular/core";
+import { ActivatedRoute, Router } from '@angular/router';
+// Third party import statements
+import { Subject } from "rxjs";
+import { cloneDeep } from "lodash-es";
+//sub-entries of anna lib import statement
+import { AnnaFilterService } from "./anna-filter.service";
+import { AnnaSortService } from "./anna-sort.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./anna-filter.service";
+import * as i2 from "@angular/router";
+import * as i3 from "./anna-sort.service";
+export class AnnaGtHelperService {
+    constructor(annaFilterService, router, route, annaSortService) {
+        this.annaFilterService = annaFilterService;
+        this.router = router;
+        this.route = route;
+        this.annaSortService = annaSortService;
+        this.virtualScrollSubject = new Subject();
+        console.log(this.annaFilterService);
+        console.log(this.annaSortService);
+    }
+    calculateNumberOfSkeletonColumnsForTable(tableHeaders) {
+        let numberOfSkeletonColumns = [];
+        var headersInEachColumn = 0;
+        tableHeaders.forEach((column) => {
+            if (column.visible) {
+                headersInEachColumn = 0;
+                column.headerInfo.forEach(() => {
+                    headersInEachColumn++;
+                });
+                numberOfSkeletonColumns.push(Array(headersInEachColumn).fill(0));
+            }
+        });
+        return numberOfSkeletonColumns;
+    }
+    initColumnFilterAndSorting() {
+        this.annaFilterService.tooltipSelectedMap = new Map();
+        this.annaFilterService.selectedRadio = null;
+        this.annaFilterService.appliedFiltersArray = [];
+        this.annaFilterService.initialValueMap = new Map();
+        this.annaSortService.columnSortState = new Map();
+        this.annaSortService.noSortingAppliedData = [];
+    }
+    enableOrDisableClearAllBtn() {
+        let isFilterApplied = this.annaFilterService.appliedFiltersArray.length > 0;
+        let isSortApplied = false;
+        for (let val of this.annaSortService.columnSortState.values()) {
+            if (val == "ASC" || val == "DESC") {
+                isSortApplied = true;
+            }
+        }
+        return isFilterApplied || isSortApplied ? false : true;
+    }
+    updateFiltersInURL() {
+        let latestQueryParams = this.prepareQueryParamsOnFilter();
+        this.router.navigate([], {
+            queryParams: { filters: JSON.stringify(latestQueryParams) },
+            relativeTo: this.route.parent,
+            queryParamsHandling: 'merge'
+        });
+    }
+    prepareQueryParamsOnFilter() {
+        if (!this.annaFilterService.appliedFiltersArray.length &&
+            !this.annaFilterService.tooltipSelectedMap.size &&
+            !this.annaSortService.columnSortState.size) {
+            return null;
+        }
+        let query = {
+            appliedFilters: this.annaFilterService.appliedFiltersArray,
+            selectedFilterData: JSON.stringify(Array.from(this.annaFilterService.tooltipSelectedMap)),
+            sortState: JSON.stringify(Array.from(this.annaSortService.columnSortState))
+        };
+        return query;
+    }
+    initTableFilters(clonedTableData) {
+        this.annaFilterService.tooltipSelectedMap = new Map();
+        this.annaFilterService.selectedRadio = null;
+        this.annaFilterService.appliedFiltersArray = [];
+        this.annaSortService.columnSortState = new Map();
+        this.annaSortService.noSortingAppliedData = cloneDeep(clonedTableData);
+        this.annaFilterService.updateStateOfAllTheKeys(this.annaSortService.columnSortState);
+    }
+    initFilters() {
+        this.annaFilterService.tooltipSelectedMap = new Map();
+        this.annaFilterService.appliedFiltersArray = [];
+    }
+    setDataAsPerPersistingFilter(isPersistingFilter, clonedTable, filters) {
+        let usersTable;
+        if (isPersistingFilter) {
+            usersTable = this.annaFilterService.filterData(clonedTable, "");
+            this.annaSortService.noSortingAppliedData = cloneDeep(usersTable);
+            this.annaSortService.columnSortState = new Map(JSON.parse(filters.sortState));
+            this.annaFilterService.updateStateOfAllTheKeys(this.annaSortService.columnSortState);
+            usersTable = this.callSort(usersTable);
+        }
+        else {
+            usersTable = clonedTable;
+            this.annaSortService.noSortingAppliedData = cloneDeep(usersTable);
+        }
+        return usersTable;
+    }
+    callSort(usersTable) {
+        for (let [key, value] of this.annaSortService.columnSortState) {
+            if (value == "ASC") {
+                usersTable = this.annaSortService.sortDataForComponentOtherThanLurAndCsrPage(true, usersTable, key);
+            }
+            else if (value == "DESC") {
+                usersTable = this.annaSortService.sortDataForComponentOtherThanLurAndCsrPage(false, usersTable, key);
+            }
+        }
+        return usersTable;
+    }
+}
+AnnaGtHelperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaGtHelperService, deps: [{ token: i1.AnnaFilterService }, { token: i2.Router }, { token: i2.ActivatedRoute }, { token: i3.AnnaSortService }], target: i0.ɵɵFactoryTarget.Injectable });
+AnnaGtHelperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaGtHelperService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaGtHelperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AnnaFilterService }, { type: i2.Router }, { type: i2.ActivatedRoute }, { type: i3.AnnaSortService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-generic-table.service.js","sourceRoot":"","sources":["../../../../../../projects/anna-core/src/lib/anna-core-shared-lib/services/anna-generic-table.service.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzD,gCAAgC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,0CAA0C;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;;;;;AAKtD,MAAM,OAAO,mBAAmB;IAG9B,YACU,iBAAoC,EACpC,MAAc,EACd,KAAqB,EACrB,eAAgC;QAHhC,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,WAAM,GAAN,MAAM,CAAQ;QACd,UAAK,GAAL,KAAK,CAAgB;QACrB,oBAAe,GAAf,eAAe,CAAiB;QAL1C,yBAAoB,GAAG,IAAI,OAAO,EAAE,CAAC;QAMjC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAA;QACnC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;IACnC,CAAC;IAEH,wCAAwC,CAAC,YAAmB;QAC1D,IAAI,uBAAuB,GAAY,EAAE,CAAC;QAC1C,IAAI,mBAAmB,GAAG,CAAC,CAAC;QAC5B,YAAY,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YAC5B,IAAI,MAAM,CAAC,OAAO,EAAE;gBAChB,mBAAmB,GAAG,CAAC,CAAC;gBACxB,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,EAAE;oBAC/B,mBAAmB,EAAE,CAAC;gBACtB,CAAC,CAAC,CAAA;gBACF,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;aACpE;QACL,CAAC,CAAC,CAAA;QACF,OAAO,uBAAuB,CAAC;IACjC,CAAC;IAED,0BAA0B;QACxB,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAC;QACtD,IAAI,CAAC,iBAAiB,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5C,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,GAAG,EAAE,CAAC;QAChD,IAAI,CAAC,iBAAiB,CAAC,eAAe,GAAG,IAAI,GAAG,EAAE,CAAC;QACnD,IAAI,CAAC,eAAe,CAAC,eAAe,GAAG,IAAI,GAAG,EAAE,CAAC;QACjD,IAAI,CAAC,eAAe,CAAC,oBAAoB,GAAG,EAAE,CAAC;IACjD,CAAC;IAGD,0BAA0B;QACxB,IAAI,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,MAAM,GAAG,CAAC,CAAC;QAE5E,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,KAAK,IAAI,GAAG,IAAI,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,MAAM,EAAE,EAAE;YAC7D,IAAI,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,MAAM,EAAE;gBACjC,aAAa,GAAG,IAAI,CAAC;aACtB;SACF;QACD,OAAO,eAAe,IAAI,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IACzD,CAAC;IAED,kBAAkB;QAChB,IAAI,iBAAiB,GAAG,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAC1D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAC;YACpB,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,EAAE;YAC3D,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;YAC7B,mBAAmB,EAAE,OAAO;SAC/B,CAAC,CAAC;IACL,CAAC;IAED,0BAA0B;QACxB,IAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,MAAM;YACnD,CAAC,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,IAAI;YAC/C,CAAC,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,IAAI,EAAE;YAC5C,OAAO,IAAI,CAAC;SACb;QAED,IAAI,KAAK,GAAG;YACV,cAAc,EAAE,IAAI,CAAC,iBAAiB,CAAC,mBAAmB;YAC1D,kBAAkB,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;YACzF,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;SAC5E,CAAA;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,gBAAgB,CAAC,eAAoB;QACnC,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAC;QACtD,IAAI,CAAC,iBAAiB,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5C,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,GAAG,EAAE,CAAC;QAEhD,IAAI,CAAC,eAAe,CAAC,eAAe,GAAG,IAAI,GAAG,EAAE,CAAC;QAEjD,IAAI,CAAC,eAAe,CAAC,oBAAoB,GAAG,SAAS,CAAC,eAAe,CAAC,CAAC;QACvE,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;IACvF,CAAC;IAED,WAAW;QACT,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAC;QACtD,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,GAAG,EAAE,CAAC;IAClD,CAAC;IAED,4BAA4B,CAAC,kBAA2B,EAAE,WAAgB,EAAE,OAAY;QACtF,IAAI,UAAU,CAAC;QACf,IAAG,kBAAkB,EAAC;YACpB,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;YAChE,IAAI,CAAC,eAAe,CAAC,oBAAoB,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;YAElE,IAAI,CAAC,eAAe,CAAC,eAAe,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;YAC9E,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,CAAC,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;YACrF,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;SACxC;aACI;YACH,UAAU,GAAG,WAAW,CAAC;YACzB,IAAI,CAAC,eAAe,CAAC,oBAAoB,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;SACnE;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,QAAQ,CAAC,UAAe;QACtB,KAAK,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,eAAe,EAAE;YAC7D,IAAI,KAAK,IAAI,KAAK,EAAE;gBAClB,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,0CAA0C,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;aACrG;iBACI,IAAI,KAAK,IAAI,MAAM,EAAE;gBACxB,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,0CAA0C,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;aACtG;SACF;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;;gHApHU,mBAAmB;oHAAnB,mBAAmB,cAFlB,MAAM;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["// Angular import statements\r\nimport { Injectable } from \"@angular/core\";\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\n\r\n// Third party import statements\r\nimport { Subject } from \"rxjs\";\r\nimport { cloneDeep } from \"lodash-es\";\r\n\r\n//sub-entries of anna lib import statement\r\nimport { AnnaFilterService } from \"./anna-filter.service\";\r\nimport { AnnaSortService } from \"./anna-sort.service\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class AnnaGtHelperService {\r\n\r\n  virtualScrollSubject = new Subject();\r\n  constructor(\r\n    private annaFilterService: AnnaFilterService,\r\n    private router: Router,\r\n    private route: ActivatedRoute,\r\n    private annaSortService: AnnaSortService){\r\n      console.log(this.annaFilterService)\r\n      console.log(this.annaSortService)\r\n    }\r\n\r\n  calculateNumberOfSkeletonColumnsForTable(tableHeaders: any[]): number[][] {\r\n    let numberOfSkeletonColumns: any[][] = [];\r\n    var headersInEachColumn = 0;\r\n    tableHeaders.forEach((column) => {\r\n        if (column.visible) {\r\n            headersInEachColumn = 0;\r\n            column.headerInfo.forEach(() => {\r\n            headersInEachColumn++;\r\n            })\r\n            numberOfSkeletonColumns.push(Array(headersInEachColumn).fill(0));\r\n        }\r\n    })\r\n    return numberOfSkeletonColumns;\r\n  }\r\n\r\n  initColumnFilterAndSorting() {\r\n    this.annaFilterService.tooltipSelectedMap = new Map();\r\n    this.annaFilterService.selectedRadio = null;\r\n    this.annaFilterService.appliedFiltersArray = [];\r\n    this.annaFilterService.initialValueMap = new Map();\r\n    this.annaSortService.columnSortState = new Map();\r\n    this.annaSortService.noSortingAppliedData = [];\r\n  }\r\n\r\n  \r\n  enableOrDisableClearAllBtn(): boolean {\r\n    let isFilterApplied = this.annaFilterService.appliedFiltersArray.length > 0;\r\n\r\n    let isSortApplied = false;\r\n    for (let val of this.annaSortService.columnSortState.values()) {\r\n      if (val == \"ASC\" || val == \"DESC\") {\r\n        isSortApplied = true;\r\n      }\r\n    }\r\n    return isFilterApplied || isSortApplied ? false : true;\r\n  }\r\n\r\n  updateFiltersInURL(){\r\n    let latestQueryParams = this.prepareQueryParamsOnFilter();\r\n    this.router.navigate([],{\r\n        queryParams: { filters: JSON.stringify(latestQueryParams) },\r\n        relativeTo: this.route.parent,\r\n        queryParamsHandling: 'merge'\r\n    });\r\n  }\r\n\r\n  prepareQueryParamsOnFilter() {\r\n    if(!this.annaFilterService.appliedFiltersArray.length && \r\n      !this.annaFilterService.tooltipSelectedMap.size && \r\n      !this.annaSortService.columnSortState.size) {\r\n      return null;\r\n    } \r\n\r\n    let query = {\r\n      appliedFilters: this.annaFilterService.appliedFiltersArray,\r\n      selectedFilterData: JSON.stringify(Array.from(this.annaFilterService.tooltipSelectedMap)),\r\n      sortState: JSON.stringify(Array.from(this.annaSortService.columnSortState))\r\n    }\r\n    return query;\r\n  }\r\n\r\n  initTableFilters(clonedTableData: any) {\r\n    this.annaFilterService.tooltipSelectedMap = new Map();\r\n    this.annaFilterService.selectedRadio = null;\r\n    this.annaFilterService.appliedFiltersArray = [];\r\n\r\n    this.annaSortService.columnSortState = new Map();\r\n\r\n    this.annaSortService.noSortingAppliedData = cloneDeep(clonedTableData);\r\n    this.annaFilterService.updateStateOfAllTheKeys(this.annaSortService.columnSortState);\r\n  }\r\n\r\n  initFilters(){\r\n    this.annaFilterService.tooltipSelectedMap = new Map();\r\n    this.annaFilterService.appliedFiltersArray = [];\r\n  }\r\n\r\n  setDataAsPerPersistingFilter(isPersistingFilter: boolean, clonedTable: any, filters: any): any{\r\n    let usersTable;\r\n    if(isPersistingFilter){\r\n      usersTable = this.annaFilterService.filterData(clonedTable, \"\");\r\n      this.annaSortService.noSortingAppliedData = cloneDeep(usersTable);\r\n\r\n      this.annaSortService.columnSortState = new Map(JSON.parse(filters.sortState));\r\n      this.annaFilterService.updateStateOfAllTheKeys(this.annaSortService.columnSortState);\r\n      usersTable = this.callSort(usersTable);\r\n    }\r\n    else {\r\n      usersTable = clonedTable;\r\n      this.annaSortService.noSortingAppliedData = cloneDeep(usersTable);\r\n    }\r\n    return usersTable;\r\n  }\r\n\r\n  callSort(usersTable: any): any {\r\n    for (let [key, value] of this.annaSortService.columnSortState) {\r\n      if (value == \"ASC\") {\r\n        usersTable = this.annaSortService.sortDataForComponentOtherThanLurAndCsrPage(true, usersTable, key);\r\n      }\r\n      else if (value == \"DESC\") {\r\n        usersTable = this.annaSortService.sortDataForComponentOtherThanLurAndCsrPage(false, usersTable, key);\r\n      }\r\n    }\r\n    return usersTable;\r\n  }\r\n\r\n\r\n\r\n}\r\n"]}

package/esm2020/lib/anna-core-shared-lib/services/anna-global-config.service.mjs

@@ -0,0 +1,133 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AnnaGlobalConfigService {
+    /*
+     Initializing all default settings
+    */
+    constructor() {
+        console.log("AnnaGlobalConfigService service created.");
+        this.defaultAngular2MultiSelectSettings = {
+            text: "Select option",
+            selectAllText: "Select All",
+            unSelectAllText: "UnSelect All",
+            badgeShowLimit: 1,
+            singleSelection: false,
+            classes: "filter-dropdowns",
+            enableSearchFilter: true,
+            enableCheckAll: true,
+            autoPosition: false,
+            disabled: false,
+            position: "bottom",
+            lazyLoading: false,
+            showCheckbox: true,
+            maxHeight: 300,
+            enableFilterSelectAll: true,
+        };
+        this.defaultNgxAsideSettings = {
+            title: '"Filters"',
+            cancelButtonTitle: '"Cancel"',
+            submitButtonTitle: '"Apply"',
+            closeOnEscape: false,
+            showOverlay: false,
+            showDefaultFooter: false,
+            showDefaultHeader: false,
+        };
+        this.defaultNgbDatePickerSettings = {
+            autoClose: false,
+            placeholder: "mm-dd-yyyy",
+            displayMonths: 1,
+            firstDayOfWeek: 1,
+            showWeekNumbers: false,
+            readonly: true,
+        };
+        this.defaultNgSelectSettings = {
+            allowClear: false,
+            placeholder: "Select",
+        };
+        this.defaultNgxInfiniteScrollSettings = {
+            infiniteScrollDistance: 1,
+            infiniteScrollUpDistance: 2,
+            infiniteScrollThrottle: 300,
+            scrollWindow: false,
+        };
+        this.defaultNgxSkeletonLoaderSettings = {
+            numberOfSkeletonRows: Array(6).fill(0),
+        };
+        this.defaultRadioButtonsComponentConfig = {
+            heading: "Select Option",
+            radioButtons: [
+                {
+                    value: "Yes",
+                    isDisabled: false,
+                    label: "Yes",
+                    class: "",
+                },
+                {
+                    value: "No",
+                    isDisabled: false,
+                    label: "No",
+                    class: "",
+                },
+            ],
+        };
+        this.defaultConfirmationPopupConfig = {
+            showCancelButton: true,
+            title: "Are you sure ?",
+            showConfirmButton: true,
+            cancelButtonLabel: "No",
+            confirmButtonLabel: "Yes",
+            showCloseIcon: true,
+            backdrop: "static",
+            windowClass: "",
+            size: "sm",
+            keyboard: false,
+        };
+        this.defaultWeekCalendarConfig = {
+            firstDayOfWeek: 1,
+            showWeekNumbers: true,
+            dateFormatToDisplay: "d MMM y",
+            dateFormatForRequest: "y-MM-dd",
+            maxWeeksToShowWithRemainingCount: 2,
+            numberOfMonthsToEnableInPast: 1,
+            selectMultipleWeeks: false,
+            customClass: "",
+            emitMultipleWeekObjects: true,
+            maxWeeksToSelect: 0,
+            showAsDropdown: true,
+            selectCurrentWeek: true,
+        };
+        this.defaultGtHeaderConfig = {
+            iconColumn: false,
+            checkboxColumn: false,
+            lastColumnKeys: []
+        };
+        this.defaultGtGeneralConfig = {
+            component: "",
+            totalRow: false,
+            isHeaderChecked: false,
+            disableHeaderCheckbox: false,
+            verticalScrollOffsetForFilterTooltip: 0,
+            isGrouped: false,
+            showAllColumnFilter: true,
+            bufferSize: 20,
+            page: ""
+        };
+        this.defaultSingleSelectConfig = {
+            showSearchBar: false,
+            placeholder: "Select",
+            classes: "",
+            position: "BOTTOM",
+            maxHeightOfList: 200
+        };
+        this.defaultMultiSelectConfig = { ...this.defaultSingleSelectConfig, ...{ showErrorWhenNoOptionSelected: true } };
+    }
+}
+AnnaGlobalConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaGlobalConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AnnaGlobalConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaGlobalConfigService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaGlobalConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-global-config.service.js","sourceRoot":"","sources":["../../../../../../projects/anna-core/src/lib/anna-core-shared-lib/services/anna-global-config.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport {\r\n    IAngular2MultiSelectSettings,\r\n    INgxAsideSettings,\r\n    INgbDatePickerSettings,\r\n    INgSelectSettings,\r\n    INgxInfiniteScrollSettings,\r\n    INgxSkeletonLoaderSettings,\r\n    IRadioButtonComponentConfig,\r\n    IConfirmationPopupConfig,\r\n    IWeekCalendar,\r\n    ICustomSingleSelect,\r\n    ICustomMultiSelect,\r\n} from \"../models/anna-global-dropdown-config.model\";\r\nimport {\r\n    IGtHeaderConfig,\r\n    IGtGeneralConfig\r\n} from \"../models/anna-non-editable-gt-models\";\r\n\r\n@Injectable({\r\n    providedIn: \"root\",\r\n})\r\nexport class AnnaGlobalConfigService {\r\n    readonly defaultAngular2MultiSelectSettings: IAngular2MultiSelectSettings;\r\n    readonly defaultNgxAsideSettings: INgxAsideSettings;\r\n    readonly defaultNgbDatePickerSettings: INgbDatePickerSettings;\r\n    readonly defaultNgSelectSettings: INgSelectSettings;\r\n    readonly defaultNgxInfiniteScrollSettings: INgxInfiniteScrollSettings;\r\n    readonly defaultNgxSkeletonLoaderSettings: INgxSkeletonLoaderSettings;\r\n    readonly defaultRadioButtonsComponentConfig: IRadioButtonComponentConfig;\r\n    readonly defaultConfirmationPopupConfig: IConfirmationPopupConfig;\r\n    readonly defaultWeekCalendarConfig: IWeekCalendar;\r\n    readonly defaultGtHeaderConfig: IGtHeaderConfig;\r\n    readonly defaultGtGeneralConfig: IGtGeneralConfig;\r\n    readonly defaultSingleSelectConfig: ICustomSingleSelect;\r\n    readonly defaultMultiSelectConfig: ICustomMultiSelect;\r\n\r\n    /*\r\n     Initializing all default settings\r\n    */\r\n    constructor() {\r\n        console.log(\"AnnaGlobalConfigService service created.\");\r\n        this.defaultAngular2MultiSelectSettings = {\r\n            text: \"Select option\",\r\n            selectAllText: \"Select All\",\r\n            unSelectAllText: \"UnSelect All\",\r\n            badgeShowLimit: 1,\r\n            singleSelection: false,\r\n            classes: \"filter-dropdowns\",\r\n            enableSearchFilter: true,\r\n            enableCheckAll: true,\r\n            autoPosition: false,\r\n            disabled: false,\r\n            position: \"bottom\",\r\n            lazyLoading: false,\r\n            showCheckbox: true,\r\n            maxHeight: 300,\r\n            enableFilterSelectAll: true,\r\n        };\r\n\r\n        this.defaultNgxAsideSettings = {\r\n            title: '\"Filters\"',\r\n            cancelButtonTitle: '\"Cancel\"',\r\n            submitButtonTitle: '\"Apply\"',\r\n            closeOnEscape: false,\r\n            showOverlay: false,\r\n            showDefaultFooter: false,\r\n            showDefaultHeader: false,\r\n        };\r\n\r\n        this.defaultNgbDatePickerSettings = {\r\n            autoClose: false,\r\n            placeholder: \"mm-dd-yyyy\",\r\n            displayMonths: 1,\r\n            firstDayOfWeek: 1,\r\n            showWeekNumbers: false,\r\n            readonly: true,\r\n        };\r\n\r\n        this.defaultNgSelectSettings = {\r\n            allowClear: false,\r\n            placeholder: \"Select\",\r\n        };\r\n\r\n        this.defaultNgxInfiniteScrollSettings = {\r\n            infiniteScrollDistance: 1,\r\n            infiniteScrollUpDistance: 2,\r\n            infiniteScrollThrottle: 300,\r\n            scrollWindow: false,\r\n        };\r\n\r\n        this.defaultNgxSkeletonLoaderSettings = {\r\n            numberOfSkeletonRows: Array(6).fill(0),\r\n        };\r\n\r\n        this.defaultRadioButtonsComponentConfig = {\r\n            heading: \"Select Option\",\r\n            radioButtons: [\r\n                {\r\n                    value: \"Yes\",\r\n                    isDisabled: false,\r\n                    label: \"Yes\",\r\n                    class: \"\",\r\n                },\r\n                {\r\n                    value: \"No\",\r\n                    isDisabled: false,\r\n                    label: \"No\",\r\n                    class: \"\",\r\n                },\r\n            ],\r\n        };\r\n\r\n        this.defaultConfirmationPopupConfig = {\r\n            showCancelButton: true,\r\n            title: \"Are you sure ?\",\r\n            showConfirmButton: true,\r\n            cancelButtonLabel: \"No\",\r\n            confirmButtonLabel: \"Yes\",\r\n            showCloseIcon: true,\r\n            backdrop: \"static\",\r\n            windowClass: \"\",\r\n            size: \"sm\",\r\n            keyboard: false,\r\n        };\r\n\r\n        this.defaultWeekCalendarConfig = {\r\n            firstDayOfWeek: 1,\r\n            showWeekNumbers: true,\r\n            dateFormatToDisplay: \"d MMM y\",\r\n            dateFormatForRequest: \"y-MM-dd\",\r\n            maxWeeksToShowWithRemainingCount: 2,\r\n            numberOfMonthsToEnableInPast: 1,\r\n            selectMultipleWeeks: false,\r\n            customClass: \"\",\r\n            emitMultipleWeekObjects: true,\r\n            maxWeeksToSelect: 0,\r\n            showAsDropdown: true,\r\n            selectCurrentWeek: true,\r\n        };\r\n\r\n        this.defaultGtHeaderConfig = {\r\n            iconColumn: false,\r\n            checkboxColumn: false,\r\n            lastColumnKeys: []\r\n        };\r\n\r\n        this.defaultGtGeneralConfig = {\r\n            component: \"\",\r\n            totalRow: false,\r\n            isHeaderChecked: false,\r\n            disableHeaderCheckbox: false,\r\n            verticalScrollOffsetForFilterTooltip: 0,\r\n            isGrouped: false,\r\n            showAllColumnFilter: true,\r\n            bufferSize: 20,\r\n            page: \"\"\r\n        };\r\n\r\n        this.defaultSingleSelectConfig = {\r\n            showSearchBar: false,\r\n            placeholder:  \"Select\",\r\n            classes: \"\",\r\n            position: \"BOTTOM\",\r\n            maxHeightOfList: 200\r\n        }\r\n\r\n        this.defaultMultiSelectConfig = {...this.defaultSingleSelectConfig, ...{showErrorWhenNoOptionSelected: true}};\r\n    }\r\n}\r\n"]}

package/esm2020/lib/anna-core-shared-lib/services/anna-number-format.service.mjs

@@ -0,0 +1,41 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AnnaNumberFormatService {
+    static GetRoundedValueWithUnits(inputValue, digitsToRoundDecimalPoint = 2) {
+        let [value, unit] = AnnaNumberFormatService.GetValueInUnits(Math.abs(inputValue));
+        value = +((+value).toFixed(digitsToRoundDecimalPoint));
+        if (inputValue < 0) {
+            value = value * -1;
+        }
+        return value.toString() + unit;
+        //   return (Math.Round(value, digitsToRoundDecimalPoint, MidpointRounding.AwayFromZero) + unit);
+    }
+    static GetValueInUnits(inputValue) {
+        let unit = "";
+        let thousand = 1000;
+        let million = 1000000;
+        let billion = 1000000000;
+        if (inputValue >= thousand && inputValue < million) {
+            inputValue = inputValue / thousand;
+            unit = "K";
+        }
+        else if (inputValue >= million && inputValue < billion) {
+            inputValue = inputValue / million;
+            unit = "M";
+        }
+        else if (inputValue >= billion) {
+            inputValue = inputValue / billion;
+            unit = "B";
+        }
+        return [inputValue, unit];
+    }
+}
+AnnaNumberFormatService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaNumberFormatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AnnaNumberFormatService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaNumberFormatService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaNumberFormatService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5uYS1udW1iZXItZm9ybWF0LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbm5hLWNvcmUvc3JjL2xpYi9hbm5hLWNvcmUtc2hhcmVkLWxpYi9zZXJ2aWNlcy9hbm5hLW51bWJlci1mb3JtYXQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8sdUJBQXVCO0lBRTdCLE1BQU0sQ0FBQyx3QkFBd0IsQ0FBQyxVQUFrQixFQUFFLHlCQUF5QixHQUFHLENBQUM7UUFFbEYsSUFBSSxDQUFDLEtBQUssRUFBQyxJQUFJLENBQUMsR0FBRyx1QkFBdUIsQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDO1FBQ2pGLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLE9BQU8sQ0FBQyx5QkFBeUIsQ0FBQyxDQUFDLENBQUM7UUFDdkQsSUFBRyxVQUFVLEdBQUcsQ0FBQyxFQUFDO1lBQ2QsS0FBSyxHQUFHLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQztTQUN0QjtRQUNELE9BQU8sS0FBSyxDQUFDLFFBQVEsRUFBRSxHQUFHLElBQUksQ0FBQztRQUNqQyxpR0FBaUc7SUFDbkcsQ0FBQztJQUVNLE1BQU0sQ0FBQyxlQUFlLENBQUMsVUFBa0I7UUFDNUMsSUFBSSxJQUFJLEdBQUcsRUFBRSxDQUFDO1FBQ2QsSUFBSSxRQUFRLEdBQUcsSUFBSSxDQUFDO1FBQ3BCLElBQUksT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN0QixJQUFJLE9BQU8sR0FBRyxVQUFVLENBQUM7UUFFekIsSUFBSSxVQUFVLElBQUksUUFBUSxJQUFJLFVBQVUsR0FBRyxPQUFPLEVBQ2xEO1lBQ0ksVUFBVSxHQUFHLFVBQVUsR0FBRyxRQUFRLENBQUM7WUFDbkMsSUFBSSxHQUFHLEdBQUcsQ0FBQztTQUNkO2FBQ0ksSUFBSSxVQUFVLElBQUksT0FBTyxJQUFJLFVBQVUsR0FBRyxPQUFPLEVBQ3REO1lBQ0ksVUFBVSxHQUFHLFVBQVUsR0FBRyxPQUFPLENBQUM7WUFDbEMsSUFBSSxHQUFHLEdBQUcsQ0FBQztTQUNkO2FBQ0ksSUFBSSxVQUFVLElBQUksT0FBTyxFQUM5QjtZQUNJLFVBQVUsR0FBRyxVQUFVLEdBQUcsT0FBTyxDQUFDO1lBQ2xDLElBQUksR0FBRyxHQUFHLENBQUM7U0FDZDtRQUVELE9BQU8sQ0FBQyxVQUFVLEVBQUMsSUFBSSxDQUFDLENBQUM7SUFDN0IsQ0FBQzs7b0hBcENVLHVCQUF1Qjt3SEFBdkIsdUJBQXVCLGNBRnBCLE1BQU07MkZBRVQsdUJBQXVCO2tCQUhuQyxVQUFVO21CQUFDO29CQUNSLFVBQVUsRUFBRSxNQUFNO2lCQUNyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gICAgcHJvdmlkZWRJbjogXCJyb290XCIsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBBbm5hTnVtYmVyRm9ybWF0U2VydmljZSB7XHJcblxyXG5wdWJsaWMgc3RhdGljIEdldFJvdW5kZWRWYWx1ZVdpdGhVbml0cyhpbnB1dFZhbHVlOiBudW1iZXIsIGRpZ2l0c1RvUm91bmREZWNpbWFsUG9pbnQgPSAyKVxyXG4gIHtcclxuICAgICAgbGV0IFt2YWx1ZSx1bml0XSA9IEFubmFOdW1iZXJGb3JtYXRTZXJ2aWNlLkdldFZhbHVlSW5Vbml0cyhNYXRoLmFicyhpbnB1dFZhbHVlKSk7XHJcbiAgICAgIHZhbHVlID0gKygoK3ZhbHVlKS50b0ZpeGVkKGRpZ2l0c1RvUm91bmREZWNpbWFsUG9pbnQpKTtcclxuICAgICAgaWYoaW5wdXRWYWx1ZSA8IDApe1xyXG4gICAgICAgICAgdmFsdWUgPSB2YWx1ZSAqIC0xO1xyXG4gICAgICB9XHJcbiAgICAgIHJldHVybiB2YWx1ZS50b1N0cmluZygpICsgdW5pdDtcclxuICAgIC8vICAgcmV0dXJuIChNYXRoLlJvdW5kKHZhbHVlLCBkaWdpdHNUb1JvdW5kRGVjaW1hbFBvaW50LCBNaWRwb2ludFJvdW5kaW5nLkF3YXlGcm9tWmVybykgKyB1bml0KTtcclxuICB9XHJcblxyXG4gIHB1YmxpYyBzdGF0aWMgR2V0VmFsdWVJblVuaXRzKGlucHV0VmFsdWU6IG51bWJlcil7XHJcbiAgICAgIGxldCB1bml0ID0gXCJcIjtcclxuICAgICAgbGV0IHRob3VzYW5kID0gMTAwMDtcclxuICAgICAgbGV0IG1pbGxpb24gPSAxMDAwMDAwO1xyXG4gICAgICBsZXQgYmlsbGlvbiA9IDEwMDAwMDAwMDA7XHJcblxyXG4gICAgICBpZiAoaW5wdXRWYWx1ZSA+PSB0aG91c2FuZCAmJiBpbnB1dFZhbHVlIDwgbWlsbGlvbilcclxuICAgICAge1xyXG4gICAgICAgICAgaW5wdXRWYWx1ZSA9IGlucHV0VmFsdWUgLyB0aG91c2FuZDtcclxuICAgICAgICAgIHVuaXQgPSBcIktcIjtcclxuICAgICAgfVxyXG4gICAgICBlbHNlIGlmIChpbnB1dFZhbHVlID49IG1pbGxpb24gJiYgaW5wdXRWYWx1ZSA8IGJpbGxpb24pXHJcbiAgICAgIHtcclxuICAgICAgICAgIGlucHV0VmFsdWUgPSBpbnB1dFZhbHVlIC8gbWlsbGlvbjtcclxuICAgICAgICAgIHVuaXQgPSBcIk1cIjtcclxuICAgICAgfVxyXG4gICAgICBlbHNlIGlmIChpbnB1dFZhbHVlID49IGJpbGxpb24pXHJcbiAgICAgIHtcclxuICAgICAgICAgIGlucHV0VmFsdWUgPSBpbnB1dFZhbHVlIC8gYmlsbGlvbjtcclxuICAgICAgICAgIHVuaXQgPSBcIkJcIjtcclxuICAgICAgfVxyXG5cclxuICAgICAgcmV0dXJuIFtpbnB1dFZhbHVlLHVuaXRdO1xyXG4gIH1cclxufSJdfQ==

package/esm2020/lib/anna-core-shared-lib/services/anna-sort.service.mjs

@@ -0,0 +1,147 @@
+// Angular import statements
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { AnnaDateTimeFormatService } from './anna-date-time-format.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./anna-date-time-format.service";
+// Third party import statements
+// User defined import statements
+export class AnnaSortService {
+    constructor(annaDateTimeFormatService) {
+        this.annaDateTimeFormatService = annaDateTimeFormatService;
+        this.updateSortTypeSubject = new Subject();
+        this.dateSet = new Set([
+            'endDate',
+            'startDate',
+            'end_date',
+            'start_date',
+            'flightStartDate',
+            'flightEndDate',
+        ]);
+        console.log('AnnaTableColumnSortService sevice created.');
+    }
+    sortDataForComponentOtherThanLurAndCsrPage(isAsc, data, key) {
+        let param1;
+        let param2;
+        if (this.dateSet.has(key)) {
+            data.sort((a, b) => {
+                return this.annaDateTimeFormatService.compareDate(a[key], b[key], isAsc);
+            });
+        }
+        else if (key === 'AirDateAndTime') {
+            data.sort((a, b) => {
+                let first, second;
+                if (a[key] == '-') {
+                    return 1;
+                }
+                if (b[key] == '-') {
+                    return -1;
+                }
+                else {
+                    first =
+                        this.annaDateTimeFormatService.formatDateAndHHMMATimeToStandardFormat(a[key]);
+                    second =
+                        this.annaDateTimeFormatService.formatDateAndHHMMATimeToStandardFormat(b[key]);
+                    let compareDate = this.annaDateTimeFormatService.compareDate(first, second, isAsc);
+                    return compareDate;
+                }
+            });
+        }
+        else if (key == 'startEndTime' || key == 'TimeBand') {
+            data.sort((a, b) => {
+                if (isAsc) {
+                    param1 = a[key][1];
+                    param2 = b[key][1];
+                }
+                else {
+                    param1 = a[key][2];
+                    param2 = b[key][2];
+                }
+                let val = isAsc
+                    ? this.annaDateTimeFormatService.sortByTimeAscending(param1, param2)
+                    : this.annaDateTimeFormatService.sortByTimeDescending(param1, param2);
+                return val;
+            });
+        }
+        else {
+            data.sort((a, b) => {
+                param1 = a[key];
+                param2 = b[key];
+                if (param1 !== param2) {
+                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);
+                }
+                return 0;
+            });
+        }
+        return data;
+    }
+    sortEnterEditLurAndCsrPage(isAsc, data, key) {
+        let param1;
+        let param2;
+        if (key.includes('_')) {
+            let keys = key.split('_');
+            let weekNumber = keys[0];
+            let sortKey = keys[1];
+            if (keys.length > 2) {
+                sortKey =
+                    keys[2] == true
+                        ? 'BookedAurIncludingNoChargeSpots'
+                        : 'BookedAurExcludingNoChargeSpots';
+            }
+            data.sort((a, b) => {
+                let aInventoryCodeWeekWiseKey = Object.keys(a.WeekWiseInventoryCodeData).filter((key) => key.split('_')[1] == weekNumber);
+                let bInventoryCodeWeekWiseKey = Object.keys(b.WeekWiseInventoryCodeData).filter((key) => key.split('_')[1] == weekNumber);
+                param1 = null;
+                param2 = null;
+                if (aInventoryCodeWeekWiseKey.length > 0) {
+                    param1 =
+                        a.WeekWiseInventoryCodeData[aInventoryCodeWeekWiseKey[0]][sortKey][1];
+                }
+                if (bInventoryCodeWeekWiseKey.length > 0) {
+                    param2 =
+                        b.WeekWiseInventoryCodeData[bInventoryCodeWeekWiseKey[0]][sortKey][1];
+                }
+                if (param1 !== param2) {
+                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);
+                }
+                return 0;
+            });
+        }
+        else if (key == 'TimeBand') {
+            data.sort((a, b) => {
+                if (isAsc) {
+                    param1 = a[key][1];
+                    param2 = b[key][1];
+                }
+                else {
+                    param1 = a[key][2];
+                    param2 = b[key][2];
+                }
+                let val = isAsc
+                    ? this.annaDateTimeFormatService.sortByTimeAscending(param1, param2)
+                    : this.annaDateTimeFormatService.sortByTimeDescending(param1, param2);
+                return val;
+            });
+        }
+        else {
+            data.sort((a, b) => {
+                param1 = a[key];
+                param2 = b[key];
+                if (param1 !== param2) {
+                    return this.annaDateTimeFormatService.compare(param1, param2, isAsc);
+                }
+                return 0;
+            });
+        }
+        return data;
+    }
+}
+AnnaSortService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaSortService, deps: [{ token: i1.AnnaDateTimeFormatService }], target: i0.ɵɵFactoryTarget.Injectable });
+AnnaSortService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaSortService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: AnnaSortService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AnnaDateTimeFormatService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"anna-sort.service.js","sourceRoot":"","sources":["../../../../../../projects/anna-core/src/lib/anna-core-shared-lib/services/anna-sort.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular import statements\r\nimport { Injectable } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { SortType } from '../models/anna-sort.model';\r\nimport { AnnaDateTimeFormatService } from './anna-date-time-format.service';\r\n\r\n// Third party import statements\r\n\r\n// User defined import statements\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class AnnaSortService {\r\n  columnSortState: Map<string, SortType>;\r\n  noSortingAppliedData: any[];\r\n  updateSortTypeSubject: Subject<string> = new Subject();\r\n\r\n  dateSet = new Set([\r\n    'endDate',\r\n    'startDate',\r\n    'end_date',\r\n    'start_date',\r\n    'flightStartDate',\r\n    'flightEndDate',\r\n  ]);\r\n\r\n  constructor(private annaDateTimeFormatService: AnnaDateTimeFormatService) {\r\n    console.log('AnnaTableColumnSortService sevice created.');\r\n  }\r\n\r\n  sortDataForComponentOtherThanLurAndCsrPage(\r\n    isAsc: boolean,\r\n    data: any[],\r\n    key: string\r\n  ) {\r\n    let param1: string | number;\r\n    let param2: string | number;\r\n\r\n    if (this.dateSet.has(key)) {\r\n      data.sort((a, b) => {\r\n        return this.annaDateTimeFormatService.compareDate(\r\n          a[key],\r\n          b[key],\r\n          isAsc\r\n        );\r\n      });\r\n    } else if (key === 'AirDateAndTime') {\r\n      data.sort((a, b) => {\r\n        let first, second;\r\n        if (a[key] == '-') {\r\n          return 1;\r\n        }\r\n\r\n        if (b[key] == '-') {\r\n          return -1;\r\n        } else {\r\n          first =\r\n            this.annaDateTimeFormatService.formatDateAndHHMMATimeToStandardFormat(\r\n              a[key]\r\n            );\r\n          second =\r\n            this.annaDateTimeFormatService.formatDateAndHHMMATimeToStandardFormat(\r\n              b[key]\r\n            );\r\n          let compareDate = this.annaDateTimeFormatService.compareDate(\r\n            first,\r\n            second,\r\n            isAsc\r\n          );\r\n          return compareDate;\r\n        }\r\n      });\r\n    } else if (key == 'startEndTime' || key == 'TimeBand') {\r\n      data.sort((a, b) => {\r\n        if (isAsc) {\r\n          param1 = a[key][1];\r\n          param2 = b[key][1];\r\n        } else {\r\n          param1 = a[key][2];\r\n          param2 = b[key][2];\r\n        }\r\n        let val = isAsc\r\n          ? this.annaDateTimeFormatService.sortByTimeAscending(param1, param2)\r\n          : this.annaDateTimeFormatService.sortByTimeDescending(param1, param2);\r\n        return val;\r\n      });\r\n    } else {\r\n      data.sort((a, b) => {\r\n        param1 = a[key];\r\n        param2 = b[key];\r\n\r\n        if (param1 !== param2) {\r\n          return this.annaDateTimeFormatService.compare(param1, param2, isAsc);\r\n        }\r\n\r\n        return 0;\r\n      });\r\n    }\r\n\r\n    return data;\r\n  }\r\n\r\n  sortEnterEditLurAndCsrPage(isAsc: boolean, data: any[], key: any) {\r\n    let param1: string | number;\r\n    let param2: string | number;\r\n\r\n    if (key.includes('_')) {\r\n      let keys = key.split('_');\r\n      let weekNumber = keys[0];\r\n      let sortKey = keys[1];\r\n\r\n      if (keys.length > 2) {\r\n        sortKey =\r\n          keys[2] == true\r\n            ? 'BookedAurIncludingNoChargeSpots'\r\n            : 'BookedAurExcludingNoChargeSpots';\r\n      }\r\n\r\n      data.sort((a, b) => {\r\n        let aInventoryCodeWeekWiseKey = Object.keys(\r\n          a.WeekWiseInventoryCodeData\r\n        ).filter((key) => key.split('_')[1] == weekNumber);\r\n        let bInventoryCodeWeekWiseKey = Object.keys(\r\n          b.WeekWiseInventoryCodeData\r\n        ).filter((key) => key.split('_')[1] == weekNumber);\r\n\r\n        param1 = null;\r\n        param2 = null;\r\n        if (aInventoryCodeWeekWiseKey.length > 0) {\r\n          param1 =\r\n            a.WeekWiseInventoryCodeData[aInventoryCodeWeekWiseKey[0]][\r\n              sortKey\r\n            ][1];\r\n        }\r\n\r\n        if (bInventoryCodeWeekWiseKey.length > 0) {\r\n          param2 =\r\n            b.WeekWiseInventoryCodeData[bInventoryCodeWeekWiseKey[0]][\r\n              sortKey\r\n            ][1];\r\n        }\r\n\r\n        if (param1 !== param2) {\r\n          return this.annaDateTimeFormatService.compare(param1, param2, isAsc);\r\n        }\r\n\r\n        return 0;\r\n      });\r\n    } else if (key == 'TimeBand') {\r\n      data.sort((a, b) => {\r\n        if (isAsc) {\r\n          param1 = a[key][1];\r\n          param2 = b[key][1];\r\n        } else {\r\n          param1 = a[key][2];\r\n          param2 = b[key][2];\r\n        }\r\n        let val = isAsc\r\n          ? this.annaDateTimeFormatService.sortByTimeAscending(param1, param2)\r\n          : this.annaDateTimeFormatService.sortByTimeDescending(param1, param2);\r\n        return val;\r\n      });\r\n    } else {\r\n      data.sort((a, b) => {\r\n        param1 = a[key];\r\n        param2 = b[key];\r\n\r\n        if (param1 !== param2) {\r\n          return this.annaDateTimeFormatService.compare(param1, param2, isAsc);\r\n        }\r\n\r\n        return 0;\r\n      });\r\n    }\r\n\r\n    return data;\r\n  }\r\n}\r\n"]}