kwikid-agent-dashboard 0.0.37 → 0.0.39

package/esm2015/lib/v1/kwikid-agent-dashboard.module.js

@@ -0,0 +1,120 @@
+import { CommonModule } from "@angular/common";
+import { HttpClientJsonpModule, HttpClientModule } from "@angular/common/http";
+import { NgModule } from "@angular/core";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { GoogleMapsModule } from "@angular/google-maps";
+import { ScrollingModule } from "@angular/cdk/scrolling";
+import { KwikUIButtonModule, KwikUIInputDateModule, KwikUIInputModule, KwikUIInputDateRangeModule, KwikUIInputSelectModule, KwikUITableModule, KwikUITablePaginationModule, KwikUILabelValuePairModule } from "kwikui";
+import { TuiSidebarModule } from "@taiga-ui/addon-mobile";
+import { TuiActiveZoneModule } from "@taiga-ui/cdk";
+import { TuiDialogModule, TuiDropdownModule, TuiGroupModule, TuiRootModule, TuiSvgModule } from "@taiga-ui/core";
+import { KwikIDFormViewModule } from "kwikid-forms";
+import { CustomerTileComponent } from "./components/customer-tile/customer-tile.component";
+import { CustomerListComponent } from "./components/customer-list/customer-list.component";
+import { Ng2SearchPipe } from "./pipes/search-filter.pipe";
+import { StatusPillComponent } from "./components/customer-tile/status-pill/status-pill.component";
+import { CustomerDetailsComponent } from "./components/customer-details/customer-details.component";
+import { KwikIDAgentDashboardComponentV1 } from "./kwikid-agent-dashboard.component";
+import { ActionButtonComponent } from "./components/action-button/action-button.component";
+import * as i0 from "@angular/core";
+export class KwikIDAgentDashboardModuleV1 {
+}
+/** @nocollapse */ KwikIDAgentDashboardModuleV1.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: KwikIDAgentDashboardModuleV1, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ KwikIDAgentDashboardModuleV1.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: KwikIDAgentDashboardModuleV1, declarations: [KwikIDAgentDashboardComponentV1,
+        CustomerListComponent,
+        CustomerTileComponent,
+        Ng2SearchPipe,
+        StatusPillComponent,
+        CustomerDetailsComponent,
+        ActionButtonComponent], imports: [CommonModule,
+        HttpClientModule,
+        FormsModule,
+        ReactiveFormsModule,
+        KwikUIButtonModule,
+        KwikUIInputModule,
+        KwikUIInputDateModule,
+        KwikUIInputDateRangeModule,
+        KwikUIInputSelectModule,
+        KwikUILabelValuePairModule,
+        KwikUITableModule,
+        KwikUITablePaginationModule,
+        KwikIDFormViewModule,
+        TuiRootModule,
+        TuiDialogModule,
+        TuiDropdownModule,
+        TuiSidebarModule,
+        TuiActiveZoneModule,
+        TuiGroupModule,
+        TuiSvgModule,
+        ScrollingModule,
+        GoogleMapsModule,
+        HttpClientModule,
+        HttpClientJsonpModule], exports: [KwikIDAgentDashboardComponentV1] });
+/** @nocollapse */ KwikIDAgentDashboardModuleV1.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: KwikIDAgentDashboardModuleV1, imports: [[
+            CommonModule,
+            HttpClientModule,
+            FormsModule,
+            ReactiveFormsModule,
+            KwikUIButtonModule,
+            KwikUIInputModule,
+            KwikUIInputDateModule,
+            KwikUIInputDateRangeModule,
+            KwikUIInputSelectModule,
+            KwikUILabelValuePairModule,
+            KwikUITableModule,
+            KwikUITablePaginationModule,
+            KwikIDFormViewModule,
+            TuiRootModule,
+            TuiDialogModule,
+            TuiDropdownModule,
+            TuiSidebarModule,
+            TuiActiveZoneModule,
+            TuiGroupModule,
+            TuiSvgModule,
+            ScrollingModule,
+            GoogleMapsModule,
+            HttpClientModule,
+            HttpClientJsonpModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: KwikIDAgentDashboardModuleV1, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        KwikIDAgentDashboardComponentV1,
+                        CustomerListComponent,
+                        CustomerTileComponent,
+                        Ng2SearchPipe,
+                        StatusPillComponent,
+                        CustomerDetailsComponent,
+                        ActionButtonComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        KwikUIButtonModule,
+                        KwikUIInputModule,
+                        KwikUIInputDateModule,
+                        KwikUIInputDateRangeModule,
+                        KwikUIInputSelectModule,
+                        KwikUILabelValuePairModule,
+                        KwikUITableModule,
+                        KwikUITablePaginationModule,
+                        KwikIDFormViewModule,
+                        TuiRootModule,
+                        TuiDialogModule,
+                        TuiDropdownModule,
+                        TuiSidebarModule,
+                        TuiActiveZoneModule,
+                        TuiGroupModule,
+                        TuiSvgModule,
+                        ScrollingModule,
+                        GoogleMapsModule,
+                        HttpClientModule,
+                        HttpClientJsonpModule
+                    ],
+                    exports: [KwikIDAgentDashboardComponentV1]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/v1/pipes/search-filter.pipe.js

@@ -0,0 +1,62 @@
+import { Pipe, Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class Ng2SearchPipe {
+    /**
+     * @param items object from array
+     * @param term term's search
+     * @param excludes array of strings which will ignored during search
+     */
+    transform(items, term, excludes = []) {
+        if (!term || !items)
+            return items;
+        return Ng2SearchPipe.filter(items, term, excludes);
+    }
+    /**
+     *
+     * @param items List of items to filter
+     * @param term  a string term to compare with every property of the list
+     * @param excludes List of keys which will be ignored during search
+     *
+     */
+    static filter(items, term, excludes) {
+        const toCompare = term.toLowerCase();
+        function checkInside(item, term) {
+            if (typeof item === "string" &&
+                item.toString().toLowerCase().includes(toCompare)) {
+                return true;
+            }
+            for (const property in item) {
+                if (item[property] === null ||
+                    item[property] == undefined ||
+                    excludes.includes(property)) {
+                    continue;
+                }
+                if (typeof item[property] === "object") {
+                    if (checkInside(item[property], term)) {
+                        return true;
+                    }
+                }
+                else if (item[property].toString().toLowerCase().includes(toCompare)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return items.filter((item) => {
+            return checkInside(item, term);
+        });
+    }
+}
+/** @nocollapse */ Ng2SearchPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Ng2SearchPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+/** @nocollapse */ Ng2SearchPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Ng2SearchPipe, name: "filter", pure: false });
+/** @nocollapse */ Ng2SearchPipe.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Ng2SearchPipe });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Ng2SearchPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "filter",
+                    pure: false
+                }]
+        }, {
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/v1/services/agent.service.js

@@ -0,0 +1,149 @@
+import { Injectable } from "@angular/core";
+import { EStatus } from "../components/customer-tile/status-pill/status-pill.definitions";
+import * as i0 from "@angular/core";
+export class AgentService {
+    constructor() {
+        this.isListOpen = true;
+        this.showMapview = false;
+        this.addTaskForm = {
+            key: "ADD_TASK",
+            title: "Add Task",
+            fields: [
+                {
+                    key: "name",
+                    label: "Customer Name",
+                    validators: {
+                        required: true
+                    },
+                    properties: {
+                        placeholder: "Please enter the Customer Name",
+                        readOnly: false,
+                        case: "default"
+                    },
+                    type: "text"
+                },
+                {
+                    key: "phone",
+                    label: "Phone Number",
+                    validators: {
+                        required: true
+                    },
+                    properties: {
+                        countryCode: "+91",
+                        removeCountryCodeFromValue: true,
+                        phoneMaskAfterCountryCode: "##########",
+                        placeholder: "Please enter your Mobile Number",
+                        readOnly: false
+                    },
+                    type: "phone"
+                },
+                {
+                    key: "address",
+                    label: "Address",
+                    validators: {
+                        required: true
+                    },
+                    properties: {
+                        placeholder: "Please enter the Address",
+                        readOnly: false,
+                        case: "default"
+                    },
+                    type: "text"
+                },
+                {
+                    key: "city",
+                    label: "City",
+                    validators: {
+                        required: true
+                    },
+                    properties: {
+                        placeholder: "Please enter the City",
+                        readOnly: false,
+                        case: "default"
+                    },
+                    type: "text"
+                },
+                {
+                    key: "location",
+                    label: "Location URL",
+                    validators: {
+                        required: true
+                    },
+                    properties: {
+                        placeholder: "Please enter the Location URL",
+                        readOnly: false,
+                        case: "default"
+                    },
+                    type: "text"
+                }
+            ],
+            properties: {
+                header: {
+                    title: {
+                        hidden: true,
+                        label: "Add Task"
+                    },
+                    steps: {
+                        hidden: true
+                    },
+                    logo: {
+                        hidden: true
+                    }
+                },
+                footer: {
+                    viewFormsButton: {
+                        hidden: true,
+                        label: "View Forms"
+                    },
+                    saveButton: {
+                        hidden: false,
+                        label: "Submit"
+                    }
+                }
+            }
+        };
+        this.notRequiredStatus = [
+            EStatus.REJECTED,
+            EStatus.AFTER_AUDIT,
+            EStatus.COMPLETE,
+            EStatus.SESSION_EXPIRED,
+            EStatus.KYC_REJECTED,
+            EStatus.KYC_RESULT_APPROVED,
+            EStatus.KYC_RESULT_REJECTED,
+            EStatus.KYC_RESULT_UNDER_REVIEW,
+            EStatus.KYC_REQUEST_REJECTED
+        ];
+    }
+    ngOnInit() { }
+    setAgentConfig(config) {
+        this.config = config;
+    }
+    toggleMapview() {
+        this.showMapview = !this.showMapview;
+    }
+    canStartJourney(status) {
+        var _a, _b;
+        const noneEditableStatus = (_b = (_a = this.config.dashboard) === null || _a === void 0 ? void 0 : _a.cannotStartJourney) !== null && _b !== void 0 ? _b : this.notRequiredStatus;
+        if (noneEditableStatus.includes(status)) {
+            return false;
+        }
+        return true;
+    }
+    canPlotMarkers(status) {
+        var _a, _b;
+        const nonePlottingSessions = (_b = (_a = this.config.dashboard) === null || _a === void 0 ? void 0 : _a.dontPlotMarkers) !== null && _b !== void 0 ? _b : [];
+        if (nonePlottingSessions.includes(status)) {
+            return false;
+        }
+        return true;
+    }
+}
+/** @nocollapse */ AgentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AgentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ AgentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AgentService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AgentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent.service.js","sourceRoot":"","sources":["../../../../../../projects/kwikid-agent-dashboard/src/lib/v1/services/agent.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\nimport { EStatus } from \"../components/customer-tile/status-pill/status-pill.definitions\";\n\n@Injectable({\n  providedIn: \"root\"\n})\nexport class AgentService {\n  config;\n\n  isListOpen = true;\n\n  isMobileView;\n\n  showMapview = false;\n\n  currentTaskDetails;\n\n  addTaskForm = {\n    key: \"ADD_TASK\",\n    title: \"Add Task\",\n    fields: [\n      {\n        key: \"name\",\n        label: \"Customer Name\",\n        validators: {\n          required: true\n        },\n        properties: {\n          placeholder: \"Please enter the Customer Name\",\n          readOnly: false,\n          case: \"default\"\n        },\n        type: \"text\"\n      },\n      {\n        key: \"phone\",\n        label: \"Phone Number\",\n        validators: {\n          required: true\n        },\n        properties: {\n          countryCode: \"+91\",\n          removeCountryCodeFromValue: true,\n          phoneMaskAfterCountryCode: \"##########\",\n          placeholder: \"Please enter your Mobile Number\",\n          readOnly: false\n        },\n        type: \"phone\"\n      },\n      {\n        key: \"address\",\n        label: \"Address\",\n        validators: {\n          required: true\n        },\n        properties: {\n          placeholder: \"Please enter the Address\",\n          readOnly: false,\n          case: \"default\"\n        },\n        type: \"text\"\n      },\n      {\n        key: \"city\",\n        label: \"City\",\n        validators: {\n          required: true\n        },\n        properties: {\n          placeholder: \"Please enter the City\",\n          readOnly: false,\n          case: \"default\"\n        },\n        type: \"text\"\n      },\n      {\n        key: \"location\",\n        label: \"Location URL\",\n        validators: {\n          required: true\n        },\n        properties: {\n          placeholder: \"Please enter the Location URL\",\n          readOnly: false,\n          case: \"default\"\n        },\n        type: \"text\"\n      }\n    ],\n    properties: {\n      header: {\n        title: {\n          hidden: true,\n          label: \"Add Task\"\n        },\n        steps: {\n          hidden: true\n        },\n        logo: {\n          hidden: true\n        }\n      },\n      footer: {\n        viewFormsButton: {\n          hidden: true,\n          label: \"View Forms\"\n        },\n        saveButton: {\n          hidden: false,\n          label: \"Submit\"\n        }\n      }\n    }\n  };\n\n  notRequiredStatus = [\n    EStatus.REJECTED,\n    EStatus.AFTER_AUDIT,\n    EStatus.COMPLETE,\n    EStatus.SESSION_EXPIRED,\n    EStatus.KYC_REJECTED,\n    EStatus.KYC_RESULT_APPROVED,\n    EStatus.KYC_RESULT_REJECTED,\n    EStatus.KYC_RESULT_UNDER_REVIEW,\n    EStatus.KYC_REQUEST_REJECTED\n  ];\n\n  constructor() {}\n\n  ngOnInit() {}\n\n  setAgentConfig(config) {\n    this.config = config;\n  }\n\n  toggleMapview() {\n    this.showMapview = !this.showMapview;\n  }\n\n  canStartJourney(status) {\n    const noneEditableStatus =\n      this.config.dashboard?.cannotStartJourney ?? this.notRequiredStatus;\n\n    if (noneEditableStatus.includes(status)) {\n      return false;\n    }\n    return true;\n  }\n\n  canPlotMarkers(status) {\n    const nonePlottingSessions = this.config.dashboard?.dontPlotMarkers ?? [];\n\n    if (nonePlottingSessions.includes(status)) {\n      return false;\n    }\n    return true;\n  }\n}\n"]}

