kwikid-agent-dashboard 0.0.21 → 0.0.22

package/esm2015/lib/services/map.service.js

@@ -1,62 +1,160 @@
 import { __awaiter } from "tslib";
 import { Injectable, ViewChildren } from '@angular/core';
-import { map } from 'rxjs/operators';
+import * as L from 'leaflet';
+import 'leaflet-routing-machine';
+import { checkObjectPathExists, getObjectValueFromPath } from 'kwikid-toolkit';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/google-maps";
+import * as i1 from "./agent.service";
 export class MapService {
-    constructor(mapDirectionsService) {
-        this.mapDirectionsService = mapDirectionsService;
-        this.markers = [];
-        this.directionsRenderOption = {};
-    }
-    getMarkers() {
-        return this.markers;
-    }
-    setMarkers(markers) {
-        this.markers = markers;
+    constructor(agentService) {
+        this.agentService = agentService;
+        this.allMarkers = [];
     }
+    // To Initialize Map
     initMap() {
         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
-            };
+            this.map = L.map('map', {
+                center: [this.myPosition.lat, this.myPosition.lng],
+                zoom: 13
+            });
+            L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png').addTo(this.map);
         });
     }
-    plotMarkers(customers) {
-        this.markers = [];
-        let path = [];
-        this.markers.push(this.myPosition);
-        const request = {
-            origin: this.myPosition,
-            destination: this.myPosition,
-            waypoints: path,
-            optimizeWaypoints: true,
-            travelMode: google.maps.TravelMode.DRIVING
-        };
-        this.directionsRenderOption = {
-            suppressMarkers: true
-        };
-        this.directionsResults$ = this.mapDirectionsService
-            .route(request)
-            .pipe(map((response) => response.result));
-        this.directionsResults$.subscribe((val) => {
-            customers = this.sortList(val.routes[0].waypoint_order, customers);
-            customers.map((customer) => {
-                path.push({
-                    location: this.getLatLng(customer.task_details.customer_details.location),
-                    stopover: true
-                });
-                this.markers.push(this.getLatLng(customer.task_details.customer_details.location));
+    // To Add Marker in Map
+    addMarker({ lat, lng, title, color }) {
+        L.marker([lat, lng], {
+            icon: L.icon({
+                iconUrl: color == 'red' ? 'assets/map-marker-0.png' : 'assets/map-marker-1.png'
+            })
+        })
+            .addTo(this.map)
+            .bindPopup(title);
+    }
+    // To Plot Directions for All Tasks
+    plotDirectionsForAllTasks(tasks) {
+        if (this.map) {
+            this.allMarkers = [];
+            // Create Agent Marker & Plot It.
+            const myMarker = {
+                lat: this.myPosition.lat,
+                lng: this.myPosition.lng,
+                title: 0,
+                color: 'red'
+            };
+            this.addMarker(myMarker);
+            this.allMarkers.push(myMarker);
+            // Create Markers for all Tasks
+            tasks.map((task, index) => {
+                const marker = this.getLatLng(this.getLocation(task), index);
+                this.allMarkers.push(marker);
             });
+            // Run Algorithm to get optimized Routes
+            const startingPoint = this.allMarkers[0];
+            const unvisitedWaypoints = this.allMarkers.slice(1);
+            const optimizedRoute = this.nearestNeighborAlgorithm(startingPoint, unvisitedWaypoints);
+            // Sort All Markers as per optimized routes
+            this.allMarkers = this.sortTasksAsPerDistance(optimizedRoute, this.allMarkers, true);
+            // Sort All Tasks as per optimized routes
+            tasks = this.sortTasksAsPerDistance(optimizedRoute.slice(1), tasks, false);
+            // Plot Markers for All Tasks
+            tasks.map((task, index) => {
+                const marker = this.getLatLng(this.getLocation(task), index);
+                this.addMarker(marker);
+            });
+            // Set Styles for all Task Routes
+            const styles = [
+                { color: 'blue', opacity: 1, weight: 8 },
+                { color: 'white', opacity: 0.6, weight: 12 }
+            ];
+            // Set Routes for all Tasks
+            this.allTasksRoutes = this.setRoutes(this.allMarkers, styles);
+            this.fitMapBounds();
+        }
+        return tasks;
+    }
+    // To plot Direction for selected Task
+    plotDirectionsForSelectedTask(index) {
+        if (index !== null) {
+            // Remove Previously Selected Task Route
+            if (this.selectedTaskRoutes) {
+                this.map.removeControl(this.selectedTaskRoutes);
+            }
+            // Remove All Tasks Routes
+            if (this.allTasksRoutes) {
+                this.map.removeControl(this.allTasksRoutes);
+            }
+            const taskMarker = this.allMarkers[index + 1];
+            // If Location is Available in Task Details
+            if (taskMarker.color != 'red') {
+                const markers = [this.allMarkers[0], taskMarker];
+                const styles = [
+                    { color: 'green', opacity: 1, weight: 8 },
+                    { color: 'white', opacity: 0.4, weight: 12 }
+                ];
+                this.selectedTaskRoutes = this.setRoutes(markers, styles);
+                this.setSelectedTaskDistanceAndTime();
+            }
+            else {
+                alert('No Location Available');
+            }
+        }
+        // Set All Tasks Routes Again & Remove Selected Tasks route
+        else {
+            if (this.selectedTaskRoutes) {
+                this.map.removeControl(this.selectedTaskRoutes);
+            }
+            this.map.addControl(this.allTasksRoutes);
+            this.selectedTaskRoutes = undefined;
+        }
+        this.fitMapBounds();
+    }
+    // Get Distance & Time of Selected Task
+    getSelectedTaskDistanceAndTime() {
+        return this.selectedTaskDistanceAndTime;
+    }
+    // Set Distance & Time of Selected Task
+    setSelectedTaskDistanceAndTime() {
+        this.selectedTaskRoutes.on('routesfound', function (e) {
+            let routes = e.routes;
+            let summary = routes[0].summary;
+            const distance = summary.totalDistance / 1000;
+            const time = Math.round((summary.totalTime % 3600) / 60);
+            this.selectedTaskDistanceAndTime = {
+                distance: distance,
+                time: time
+            };
         });
-        return this.directionsResults$;
     }
+    // To sort Task as per nearest distance
+    sortTasksAsPerDistance(order, tasks, isMarker) {
+        let sortedTasks = [];
+        for (let i = 0; i < tasks.length; i++) {
+            const title = isMarker ? order[i].title : order[i].title - 1;
+            let task = tasks[title];
+            sortedTasks.push(task);
+        }
+        return sortedTasks;
+    }
+    // To set routes in the maps
+    setRoutes(markers, styles) {
+        return L.Routing.control({
+            waypoints: markers,
+            lineOptions: {
+                styles: styles
+            },
+            createMarker: function () {
+                return null;
+            },
+            routeWhileDragging: true
+        }).addTo(this.map);
+    }
+    // To set view point on the map
+    fitMapBounds() {
+        const markerLatLngs = this.allMarkers.map((marker) => L.latLng(marker.lat, marker.lng));
+        this.map.fitBounds(markerLatLngs);
+    }
+    // To get Current Position
     getPosition() {
         return new Promise((resolve, reject) => {
             navigator.geolocation.watchPosition((resp) => {
@@ -69,31 +167,86 @@ export class MapService {
             });
         });
     }
-    getLatLng(data) {
-        let url = data.split('@');
-        let lat_long_match = url[1].split(',');
-        let lat = Number(lat_long_match[0]);
-        let long = Number(lat_long_match[1]);
-        return { lat: lat, lng: long };
+    // To extract Location from the Task Details
+    getLocation(task) {
+        var _a, _b, _c, _d, _e, _f;
+        if (checkObjectPathExists(this.agentService.config, 'dashboard.taskLocationPath')) {
+            const location = getObjectValueFromPath(task, this.agentService.config.dashboard.taskLocationPath);
+            return location;
+        }
+        else {
+            return ((_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.location) !== 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.location);
+        }
+    }
+    // To get Latitude & Longitude from Task Location
+    getLatLng(data, index) {
+        try {
+            const url = data.split('@');
+            const lat_long_match = url[1].split(',');
+            const lat = Number(lat_long_match[0]);
+            const long = Number(lat_long_match[1]);
+            return { lat: lat, lng: long, title: index + 1, color: 'blue' };
+        }
+        catch (_a) {
+            // If could not find Google Maps Location URL in Task
+            return {
+                lat: this.myPosition.lat,
+                lng: this.myPosition.lng,
+                title: index + 1,
+                color: 'red'
+            };
+        }
+    }
+    // To Calculate Distance between two markers
+    calculateDistance(point1, point2) {
+        const lat1 = point1.lat;
+        const lng1 = point1.lng;
+        const lat2 = point2.lat;
+        const lng2 = point2.lng;
+        const R = 6371; // Earth radius in kilometers
+        const dLat = (lat2 - lat1) * (Math.PI / 180);
+        const dLng = (lng2 - lng1) * (Math.PI / 180);
+        const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+            Math.cos((lat1 * Math.PI) / 180) *
+                Math.cos((lat2 * Math.PI) / 180) *
+                Math.sin(dLng / 2) *
+                Math.sin(dLng / 2);
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        const distance = R * c;
+        return distance;
     }
-    sortList(order, customersData) {
-        let c = [];
-        for (let i = 0; i < customersData.length; i++) {
-            let customer = customersData[order[i]];
-            c.push(customer);
+    // To calculate nearest distance from marker
+    nearestNeighborAlgorithm(startingPoint, unvisitedPoints) {
+        let currentPoint = startingPoint;
+        const path = [currentPoint];
+        const visitedPoints = new Set([currentPoint]);
+        while (unvisitedPoints.length > 0) {
+            let nearestPoint = null;
+            let minDistance = Number.POSITIVE_INFINITY;
+            for (const point of unvisitedPoints) {
+                const distance = this.calculateDistance(currentPoint, point);
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    nearestPoint = point;
+                }
+            }
+            path.push(nearestPoint);
+            visitedPoints.add(nearestPoint);
+            currentPoint = nearestPoint;
+            unvisitedPoints = unvisitedPoints.filter((point) => !visitedPoints.has(point));
         }
-        return c;
+        return path;
     }
 }
-/** @nocollapse */ MapService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapService, deps: [{ token: i1.MapDirectionsService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ MapService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapService, deps: [{ token: i1.AgentService }], target: i0.ɵɵFactoryTarget.Injectable });
 /** @nocollapse */ MapService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MapService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: i1.MapDirectionsService }]; }, propDecorators: { directionsRenders: [{
+        }], ctorParameters: function () { return [{ type: i1.AgentService }]; }, propDecorators: { directionsRenders: [{
                 type: ViewChildren,
                 args: ['directionsRender']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.service.js","sourceRoot":"","sources":["../../../../../projects/kwikid-agent-dashboard/src/lib/services/map.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable, QueryList, ViewChildren } from '@angular/core';\nimport * as L from 'leaflet';\nimport 'leaflet-routing-machine';\nimport { AgentService } from './agent.service';\nimport { checkObjectPathExists, getObjectValueFromPath } from 'kwikid-toolkit';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MapService {\n  myPosition;\n  map: any;\n  allMarkers: any = [];\n\n  allTasksRoutes: any;\n  selectedTaskRoutes: any;\n  selectedTaskDistanceAndTime: any;\n\n  @ViewChildren('directionsRender') directionsRenders: QueryList<\n    ElementRef<google.maps.DirectionsRenderer>\n  >;\n\n  constructor(private agentService: AgentService) {}\n\n  // To Initialize Map\n  async initMap() {\n    this.myPosition = await this.getPosition();\n    this.map = L.map('map', {\n      center: [this.myPosition.lat, this.myPosition.lng],\n      zoom: 13\n    });\n    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png').addTo(\n      this.map\n    );\n  }\n\n  // To Add Marker in Map\n  addMarker({ lat, lng, title, color }) {\n    L.marker([lat, lng], {\n      icon: L.icon({\n        iconUrl:\n          color == 'red' ? 'assets/map-marker-0.png' : 'assets/map-marker-1.png'\n      })\n    })\n      .addTo(this.map)\n      .bindPopup(title);\n  }\n\n  // To Plot Directions for All Tasks\n  plotDirectionsForAllTasks(tasks) {\n    if (this.map) {\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      this.addMarker(myMarker);\n      this.allMarkers.push(myMarker);\n\n      // Create Markers for all Tasks\n      tasks.map((task, index) => {\n        const marker = this.getLatLng(this.getLocation(task), index);\n        this.allMarkers.push(marker);\n      });\n\n      // Run Algorithm to get optimized Routes\n      const startingPoint = this.allMarkers[0];\n      const unvisitedWaypoints = this.allMarkers.slice(1);\n      const optimizedRoute = this.nearestNeighborAlgorithm(\n        startingPoint,\n        unvisitedWaypoints\n      );\n\n      // Sort All Markers as per optimized routes\n      this.allMarkers = this.sortTasksAsPerDistance(\n        optimizedRoute,\n        this.allMarkers,\n        true\n      );\n\n      // Sort All Tasks as per optimized routes\n      tasks = this.sortTasksAsPerDistance(\n        optimizedRoute.slice(1),\n        tasks,\n        false\n      );\n\n      // Plot Markers for All Tasks\n      tasks.map((task, index) => {\n        const marker = this.getLatLng(this.getLocation(task), index);\n        this.addMarker(marker);\n      });\n\n      // Set Styles for all Task Routes\n      const styles = [\n        { color: 'blue', opacity: 1, weight: 8 },\n        { color: 'white', opacity: 0.6, weight: 12 }\n      ];\n\n      // Set Routes for all Tasks\n      this.allTasksRoutes = this.setRoutes(this.allMarkers, styles);\n      this.fitMapBounds();\n    }\n    return tasks;\n  }\n\n  // To plot Direction for selected Task\n  plotDirectionsForSelectedTask(index) {\n    if (index !== null) {\n      // Remove Previously Selected Task Route\n      if (this.selectedTaskRoutes) {\n        this.map.removeControl(this.selectedTaskRoutes);\n      }\n\n      // Remove All Tasks Routes\n      if (this.allTasksRoutes) {\n        this.map.removeControl(this.allTasksRoutes);\n      }\n\n      const taskMarker = this.allMarkers[index + 1];\n\n      // If Location is Available in Task Details\n      if (taskMarker.color != 'red') {\n        const markers = [this.allMarkers[0], taskMarker];\n        const styles = [\n          { color: 'green', opacity: 1, weight: 8 },\n          { color: 'white', opacity: 0.4, weight: 12 }\n        ];\n        this.selectedTaskRoutes = this.setRoutes(markers, styles);\n        this.setSelectedTaskDistanceAndTime();\n      } else {\n        alert('No Location Available');\n      }\n    }\n    // Set All Tasks Routes Again & Remove Selected Tasks route\n    else {\n      if (this.selectedTaskRoutes) {\n        this.map.removeControl(this.selectedTaskRoutes);\n      }\n      this.map.addControl(this.allTasksRoutes);\n      this.selectedTaskRoutes = undefined;\n    }\n    this.fitMapBounds();\n  }\n\n  // Get Distance & Time of Selected Task\n  getSelectedTaskDistanceAndTime() {\n    return this.selectedTaskDistanceAndTime;\n  }\n\n  // Set Distance & Time of Selected Task\n  setSelectedTaskDistanceAndTime() {\n    this.selectedTaskRoutes.on('routesfound', function (e) {\n      let routes = e.routes;\n      let summary = routes[0].summary;\n\n      const distance = summary.totalDistance / 1000;\n      const time = Math.round((summary.totalTime % 3600) / 60);\n\n      this.selectedTaskDistanceAndTime = {\n        distance: distance,\n        time: time\n      };\n    });\n  }\n\n  // To sort Task as per nearest distance\n  sortTasksAsPerDistance(order, tasks, isMarker) {\n    let sortedTasks = [];\n    for (let i = 0; i < tasks.length; i++) {\n      const title = isMarker ? order[i].title : order[i].title - 1;\n      let task = tasks[title];\n      sortedTasks.push(task);\n    }\n    return sortedTasks;\n  }\n\n  // To set routes in the maps\n  setRoutes(markers, styles) {\n    return L.Routing.control({\n      waypoints: markers,\n      lineOptions: {\n        styles: styles\n      },\n      createMarker: function () {\n        return null;\n      },\n      routeWhileDragging: true\n    }).addTo(this.map);\n  }\n\n  // To set view point on the map\n  fitMapBounds() {\n    const markerLatLngs = this.allMarkers.map((marker) =>\n      L.latLng(marker.lat, marker.lng)\n    );\n    this.map.fitBounds(markerLatLngs);\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 extract Location from the Task Details\n  getLocation(task) {\n    if (\n      checkObjectPathExists(\n        this.agentService.config,\n        'dashboard.taskLocationPath'\n      )\n    ) {\n      const location = getObjectValueFromPath(\n        task,\n        this.agentService.config.dashboard.taskLocationPath\n      );\n      return location;\n    } else {\n      return (\n        task?.extras?.task_details?.customer_details?.location ??\n        task?.task_details?.customer_details?.location\n      );\n    }\n  }\n\n  // To get Latitude & Longitude from Task Location\n  getLatLng(data, index) {\n    try {\n      const url = data.split('@');\n      const lat_long_match = url[1].split(',');\n      const lat = Number(lat_long_match[0]);\n      const long = Number(lat_long_match[1]);\n      return { lat: lat, lng: long, title: index + 1, color: 'blue' };\n    } catch {\n      // If could not find Google Maps Location URL in Task\n      return {\n        lat: this.myPosition.lat,\n        lng: this.myPosition.lng,\n        title: index + 1,\n        color: 'red'\n      };\n    }\n  }\n\n  // To Calculate Distance between two markers\n  calculateDistance(point1: any, point2: any): number {\n    const lat1 = point1.lat;\n    const lng1 = point1.lng;\n    const lat2 = point2.lat;\n    const lng2 = point2.lng;\n\n    const R = 6371; // Earth radius in kilometers\n    const dLat = (lat2 - lat1) * (Math.PI / 180);\n    const dLng = (lng2 - lng1) * (Math.PI / 180);\n    const a =\n      Math.sin(dLat / 2) * Math.sin(dLat / 2) +\n      Math.cos((lat1 * Math.PI) / 180) *\n        Math.cos((lat2 * Math.PI) / 180) *\n        Math.sin(dLng / 2) *\n        Math.sin(dLng / 2);\n    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n    const distance = R * c;\n\n    return distance;\n  }\n\n  // To calculate nearest distance from marker\n  nearestNeighborAlgorithm(startingPoint: any, unvisitedPoints: any[]): any[] {\n    let currentPoint = startingPoint;\n    const path: any[] = [currentPoint];\n    const visitedPoints: Set<any> = new Set([currentPoint]);\n\n    while (unvisitedPoints.length > 0) {\n      let nearestPoint = null;\n      let minDistance = Number.POSITIVE_INFINITY;\n\n      for (const point of unvisitedPoints) {\n        const distance = this.calculateDistance(currentPoint, point);\n        if (distance < minDistance) {\n          minDistance = distance;\n          nearestPoint = point;\n        }\n      }\n\n      path.push(nearestPoint);\n      visitedPoints.add(nearestPoint);\n      currentPoint = nearestPoint;\n\n      unvisitedPoints = unvisitedPoints.filter(\n        (point) => !visitedPoints.has(point)\n      );\n    }\n\n    return path;\n  }\n}\n"]}