tango-app-ui-manage-tickets 3.7.0-beta.61 → 3.7.0-beta.62

package/esm2022/lib/services/ticket.service.mjs

@@ -0,0 +1,319 @@
+import { Injectable } from "@angular/core";
+import { BehaviorSubject, } from "rxjs";
+import { HttpParams } from "@angular/common/http";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "tango-app-ui-global";
+export class TicketService {
+    http;
+    gs;
+    userApiUrl;
+    ticketsApiUrl;
+    auditApiUrl;
+    auditmetricApiUrl;
+    zoneauditApiUrl;
+    footfallDirapiUrl;
+    footfallCDN;
+    trafficApiUrl;
+    revopApiUrl;
+    clientApiUrl;
+    vmsAuditUrl;
+    dropDownTrigger = new BehaviorSubject(null);
+    constructor(http, gs) {
+        this.http = http;
+        this.gs = gs;
+        this.gs.environment.subscribe((env) => {
+            if (env) {
+                this.userApiUrl = env.userApiUrl;
+                this.ticketsApiUrl = env.ticketsApiUrl;
+                this.auditmetricApiUrl = env.auditmetricApiUrl;
+                this.auditApiUrl = env.auditApiUrl;
+                this.zoneauditApiUrl = env.zoneauditApiUrl;
+                this.clientApiUrl = env.clientApiUrl;
+                this.footfallDirapiUrl = env.footfallDirapiUrl;
+                this.footfallCDN = env.footfallCDN;
+                this.trafficApiUrl = env.trafficApiUrl;
+                this.revopApiUrl = env.revopApiUrl;
+                this.vmsAuditUrl = env.vmsAuditUrl;
+            }
+        });
+    }
+    getUserList(params) {
+        return this.http.post(`${this.userApiUrl}/get-list`, params);
+    }
+    exportInstallationList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/installationTable`, data, { responseType: "arraybuffer" });
+    }
+    exportInfraList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/infraTable`, data, {
+            responseType: "arraybuffer",
+        });
+    }
+    exportMatList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/matTable`, data, {
+            responseType: "arraybuffer",
+        });
+    }
+    getSotresList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/storeFilter`, data);
+    }
+    getInstallationList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/installationTable`, data);
+    }
+    getInfraList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/infraTable`, data);
+    }
+    getAssignTicket(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/assignTicket`, data);
+    }
+    getMatList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/matTable`, data);
+    }
+    updateTicketIssue(data) {
+        return this.http.post(`${this.ticketsApiUrl}/employeeTraning/updatecomment`, data);
+    }
+    getUserActiveList(params) {
+        return this.http.post(`${this.userApiUrl}/list`, params);
+    }
+    getAllCounts(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/allCounts`, data);
+    }
+    getstoreMetrics(data) {
+        return this.http.post(`${this.auditApiUrl}/metrics/store-metrics`, data);
+    }
+    getstoreMetricsExport(data) {
+        return this.http.post(`${this.auditApiUrl}/metrics/store-metrics`, data, { responseType: 'arraybuffer' });
+    }
+    getclientList() {
+        return this.http.get(`${this.auditApiUrl}/clients`);
+    }
+    getuserList() {
+        return this.http.get(`${this.auditApiUrl}/tango-users`);
+    }
+    auditretrigger(data) {
+        return this.http.post(`${this.auditApiUrl}/metrics/re-trigger`, data);
+    }
+    getfootfallcount(data) {
+        return this.http.get(`${this.revopApiUrl}/store-processed-data?storeId=${data.storeId}&fromDate=${data.Date}&toDate=${data.Date}`);
+    }
+    getstoreList(data) {
+        return this.http.post(`${this.auditApiUrl}/audit-stores`, data);
+    }
+    checkTicketExists(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/checkTicketExists`, data);
+    }
+    mergeticket(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/mergeticket`, data);
+    }
+    getDataMismathList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/dataMismatchTable`, data);
+    }
+    accuracyReasonsupdate(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/tango-review-accuracy-ticket`, data);
+    }
+    exportDataMismatchList(data) {
+        return this.http.post(`${this.ticketsApiUrl}/infra/dataMismatchTable`, data, { responseType: "arraybuffer" });
+    }
+    getAuditImages(data) {
+        return this.http.get(`${this.auditApiUrl}/audit-images?fileDate=${data?.fileDate}&storeId=${data?.storeId}&imageType=${data?.imageType}&export=${data?.export}&zoneName=${data?.zoneName}&moduleType=${data?.moduleType}`);
+    }
+    ExportAuditImagesasxlsx(data) {
+        return this.http.get(`${this.auditApiUrl}/audit-images?fileDate=${data?.fileDate}&storeId=${data?.storeId}&imageType=${data?.imageType}&export=${data?.export}&zoneName=${data?.zoneName}&moduleType=${data?.moduleType}`, { responseType: "arraybuffer" });
+    }
+    getTicketSummaryApi(client, fromDate, toDate, tangoType, permissionType) {
+        let url = `${this.footfallDirapiUrl}/ticket-summary?` +
+            `clientId=${client}` +
+            `&fromDate=${fromDate}` +
+            `&toDate=${toDate}` +
+            `&tangoType=${tangoType}`;
+        if (permissionType) {
+            url += `&permissionType=${permissionType}`;
+        }
+        return this.http.get(url);
+    }
+    accuracyReasons(client) {
+        return this.http.get(`${this.footfallDirapiUrl}/get-accuarcy-issues?clientId=${client}`);
+    }
+    getTicketListOldApi(client, fromDate, toDate, searchvalue, limit, offset, isExport, sortBy, sortOrder) {
+        return this.http.get(`${this.footfallDirapiUrl}/ticket-list?clientId=${client}&fromDate=${fromDate}&toDate=${toDate}&searchValue=${searchvalue}&limit=${limit}&offset=${offset}&isExport=${isExport}&sortBy=${sortBy}&sortOrder=${sortOrder}`);
+    }
+    getTicketListApi(client, fromDate, toDate, searchvalue, limit, offset, isExport, sortBy, sortOrder, tangoType, permissionType, filters) {
+        let url = `${this.footfallDirapiUrl}/ticket-list?` +
+            `clientId=${client}` +
+            `&fromDate=${fromDate}` +
+            `&toDate=${toDate}` +
+            `&searchValue=${searchvalue}` +
+            `&limit=${limit}` +
+            `&offset=${offset}` +
+            `&isExport=${isExport}` +
+            `&sortBy=${sortBy}` +
+            `&sortOrder=${sortOrder}` +
+            `&tangoType=${tangoType}`;
+        if (permissionType) {
+            url += `&permissionType=${permissionType}`;
+        }
+        if (filters) {
+            // array params – send as comma-separated
+            if (filters.filterByStatus?.length) {
+                url += `&filterByStatus=${encodeURIComponent(filters.filterByStatus.join(','))}`;
+            }
+            if (filters.filterByReviewedBy?.length) {
+                url += `&filterByReviewedBy=${encodeURIComponent(filters.filterByReviewedBy.join(','))}`;
+            }
+            if (filters.fileterByApprovedBy?.length) {
+                url += `&fileterByApprovedBy=${encodeURIComponent(filters.fileterByApprovedBy.join(','))}`;
+            }
+            // string params – JSON stringified accuracy
+            if (filters.filterByReviewer) {
+                url += `&filterByReviewer=${encodeURIComponent(filters.filterByReviewer)}`;
+            }
+            if (filters.filterByApprover) {
+                url += `&filterByApprover=${encodeURIComponent(filters.filterByApprover)}`;
+            }
+            if (filters.filterByTango) {
+                url += `&filterByTango=${encodeURIComponent(filters.filterByTango)}`;
+            }
+        }
+        return this.http.get(url);
+    }
+    getTicketListExportOldApi(client, fromDate, toDate, searchvalue, limit, offset, isExport, sortBy, sortOrder) {
+        return this.http.get(`${this.footfallDirapiUrl}/ticket-list?clientId=${client}&fromDate=${fromDate}&toDate=${toDate}&searchValue=${searchvalue}&limit=${limit}&offset=${offset}&isExport=${isExport}&sortBy=${sortBy}&sortOrder=${sortOrder}`, { responseType: "arraybuffer" });
+    }
+    getTicketListExportApi(client, fromDate, toDate, searchvalue, limit, offset, isExport, sortBy, sortOrder, tangoType, permissionType, filters) {
+        let url = `${this.footfallDirapiUrl}/ticket-list?` +
+            `clientId=${client}` +
+            `&fromDate=${fromDate}` +
+            `&toDate=${toDate}` +
+            `&searchValue=${searchvalue}` +
+            `&limit=${limit}` +
+            `&offset=${offset}` +
+            `&isExport=${isExport}` +
+            `&sortBy=${sortBy}` +
+            `&sortOrder=${sortOrder}` +
+            `&tangoType=${tangoType}`;
+        if (permissionType) {
+            url += `&permissionType=${permissionType}`;
+        }
+        if (filters) {
+            if (filters.filterByStatus?.length) {
+                url += `&filterByStatus=${encodeURIComponent(filters.filterByStatus.join(','))}`;
+            }
+            if (filters.filterByReviewedBy?.length) {
+                url += `&filterByReviewedBy=${encodeURIComponent(filters.filterByReviewedBy.join(','))}`;
+            }
+            if (filters.fileterByApprovedBy?.length) {
+                url += `&fileterByApprovedBy=${encodeURIComponent(filters.fileterByApprovedBy.join(','))}`;
+            }
+            if (filters.filterByReviewer) {
+                url += `&filterByReviewer=${encodeURIComponent(filters.filterByReviewer)}`;
+            }
+            if (filters.filterByApprover) {
+                url += `&filterByApprover=${encodeURIComponent(filters.filterByApprover)}`;
+            }
+            if (filters.filterByTango) {
+                url += `&filterByTango=${encodeURIComponent(filters.filterByTango)}`;
+            }
+        }
+        const options = isExport
+            ? { responseType: 'arraybuffer' }
+            : {};
+        return this.http.get(url, options);
+    }
+    getTicketsApi(store, fromDate, toDate, revopsType, status, action, offset, limit) {
+        let params = new HttpParams()
+            .set("storeId", store)
+            .set("fromDate", fromDate)
+            .set("toDate", toDate)
+            .set("offset", offset)
+            .set("limit", limit);
+        if (revopsType) {
+            params = params.set("revopsType", revopsType);
+        }
+        if (status) {
+            params = params.set("status", status);
+        }
+        if (action) {
+            params = params.set("action", action);
+        }
+        return this.http.get(`${this.footfallDirapiUrl}/get-tickets`, { params });
+    }
+    getTicketsNewApi(ticketId) {
+        let params = new HttpParams().set("ticketId", ticketId);
+        return this.http.get(`${this.footfallDirapiUrl}/get-tickets`, { params });
+    }
+    getTaggedStoresApi(client, fromDate, toDate, searchValue, clusters, sortOrder) {
+        let params = new HttpParams()
+            .set("clientId", client)
+            .set("fromDate", fromDate)
+            .set("toDate", toDate); // Add searchValue as an empty string if not provided
+        // Only add 'clusters' if it's not null, undefined, or an empty array/string
+        if (searchValue) {
+            params = params.set("searchValue", searchValue);
+        }
+        if (clusters && clusters.length > 0) {
+            params = params.set("clusters", clusters);
+        }
+        if (sortOrder) {
+            params = params.set("sortOrder", sortOrder);
+        }
+        return this.http.get(`${this.footfallDirapiUrl}/get-tagged-stores`, {
+            params,
+        });
+    }
+    getUpdateStatusApi(data) {
+        const url = `${this.footfallDirapiUrl}/update-status`;
+        return this.http.put(url, data);
+    }
+    getUpdateTempStatusApi(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/update-temp-status`, data);
+    }
+    getOpenTicketListApi(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/open-ticket-list`, data);
+    }
+    getUpdateTicketStatusApi(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/update-ticket-status`, data);
+    }
+    getCreateTicketListApi(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/create-ticket`, data);
+    }
+    CreateinternalTicketApi(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/create-internalticket`, data);
+    }
+    getclusters(data) {
+        return this.http.post(`${this.trafficApiUrl}/headercluster_v2`, data);
+    }
+    getReviewerApi(clientId, type, tangotype) {
+        let params = new HttpParams().set("clientId", clientId)
+            .set("type", type).set("tangotype", tangotype);
+        return this.http.get(`${this.footfallDirapiUrl}/reviewer-list`, { params });
+    }
+    getTicketAssignApi(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/assign-ticket`, data);
+    }
+    reAssignAudit(data) {
+        return this.http.post(`${this.vmsAuditUrl}/reAssign-audit`, data);
+    }
+    getMultiCloseTicketApi(data) {
+        return this.http.post(`${this.footfallDirapiUrl}/multi-close-tickets`, data);
+    }
+    getTypeFunction(clientId) {
+        let params = new HttpParams().set("clientId", clientId);
+        return this.http.get(`${this.clientApiUrl}/get-footfall-directory-config`, { params });
+    }
+    footfallData;
+    setFootfallData(data) {
+        this.footfallData = data;
+    }
+    getFootfallData() {
+        return this.footfallData;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TicketService, deps: [{ token: i1.HttpClient }, { token: i2.GlobalStateService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TicketService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TicketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.GlobalStateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ticket.service.js","sourceRoot":"","sources":["../../../../../projects/tango-manage-tickets/src/lib/services/ticket.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\r\nimport { Injectable, Optional } from \"@angular/core\";\r\nimport { GlobalStateService } from \"tango-app-ui-global\";\r\nimport {\r\n  BehaviorSubject,\r\n  Observable,\r\n  catchError,\r\n  map,\r\n  of,\r\n  throwError,\r\n} from \"rxjs\";\r\nimport { HttpParams } from \"@angular/common/http\";\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class TicketService {\r\n  userApiUrl: any;\r\n  ticketsApiUrl: any;\r\n  auditApiUrl: any;\r\n  auditmetricApiUrl: any;\r\n  zoneauditApiUrl: any;\r\n  footfallDirapiUrl: any;\r\n  footfallCDN: any;\r\n  trafficApiUrl: any;\r\n  revopApiUrl: any;\r\n  clientApiUrl:any;\r\n  vmsAuditUrl:any;\r\n  dropDownTrigger = new BehaviorSubject<any>(null);\r\n  constructor(private http: HttpClient, private gs: GlobalStateService) {\r\n    this.gs.environment.subscribe((env) => {\r\n      if (env) {\r\n        this.userApiUrl = env.userApiUrl;\r\n        this.ticketsApiUrl = env.ticketsApiUrl;\r\n        this.auditmetricApiUrl = env.auditmetricApiUrl;\r\n        this.auditApiUrl = env.auditApiUrl;\r\n        this.zoneauditApiUrl = env.zoneauditApiUrl;\r\n        this.clientApiUrl = env.clientApiUrl;\r\n        this.footfallDirapiUrl = env.footfallDirapiUrl;\r\n        this.footfallCDN = env.footfallCDN;\r\n        this.trafficApiUrl = env.trafficApiUrl;\r\n        this.revopApiUrl = env.revopApiUrl;\r\n        this.vmsAuditUrl = env.vmsAuditUrl;\r\n      }\r\n    });\r\n  }\r\n\r\n  getUserList(params: any): Observable<any> {\r\n    return this.http.post<any>(`${this.userApiUrl}/get-list`, params);\r\n  }\r\n\r\n  exportInstallationList(data: any) {\r\n    return this.http.post(\r\n      `${this.ticketsApiUrl}/infra/installationTable`,\r\n      data,\r\n      { responseType: \"arraybuffer\" }\r\n    );\r\n  }\r\n\r\n  exportInfraList(data: any) {\r\n    return this.http.post(`${this.ticketsApiUrl}/infra/infraTable`, data, {\r\n      responseType: \"arraybuffer\",\r\n    });\r\n  }\r\n\r\n  exportMatList(data: any) {\r\n    return this.http.post(`${this.ticketsApiUrl}/infra/matTable`, data, {\r\n      responseType: \"arraybuffer\",\r\n    });\r\n  }\r\n\r\n  getSotresList(data: any) {\r\n    return this.http.post<any>(`${this.ticketsApiUrl}/infra/storeFilter`, data);\r\n  }\r\n\r\n  getInstallationList(data: any) {\r\n    return this.http.post<any>(\r\n      `${this.ticketsApiUrl}/infra/installationTable`,\r\n      data\r\n    );\r\n  }\r\n\r\n  getInfraList(data: any) {\r\n    return this.http.post<any>(`${this.ticketsApiUrl}/infra/infraTable`, data);\r\n  }\r\n\r\n  getAssignTicket(data: any) {\r\n    return this.http.post<any>(\r\n      `${this.ticketsApiUrl}/infra/assignTicket`,\r\n      data\r\n    );\r\n  }\r\n\r\n  getMatList(data: any) {\r\n    return this.http.post<any>(`${this.ticketsApiUrl}/infra/matTable`, data);\r\n  }\r\n\r\n  updateTicketIssue(data: any) {\r\n    return this.http.post<any>(\r\n      `${this.ticketsApiUrl}/employeeTraning/updatecomment`,\r\n      data\r\n    );\r\n  }\r\n\r\n  getUserActiveList(params: any): Observable<any> {\r\n    return this.http.post<any>(`${this.userApiUrl}/list`, params);\r\n  }\r\n\r\n  getAllCounts(data:any){\r\n    return this.http.post<any>(`${this.ticketsApiUrl}/infra/allCounts`, data)\r\n  }\r\n  getstoreMetrics(data:any){\r\n    return this.http.post(`${this.auditApiUrl}/metrics/store-metrics`,data)\r\n  }\r\n  getstoreMetricsExport(data:any){\r\n    return this.http.post(`${this.auditApiUrl}/metrics/store-metrics`,data,{responseType: 'arraybuffer'})\r\n  }\r\n  getclientList(){\r\n    return this.http.get(`${this.auditApiUrl}/clients`)\r\n  }\r\n  getuserList(){\r\n    return this.http.get(`${this.auditApiUrl}/tango-users`)\r\n  }\r\n  auditretrigger(data:any){\r\n    return this.http.post(`${this.auditApiUrl}/metrics/re-trigger`,data)\r\n }\r\n getfootfallcount(data:any){\r\n     return this.http.get(`${this.revopApiUrl}/store-processed-data?storeId=${data.storeId}&fromDate=${data.Date}&toDate=${data.Date}`)\r\n  \r\n }\r\n getstoreList(data:any){\r\n  return this.http.post(`${this.auditApiUrl}/audit-stores`,data)\r\n }\r\n checkTicketExists(data:any){\r\n  return this.http.post(`${this.footfallDirapiUrl}/checkTicketExists`,data)\r\n }\r\n mergeticket(data:any){\r\n  return this.http.post(`${this.footfallDirapiUrl}/mergeticket`,data)\r\n }\r\n  getDataMismathList(data: any) {\r\n    return this.http.post<any>(\r\n      `${this.ticketsApiUrl}/infra/dataMismatchTable`,\r\n      data\r\n    );\r\n  }\r\n  accuracyReasonsupdate(data: any) {\r\n    return this.http.post<any>(\r\n      `${this.footfallDirapiUrl}/tango-review-accuracy-ticket`,\r\n      data\r\n    );\r\n  }\r\n\r\n  exportDataMismatchList(data: any) {\r\n    return this.http.post(\r\n      `${this.ticketsApiUrl}/infra/dataMismatchTable`,\r\n      data,\r\n      { responseType: \"arraybuffer\" }\r\n    );\r\n  }\r\n\r\n\r\n  getAuditImages(data: any) {\r\n    return this.http.get(\r\n      `${this.auditApiUrl}/audit-images?fileDate=${data?.fileDate}&storeId=${data?.storeId}&imageType=${data?.imageType}&export=${data?.export}&zoneName=${data?.zoneName}&moduleType=${data?.moduleType}`\r\n    );\r\n  }\r\n  ExportAuditImagesasxlsx(data: any) {\r\n    return this.http.get(\r\n      `${this.auditApiUrl}/audit-images?fileDate=${data?.fileDate}&storeId=${data?.storeId}&imageType=${data?.imageType}&export=${data?.export}&zoneName=${data?.zoneName}&moduleType=${data?.moduleType}`,\r\n      { responseType: \"arraybuffer\" }\r\n    );\r\n  }\r\n\r\n  getTicketSummaryApi(\r\n    client: any,\r\n    fromDate: any,\r\n    toDate: any,\r\n    tangoType:any,\r\n     permissionType?: string | null,\r\n  ): Observable<any> {\r\n     let url =\r\n    `${this.footfallDirapiUrl}/ticket-summary?` +\r\n    `clientId=${client}` +\r\n    `&fromDate=${fromDate}` +\r\n    `&toDate=${toDate}` +\r\n    `&tangoType=${tangoType}`;\r\n    if (permissionType) {\r\n    url += `&permissionType=${permissionType}`;\r\n  }\r\n\r\n  return this.http.get(url);\r\n  }\r\n  accuracyReasons(\r\n    client: any,\r\n  ): Observable<any> {\r\n    return this.http.get(\r\n      `${this.footfallDirapiUrl}/get-accuarcy-issues?clientId=${client}`\r\n    );\r\n  }\r\n\r\n  getTicketListOldApi(\r\n    client: any,\r\n    fromDate: any,\r\n    toDate: any,\r\n    searchvalue: any,\r\n    limit: any,\r\n    offset: any,\r\n    isExport: any,\r\n    sortBy: any,\r\n    sortOrder: any\r\n  ): Observable<any> {\r\n    return this.http.get(\r\n      `${this.footfallDirapiUrl}/ticket-list?clientId=${client}&fromDate=${fromDate}&toDate=${toDate}&searchValue=${searchvalue}&limit=${limit}&offset=${offset}&isExport=${isExport}&sortBy=${sortBy}&sortOrder=${sortOrder}`\r\n    );\r\n  }\r\n\r\ngetTicketListApi(\r\n  client: any,\r\n  fromDate: any,\r\n  toDate: any,\r\n  searchvalue: any,\r\n  limit: any,\r\n  offset: any,\r\n  isExport: any,\r\n  sortBy: any,\r\n  sortOrder: any,\r\n  tangoType: any,\r\n  permissionType?: string | null,\r\n  filters?: {\r\n    filterByStatus: any[];\r\n    filterByReviewer: any | null;\r\n    filterByApprover: any | null;\r\n    filterByTango: any | null;\r\n    filterByReviewedBy: any[];\r\n    fileterByApprovedBy: any[];\r\n  }\r\n): Observable<any> {\r\n  let url =\r\n    `${this.footfallDirapiUrl}/ticket-list?` +\r\n    `clientId=${client}` +\r\n    `&fromDate=${fromDate}` +\r\n    `&toDate=${toDate}` +\r\n    `&searchValue=${searchvalue}` +\r\n    `&limit=${limit}` +\r\n    `&offset=${offset}` +\r\n    `&isExport=${isExport}` +\r\n    `&sortBy=${sortBy}` +\r\n    `&sortOrder=${sortOrder}` +\r\n    `&tangoType=${tangoType}`;\r\n\r\n  if (permissionType) {\r\n    url += `&permissionType=${permissionType}`;\r\n  }\r\n\r\n  if (filters) {\r\n    // array params – send as comma-separated\r\n    if (filters.filterByStatus?.length) {\r\n      url += `&filterByStatus=${encodeURIComponent(filters.filterByStatus.join(','))}`;\r\n    }\r\n\r\n    if (filters.filterByReviewedBy?.length) {\r\n      url += `&filterByReviewedBy=${encodeURIComponent(filters.filterByReviewedBy.join(','))}`;\r\n    }\r\n\r\n    if (filters.fileterByApprovedBy?.length) {\r\n      url += `&fileterByApprovedBy=${encodeURIComponent(filters.fileterByApprovedBy.join(','))}`;\r\n    }\r\n\r\n    // string params – JSON stringified accuracy\r\n    if (filters.filterByReviewer) {\r\n      url += `&filterByReviewer=${encodeURIComponent(filters.filterByReviewer)}`;\r\n    }\r\n\r\n    if (filters.filterByApprover) {\r\n      url += `&filterByApprover=${encodeURIComponent(filters.filterByApprover)}`;\r\n    }\r\n\r\n    if (filters.filterByTango) {\r\n      url += `&filterByTango=${encodeURIComponent(filters.filterByTango)}`;\r\n    }\r\n  }\r\n\r\n  return this.http.get(url);\r\n}\r\n\r\n\r\n  getTicketListExportOldApi(\r\n    client: any,\r\n    fromDate: any,\r\n    toDate: any,\r\n    searchvalue: any,\r\n    limit: any,\r\n    offset: any,\r\n    isExport: any,\r\n    sortBy: any,\r\n    sortOrder: any\r\n  ): Observable<any> {\r\n    return this.http.get(\r\n      `${this.footfallDirapiUrl}/ticket-list?clientId=${client}&fromDate=${fromDate}&toDate=${toDate}&searchValue=${searchvalue}&limit=${limit}&offset=${offset}&isExport=${isExport}&sortBy=${sortBy}&sortOrder=${sortOrder}`,\r\n      { responseType: \"arraybuffer\" }\r\n    );\r\n  }\r\n\r\ngetTicketListExportApi(\r\n  client: any,\r\n  fromDate: any,\r\n  toDate: any,\r\n  searchvalue: any,\r\n  limit: any,\r\n  offset: any,\r\n  isExport: any,\r\n  sortBy: any,\r\n  sortOrder: any,\r\n  tangoType: any,\r\n  permissionType?: string | null,\r\n  filters?: {\r\n    filterByStatus?: string[];\r\n    filterByReviewer?: string | null;\r\n    filterByApprover?: string | null;\r\n    filterByTango?: string | null;\r\n    filterByReviewedBy?: string[];\r\n    fileterByApprovedBy?: string[];\r\n  }\r\n): Observable<any> {\r\n  let url =\r\n    `${this.footfallDirapiUrl}/ticket-list?` +\r\n    `clientId=${client}` +\r\n    `&fromDate=${fromDate}` +\r\n    `&toDate=${toDate}` +\r\n    `&searchValue=${searchvalue}` +\r\n    `&limit=${limit}` +\r\n    `&offset=${offset}` +\r\n    `&isExport=${isExport}` +\r\n    `&sortBy=${sortBy}` +\r\n    `&sortOrder=${sortOrder}` +\r\n    `&tangoType=${tangoType}`;\r\n\r\n  if (permissionType) {\r\n    url += `&permissionType=${permissionType}`;\r\n  }\r\n\r\n  if (filters) {\r\n    if (filters.filterByStatus?.length) {\r\n      url += `&filterByStatus=${encodeURIComponent(filters.filterByStatus.join(','))}`;\r\n    }\r\n\r\n    if (filters.filterByReviewedBy?.length) {\r\n      url += `&filterByReviewedBy=${encodeURIComponent(filters.filterByReviewedBy.join(','))}`;\r\n    }\r\n\r\n    if (filters.fileterByApprovedBy?.length) {\r\n      url += `&fileterByApprovedBy=${encodeURIComponent(filters.fileterByApprovedBy.join(','))}`;\r\n    }\r\n\r\n    if (filters.filterByReviewer) {\r\n      url += `&filterByReviewer=${encodeURIComponent(filters.filterByReviewer)}`;\r\n    }\r\n\r\n    if (filters.filterByApprover) {\r\n      url += `&filterByApprover=${encodeURIComponent(filters.filterByApprover)}`;\r\n    }\r\n\r\n    if (filters.filterByTango) {\r\n      url += `&filterByTango=${encodeURIComponent(filters.filterByTango)}`;\r\n    }\r\n  }\r\n\r\n  const options = isExport\r\n    ? { responseType: 'arraybuffer' as 'json' }\r\n    : {};\r\n\r\n  return this.http.get(url, options);\r\n}\r\n\r\n\r\n  getTicketsApi(\r\n    store: any,\r\n    fromDate: any,\r\n    toDate: any,\r\n    revopsType: any,\r\n    status: any,\r\n    action: any,\r\n    offset: any,\r\n    limit: any\r\n  ): Observable<any> {\r\n    let params = new HttpParams()\r\n      .set(\"storeId\", store)\r\n      .set(\"fromDate\", fromDate)\r\n      .set(\"toDate\", toDate)\r\n      .set(\"offset\", offset)\r\n      .set(\"limit\", limit);\r\n    if (revopsType) {\r\n      params = params.set(\"revopsType\", revopsType);\r\n    }\r\n    if (status) {\r\n      params = params.set(\"status\", status);\r\n    }\r\n    if (action) {\r\n      params = params.set(\"action\", action);\r\n    }\r\n    return this.http.get(`${this.footfallDirapiUrl}/get-tickets`, { params });\r\n  }\r\n\r\n  getTicketsNewApi(ticketId: any): Observable<any> {\r\n    let params = new HttpParams().set(\"ticketId\", ticketId);\r\n    return this.http.get(`${this.footfallDirapiUrl}/get-tickets`, { params });\r\n  }\r\n\r\n  getTaggedStoresApi(\r\n    client: any,\r\n    fromDate: any,\r\n    toDate: any,\r\n    searchValue: any,\r\n    clusters: any,\r\n    sortOrder: any\r\n  ): Observable<any> {\r\n    let params = new HttpParams()\r\n      .set(\"clientId\", client)\r\n      .set(\"fromDate\", fromDate)\r\n      .set(\"toDate\", toDate); // Add searchValue as an empty string if not provided\r\n    // Only add 'clusters' if it's not null, undefined, or an empty array/string\r\n    if (searchValue) {\r\n      params = params.set(\"searchValue\", searchValue);\r\n    }\r\n\r\n    if (clusters && clusters.length > 0) {\r\n      params = params.set(\"clusters\", clusters);\r\n    }\r\n    if (sortOrder) {\r\n      params = params.set(\"sortOrder\", sortOrder);\r\n    }\r\n    return this.http.get(`${this.footfallDirapiUrl}/get-tagged-stores`, {\r\n      params,\r\n    });\r\n  }\r\n\r\n  getUpdateStatusApi(data: any): Observable<any> {\r\n    const url = `${this.footfallDirapiUrl}/update-status`;\r\n    return this.http.put(url, data);\r\n  }\r\n\r\n  getUpdateTempStatusApi(data: any): Observable<any> {\r\n    return this.http.post(`${this.footfallDirapiUrl}/update-temp-status`, data);\r\n  }\r\n\r\n  getOpenTicketListApi(data: any): Observable<any> {\r\n    return this.http.post(`${this.footfallDirapiUrl}/open-ticket-list`, data);\r\n  }\r\n\r\n  getUpdateTicketStatusApi(data: any): Observable<any> {\r\n    return this.http.post(\r\n      `${this.footfallDirapiUrl}/update-ticket-status`,\r\n      data\r\n    );\r\n  }\r\n\r\ngetCreateTicketListApi(data:any): Observable<any> {\r\n  return this.http.post(`${this.footfallDirapiUrl}/create-ticket`, data);\r\n}\r\nCreateinternalTicketApi(data:any): Observable<any> {\r\n  return this.http.post(`${this.footfallDirapiUrl}/create-internalticket`, data);\r\n}\r\n  getclusters(data: any) {\r\n    return this.http.post(`${this.trafficApiUrl}/headercluster_v2`, data);\r\n  }\r\n\r\n  getReviewerApi(clientId: any,type:any,tangotype:any): Observable<any> {\r\n    let params = new HttpParams().set(\"clientId\", clientId)\r\n      .set(\"type\",type).set(\"tangotype\",tangotype);\r\n    return this.http.get(`${this.footfallDirapiUrl}/reviewer-list`, { params });\r\n  }\r\n\r\n  getTicketAssignApi(data: any): Observable<any> {\r\n    return this.http.post(`${this.footfallDirapiUrl}/assign-ticket`, data);\r\n  }\r\n  reAssignAudit(data: any): Observable<any> {\r\n    return this.http.post(`${this.vmsAuditUrl}/reAssign-audit`, data);\r\n  }\r\n\r\n  getMultiCloseTicketApi(data: any): Observable<any> {\r\n    return this.http.post(\r\n      `${this.footfallDirapiUrl}/multi-close-tickets`,\r\n      data\r\n    );\r\n  }\r\n\r\n  getTypeFunction(clientId: any): Observable<any> {\r\n    let params = new HttpParams().set(\"clientId\", clientId);\r\n    return this.http.get(`${this.clientApiUrl}/get-footfall-directory-config`, { params });\r\n\r\n    \r\n  }\r\n  private footfallData: any;\r\n\r\n  setFootfallData(data: any) {\r\n    this.footfallData = data;\r\n  }\r\n\r\n  getFootfallData() {\r\n    return this.footfallData;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/services/timer.service.mjs

@@ -0,0 +1,84 @@
+import { Injectable } from '@angular/core';
+import { interval, BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class TimerService {
+    route;
+    timePassed = new BehaviorSubject(0); // Timer count
+    subscription = null; // Timer subscription
+    inactivityTimeout = null; // Timeout for inactivity
+    INACTIVITY_LIMIT = 5000;
+    constructor(route) {
+        this.route = route;
+    }
+    startTimer() {
+        if (!this.subscription) {
+            let currentTime = 0;
+            let timeSpent;
+            if ('timeSpent' in sessionStorage) {
+                timeSpent = JSON.parse(sessionStorage.getItem('timeSpent') || '{}');
+                currentTime = timeSpent || 0; // Retrieve the existing timer value
+            }
+            const timer$ = interval(1000); // Emits every 1 second
+            this.subscription = timer$.subscribe(() => {
+                currentTime += 1;
+                this.timePassed.next(currentTime);
+                timeSpent = currentTime;
+                sessionStorage.setItem('timeSpent', JSON.stringify(timeSpent)); // Store the updated object
+            });
+        }
+        this.resetInactivityTimeout();
+    }
+    stopTimer() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = null;
+        }
+    }
+    stopTimerAfterInactivity() {
+        this.inactivityTimeout = setTimeout(() => {
+            this.stopTimer(); // Stop the timer after inactivity
+        }, this.INACTIVITY_LIMIT);
+    }
+    resetInactivityTimeout() {
+        if (this.inactivityTimeout) {
+            clearTimeout(this.inactivityTimeout); // Clear the previous inactivity timeout
+        }
+        this.stopTimerAfterInactivity(); // Set a new inactivity timeout
+    }
+    getTimePassed() {
+        return this.timePassed;
+    }
+    clearTimer() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = null;
+        }
+        // this.timePassed.next(0);  // Optionally reset the timePassed
+        // sessionStorage.removeItem('totalfiles');  // Optionally clear session storage
+        // sessionStorage.removeItem('timeSpent')
+    }
+    resetTimer() {
+        this.timePassed.next(0); // Reset to 0
+        // this.resetInactivityTimeout();  // Reset inactivity timeout
+    }
+    formatTime(seconds) {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secs = seconds % 60;
+        return `${this.padZero(hours)}:${this.padZero(minutes)}:${this.padZero(secs)}`;
+    }
+    // Helper method to pad single digit numbers with a leading zero
+    padZero(num) {
+        return num < 10 ? '0' + num : '' + num;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TimerService, deps: [{ token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TimerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TimerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tango-manage-tickets-routing.module.mjs

@@ -0,0 +1,44 @@
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { TangoManageTicketsComponent } from './components/tango-manage-tickets/tango-manage-tickets.component';
+import { FootfallDicviewComponent } from './components/footfall-dicview/footfall-dicview.component';
+import { StartAuditComponent } from './components/start-audit/start-audit.component';
+import { AuditMappingListComponent } from './components/audit-mapping-list/audit-mapping-list.component';
+import { AuditRetagComponent } from './components/audit-retag/audit-retag.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+const routes = [
+    {
+        path: '',
+        component: TangoManageTicketsComponent
+    },
+    {
+        path: 'list',
+        component: FootfallDicviewComponent
+    },
+    {
+        path: "audit",
+        component: StartAuditComponent
+    },
+    {
+        path: "mapping-list",
+        component: AuditMappingListComponent
+    },
+    {
+        path: 'retag-mapping',
+        component: AuditRetagComponent
+    },
+];
+export class TangoManageTicketsRoutingModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TangoManageTicketsRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: TangoManageTicketsRoutingModule, imports: [i1.RouterModule], exports: [RouterModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TangoManageTicketsRoutingModule, imports: [RouterModule.forChild(routes), RouterModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TangoManageTicketsRoutingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [RouterModule.forChild(routes)],
+                    exports: [RouterModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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