package/esm2015/lib/v1/services/google-maps.service.js

@@ -0,0 +1,201 @@
+import { __awaiter } from "tslib";
+import { Injectable, ViewChildren } from "@angular/core";
+import { checkObjectPathExists, getObjectValueFromPath, isNotEmptyArray } from "kwikid-toolkit";
+import { map } from "rxjs/operators";
+import { addressConcator, nearestNeighborAlgorithm } from "../helpers/maps.helpers";
+import * as i0 from "@angular/core";
+import * as i1 from "./agent.service";
+import * as i2 from "@angular/google-maps";
+import * as i3 from "@angular/common/http";
+export class GoogleMapsService {
+    constructor(agentService, mapDirectionsService, httpClient) {
+        this.agentService = agentService;
+        this.mapDirectionsService = mapDirectionsService;
+        this.httpClient = httpClient;
+        this.allMarkers = [];
+    }
+    // To get Current Position
+    getPosition() {
+        return new Promise((resolve, reject) => {
+            navigator.geolocation.watchPosition((resp) => {
+                resolve({
+                    lng: resp.coords.longitude,
+                    lat: resp.coords.latitude
+                });
+            }, (err) => {
+                reject(err);
+            });
+        });
+    }
+    // To Initialize Google Maps
+    initializeMap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.myPosition = yield this.getPosition();
+            this.map = {
+                zoom: 10,
+                center: this.myPosition,
+                streetViewControl: false,
+                mapTypeControl: false,
+                fullscreenControl: false,
+                zoomControl: false
+            };
+        });
+    }
+    // To extract Location from the Task Details
+    getLocation(task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                let encodedAddres;
+                // If Fetch Address from Multiple Paths
+                if (checkObjectPathExists(this.agentService.config, "dashboard.taskLocationPaths")) {
+                    // Get address string from multiple paths
+                    const config = this.agentService.config.dashboard.taskLocationPaths;
+                    const address = addressConcator(task, config);
+                    // Encode the Address in URI
+                    encodedAddres = encodeURI(address);
+                }
+                // If Fetch Address from Single Path
+                else if (checkObjectPathExists(this.agentService.config, "dashboard.taskLocationPath")) {
+                    // Get Address from Single Path
+                    const config = this.agentService.config.dashboard.taskLocationPath;
+                    const address = getObjectValueFromPath(task, config);
+                    // Encode the Address in URI
+                    encodedAddres = encodeURI(address);
+                }
+                // Default Address Paths Avaiable
+                else {
+                    const address = (_k = (_j = (_g = (_d = (_c = (_b = (_a = task === null || task === void 0 ? void 0 : task.extras) === null || _a === void 0 ? void 0 : _a.task_details) === null || _b === void 0 ? void 0 : _b.customer_details) === null || _c === void 0 ? void 0 : _c.address) !== null && _d !== void 0 ? _d : (_f = (_e = task === null || task === void 0 ? void 0 : task.task_details) === null || _e === void 0 ? void 0 : _e.customer_details) === null || _f === void 0 ? void 0 : _f.address) !== null && _g !== void 0 ? _g : (_h = task === null || task === void 0 ? void 0 : task.extras) === null || _h === void 0 ? void 0 : _h.address) !== null && _j !== void 0 ? _j : task === null || task === void 0 ? void 0 : task.address) !== null && _k !== void 0 ? _k : "";
+                    // Encode the Address in URI
+                    encodedAddres = encodeURI(address);
+                }
+                // URL to geocode Address String to Latitude & Longitude
+                const url = `https://maps.googleapis.com/maps/api/geocode/json?key=${this.apiKey}&address=${encodedAddres}`;
+                const response = yield fetch(url);
+                const data = yield response.json();
+                // Set Location {lat: LAT, lng: LNG} from address geocoded
+                const isValidLocation = isNotEmptyArray(data === null || data === void 0 ? void 0 : data.results);
+                const location = isValidLocation
+                    ? (_m = (_l = data === null || data === void 0 ? void 0 : data.results[0]) === null || _l === void 0 ? void 0 : _l.geometry) === null || _m === void 0 ? void 0 : _m.location
+                    : { lat: null, lng: null };
+                // Set Location validation & Google Maps URL
+                location.isValidLocation = isValidLocation;
+                location.googleMapsUrl = `https://www.google.com/maps/place/${location === null || location === void 0 ? void 0 : location.lat},${location === null || location === void 0 ? void 0 : location.lng}`;
+                resolve(location);
+            }));
+        });
+    }
+    // Get Tasks | Markers Location Co Ordinates
+    getMarkersLocation(myMarker, tasks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                const markers = [];
+                markers.push(myMarker);
+                const promises = tasks.map((task) => __awaiter(this, void 0, void 0, function* () {
+                    const marker = yield this.getLocation(task);
+                    task = Object.assign(Object.assign({}, task), marker);
+                    markers.push(task);
+                }));
+                yield Promise.all(promises);
+                resolve(markers);
+            }));
+        });
+    }
+    // Plot All Markers
+    plotAllMarkers(tasks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                const path = [];
+                const promises = tasks.map((task) => {
+                    if (task === null || task === void 0 ? void 0 : task.isValidLocation) {
+                        path.push({
+                            location: task,
+                            stopover: true
+                        });
+                        this.allMarkers.push(task);
+                    }
+                });
+                yield Promise.all(promises);
+                resolve(path);
+            }));
+        });
+    }
+    // To Plot Directions for All Tasks
+    plotDirectionsForAllTasks(tasks) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.allMarkers = [];
+            // Create Agent Marker & Plot It.
+            const myMarker = {
+                lat: this.myPosition.lat,
+                lng: this.myPosition.lng,
+                title: 0,
+                color: "red"
+            };
+            // Get All Markers Location Co Ordinates
+            const markers = yield this.getMarkersLocation(myMarker, tasks);
+            // Run Algorithm to get optimized Routes
+            const startingPoint = markers[0];
+            const unvisitedWaypoints = markers.slice(1);
+            const optimizedRoute = nearestNeighborAlgorithm(startingPoint, unvisitedWaypoints);
+            // Sort All Tasks as per optimized routes
+            tasks = optimizedRoute.slice(1);
+            this.allMarkers = [myMarker];
+            // Plot all markers & get path for directions
+            const path = yield this.plotAllMarkers(tasks);
+            // Set Directions in Google Maps
+            const request = {
+                origin: this.myPosition,
+                destination: this.myPosition,
+                waypoints: path,
+                travelMode: google.maps.TravelMode.DRIVING
+            };
+            this.directionsRenderOption = {
+                suppressMarkers: true
+            };
+            this.directionsResults$ = this.mapDirectionsService
+                .route(request)
+                .pipe(map((response) => response.result));
+            this.directionsResults$.subscribe((val) => { });
+            this.allDirectionsResults$ = this.directionsResults$;
+            return tasks;
+        });
+    }
+    // To Plot Directions for Selected Tasks
+    plotDirectionsForSelectedTask(task) {
+        if (task != null) {
+            const taskMarker = task;
+            // If Location is Available in Task Details
+            if (taskMarker === null || taskMarker === void 0 ? void 0 : taskMarker.isValidLocation) {
+                const request = {
+                    origin: this.myPosition,
+                    destination: taskMarker,
+                    optimizeWaypoints: true,
+                    travelMode: google.maps.TravelMode.DRIVING
+                };
+                this.directionsResults$ = this.mapDirectionsService
+                    .route(request)
+                    .pipe(map((response) => response.result));
+                this.directionsResults$.subscribe();
+            }
+            else {
+                alert("No Location Available");
+                this.directionsResults$ = this.allDirectionsResults$;
+            }
+        }
+        else {
+            this.directionsResults$ = this.allDirectionsResults$;
+        }
+    }
+}
+/** @nocollapse */ GoogleMapsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: GoogleMapsService, deps: [{ token: i1.AgentService }, { token: i2.MapDirectionsService }, { token: i3.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ GoogleMapsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: GoogleMapsService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: GoogleMapsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AgentService }, { type: i2.MapDirectionsService }, { type: i3.HttpClient }]; }, propDecorators: { directionsRenders: [{
+                type: ViewChildren,
+                args: ["directionsRender"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-maps.service.js","sourceRoot":"","sources":["../../../../../../projects/kwikid-agent-dashboard/src/lib/v1/services/google-maps.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable, QueryList, ViewChildren } from \"@angular/core\";\nimport {\n  checkObjectPathExists,\n  getObjectValueFromPath,\n  isNotEmptyArray\n} from \"kwikid-toolkit\";\n\nimport { MapDirectionsService } from \"@angular/google-maps\";\nimport { Observable, of } from \"rxjs\";\nimport { catchError, map } from \"rxjs/operators\";\nimport { HttpClient } from \"@angular/common/http\";\nimport { AgentService } from \"./agent.service\";\nimport {\n  addressConcator,\n  nearestNeighborAlgorithm\n} from \"../helpers/maps.helpers\";\n\n@Injectable({\n  providedIn: \"root\"\n})\nexport class GoogleMapsService {\n  myPosition;\n\n  map: any;\n\n  apiKey: any;\n\n  allMarkers: any = [];\n\n  directionsRenderOption: any;\n\n  directionsResults$: any;\n\n  allDirectionsResults$: any;\n\n  @ViewChildren(\"directionsRender\") directionsRenders: QueryList<\n    ElementRef<google.maps.DirectionsRenderer>\n  >;\n\n  constructor(\n    private agentService: AgentService,\n    public mapDirectionsService: MapDirectionsService,\n    public httpClient: HttpClient\n  ) {}\n\n  // To get Current Position\n  getPosition(): Promise<any> {\n    return new Promise((resolve, reject) => {\n      navigator.geolocation.watchPosition(\n        (resp) => {\n          resolve({\n            lng: resp.coords.longitude,\n            lat: resp.coords.latitude\n          });\n        },\n        (err) => {\n          reject(err);\n        }\n      );\n    });\n  }\n\n  // To Initialize Google Maps\n  async initializeMap() {\n    this.myPosition = await this.getPosition();\n    this.map = {\n      zoom: 10,\n      center: this.myPosition,\n      streetViewControl: false,\n      mapTypeControl: false,\n      fullscreenControl: false,\n      zoomControl: false\n    };\n  }\n\n  // To extract Location from the Task Details\n  async getLocation(task) {\n    return new Promise(async(resolve) => {\n      let encodedAddres;\n\n      // If Fetch Address from Multiple Paths\n      if (\n        checkObjectPathExists(\n          this.agentService.config,\n          \"dashboard.taskLocationPaths\"\n        )\n      ) {\n        // Get address string from multiple paths\n        const config = this.agentService.config.dashboard.taskLocationPaths;\n        const address = addressConcator(task, config);\n\n        // Encode the Address in URI\n        encodedAddres = encodeURI(address);\n      }\n\n      // If Fetch Address from Single Path\n      else if (\n        checkObjectPathExists(\n          this.agentService.config,\n          \"dashboard.taskLocationPath\"\n        )\n      ) {\n        // Get Address from Single Path\n        const config = this.agentService.config.dashboard.taskLocationPath;\n        const address = getObjectValueFromPath(task, config);\n\n        // Encode the Address in URI\n        encodedAddres = encodeURI(address);\n      }\n\n      // Default Address Paths Avaiable\n      else {\n        const address =\n          task?.extras?.task_details?.customer_details?.address ??\n          task?.task_details?.customer_details?.address ??\n          task?.extras?.address ??\n          task?.address ??\n          \"\";\n\n        // Encode the Address in URI\n        encodedAddres = encodeURI(address);\n      }\n\n      // URL to geocode Address String to Latitude & Longitude\n      const url = `https://maps.googleapis.com/maps/api/geocode/json?key=${this.apiKey}&address=${encodedAddres}`;\n\n      const response = await fetch(url);\n      const data: any = await response.json();\n\n      // Set Location {lat: LAT, lng: LNG} from address geocoded\n      const isValidLocation = isNotEmptyArray(data?.results);\n      const location = isValidLocation\n        ? data?.results[0]?.geometry?.location\n        : { lat: null, lng: null };\n\n      // Set Location validation & Google Maps URL\n      location.isValidLocation = isValidLocation;\n      location.googleMapsUrl = `https://www.google.com/maps/place/${location?.lat},${location?.lng}`;\n\n      resolve(location);\n    });\n  }\n\n  // Get Tasks | Markers Location Co Ordinates\n  async getMarkersLocation(myMarker, tasks) {\n    return new Promise(async(resolve) => {\n      const markers = [];\n      markers.push(myMarker);\n      const promises = tasks.map(async(task) => {\n        const marker: any = await this.getLocation(task);\n        task = { ...task, ...marker };\n        markers.push(task);\n      });\n\n      await Promise.all(promises);\n\n      resolve(markers);\n    });\n  }\n\n  // Plot All Markers\n  async plotAllMarkers(tasks) {\n    return new Promise(async(resolve) => {\n      const path = [];\n      const promises = tasks.map((task) => {\n        if (task?.isValidLocation) {\n          path.push({\n            location: task,\n            stopover: true\n          });\n          this.allMarkers.push(task);\n        }\n      });\n\n      await Promise.all(promises);\n\n      resolve(path);\n    });\n  }\n\n  // To Plot Directions for All Tasks\n  async plotDirectionsForAllTasks(tasks) {\n    this.allMarkers = [];\n\n    // Create Agent Marker & Plot It.\n    const myMarker = {\n      lat: this.myPosition.lat,\n      lng: this.myPosition.lng,\n      title: 0,\n      color: \"red\"\n    };\n\n    // Get All Markers Location Co Ordinates\n    const markers: any = await this.getMarkersLocation(myMarker, tasks);\n\n    // Run Algorithm to get optimized Routes\n    const startingPoint = markers[0];\n    const unvisitedWaypoints = markers.slice(1);\n    const optimizedRoute = nearestNeighborAlgorithm(\n      startingPoint,\n      unvisitedWaypoints\n    );\n\n    // Sort All Tasks as per optimized routes\n    tasks = optimizedRoute.slice(1);\n    this.allMarkers = [myMarker];\n\n    // Plot all markers & get path for directions\n    const path: any = await this.plotAllMarkers(tasks);\n\n    // Set Directions in Google Maps\n    const request: google.maps.DirectionsRequest = {\n      origin: this.myPosition,\n      destination: this.myPosition,\n      waypoints: path,\n      travelMode: google.maps.TravelMode.DRIVING\n    };\n\n    this.directionsRenderOption = {\n      suppressMarkers: true\n    };\n\n    this.directionsResults$ = this.mapDirectionsService\n      .route(request)\n      .pipe(map((response) => response.result));\n\n    this.directionsResults$.subscribe((val) => {});\n\n    this.allDirectionsResults$ = this.directionsResults$;\n\n    return tasks;\n  }\n\n  // To Plot Directions for Selected Tasks\n  plotDirectionsForSelectedTask(task) {\n    if (task != null) {\n      const taskMarker = task;\n\n      // If Location is Available in Task Details\n      if (taskMarker?.isValidLocation) {\n        const request: google.maps.DirectionsRequest = {\n          origin: this.myPosition,\n          destination: taskMarker,\n          optimizeWaypoints: true,\n          travelMode: google.maps.TravelMode.DRIVING\n        };\n\n        this.directionsResults$ = this.mapDirectionsService\n          .route(request)\n          .pipe(map((response) => response.result));\n\n        this.directionsResults$.subscribe();\n      } else {\n        alert(\"No Location Available\");\n        this.directionsResults$ = this.allDirectionsResults$;\n      }\n    } else {\n      this.directionsResults$ = this.allDirectionsResults$;\n    }\n  }\n}\n"]}