addio-admin-sdk 1.6.5

package/dist/lib/Delivery/Dispatch.js

@@ -0,0 +1,1055 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var PlannedOrder_1 = require("../../Interfaces/Delivery/PlannedOrder");
+var ScheduledRun_1 = require("../../Interfaces/Delivery/ScheduledRun");
+var Truck_1 = require("../../Interfaces/Delivery/Truck");
+var PlannedOrder_2 = __importDefault(require("./PlannedOrder"));
+var ScheduledRun_2 = __importDefault(require("./ScheduledRun"));
+var CalendarDay_1 = __importDefault(require("./CalendarDay"));
+var moment_1 = __importDefault(require("moment"));
+var Driver_1 = __importDefault(require("./Driver"));
+var Truck_2 = __importDefault(require("./Truck"));
+var isomorphic_unfetch_1 = __importDefault(require("isomorphic-unfetch"));
+var DispatchErrorEnum;
+(function (DispatchErrorEnum) {
+    DispatchErrorEnum[DispatchErrorEnum["NONE"] = 0] = "NONE";
+    DispatchErrorEnum[DispatchErrorEnum["OUT_OF_TRUCK"] = 1] = "OUT_OF_TRUCK";
+})(DispatchErrorEnum || (DispatchErrorEnum = {}));
+var Dispatch = (function () {
+    function Dispatch() {
+        var _this = this;
+        this.pushCityIntoRun = function (cityName, currentRun, orderList) {
+            orderList.map(function (o) {
+                if (o.city == cityName) {
+                    currentRun.command_list.push(o);
+                }
+            });
+            return currentRun;
+        };
+        this.getTruckForRun = function (avaibleTrucks, currentRun) {
+            var truckFit = [];
+            avaibleTrucks.map(function (t) {
+                if (t.skid_count >= currentRun.skids) {
+                    truckFit.push(t);
+                }
+            });
+            return truckFit;
+        };
+        this.getBestTruck = function (avaibleTrucks, skid_count) {
+            var orderedTruck = avaibleTrucks.filter(function (f) { return f.skid_count >= skid_count; }).sort(function (a, b) { return a.priority - b.priority; });
+            for (var i = 0; i < orderedTruck.length; i++) {
+                if (orderedTruck[i].skid_count - skid_count <= 4 || i == orderedTruck.length - 1)
+                    return orderedTruck[i];
+            }
+        };
+        this.getRuns = function (orderList, trucks) {
+            var citys = [];
+            orderList.map(function (c) {
+                if (!citys.includes(c.city))
+                    citys.push(c.city);
+            });
+            var currentRun = (0, ScheduledRun_1.newScheduledRun)();
+            var result = [];
+            var avaibleTrucks = trucks;
+            console.log('City list: ', citys);
+            citys.map(function (c) {
+                var backupRun = __assign({}, currentRun);
+                currentRun = _this.pushCityIntoRun(c, currentRun, orderList);
+                if (!!!avaibleTrucks.length)
+                    return { runs: result, error: DispatchErrorEnum.OUT_OF_TRUCK };
+                var truckFit = _this.getTruckForRun(avaibleTrucks, currentRun);
+                if (!!!truckFit.length) {
+                    var doFit = true;
+                    if (!!backupRun.command_list.length) {
+                        backupRun.truck = _this.getBestTruck(avaibleTrucks, backupRun.skids);
+                        console.log('adding a run: ', backupRun);
+                        result.push(backupRun);
+                        avaibleTrucks = avaibleTrucks.filter(function (t) { return !!!backupRun.truck || t.code_name !== backupRun.truck.code_name; });
+                        currentRun = (0, ScheduledRun_1.newScheduledRun)();
+                        currentRun = _this.pushCityIntoRun(c, currentRun, orderList);
+                        if (!!!avaibleTrucks.length)
+                            return { runs: result, error: DispatchErrorEnum.OUT_OF_TRUCK };
+                        truckFit = _this.getTruckForRun(avaibleTrucks, currentRun);
+                        if (!!!truckFit.length)
+                            doFit = false;
+                    }
+                    else
+                        doFit = false;
+                    if (!doFit) {
+                        console.log('Run didnt fit trying to split city');
+                        orderList.map(function (o) {
+                            if (o.city == c) {
+                                currentRun = __assign({}, backupRun);
+                                currentRun.command_list.push(o);
+                                if (!!!avaibleTrucks.length)
+                                    return { runs: result, error: DispatchErrorEnum.OUT_OF_TRUCK };
+                                truckFit = _this.getTruckForRun(avaibleTrucks, currentRun);
+                                if (!!!truckFit.length) {
+                                    backupRun.truck = _this.getBestTruck(avaibleTrucks, backupRun.skids);
+                                    result.push(backupRun);
+                                    console.log('adding a run: ', backupRun);
+                                    avaibleTrucks = avaibleTrucks.filter(function (t) { return !!!backupRun.truck || t.code_name !== backupRun.truck.code_name; });
+                                    currentRun = (0, ScheduledRun_1.newScheduledRun)();
+                                    currentRun = _this.pushCityIntoRun(c, currentRun, orderList);
+                                    if (!!!avaibleTrucks.length)
+                                        return { runs: result, error: DispatchErrorEnum.OUT_OF_TRUCK };
+                                    truckFit = _this.getTruckForRun(avaibleTrucks, currentRun);
+                                    if (!!!truckFit.length) {
+                                        console.log('Run didnt fit in 1 truck');
+                                        if (!!!avaibleTrucks.length)
+                                            return { runs: result, error: DispatchErrorEnum.OUT_OF_TRUCK };
+                                        var orderedTruck = avaibleTrucks.sort(function (a, b) { return b.skid_count - a.skid_count; });
+                                        currentRun = __assign(__assign({}, currentRun), { truck: orderedTruck[0] });
+                                        result.push(currentRun);
+                                        console.log('adding a run: ', currentRun);
+                                        currentRun = (0, ScheduledRun_1.newScheduledRun)();
+                                        currentRun.command_list.push(o);
+                                    }
+                                }
+                            }
+                        });
+                    }
+                }
+            });
+            if (!!currentRun.command_list.length) {
+                currentRun = __assign(__assign({}, currentRun), { truck: _this.getBestTruck(avaibleTrucks, currentRun.skids) });
+                result.push(currentRun);
+            }
+            return { runs: result, error: 0 };
+        };
+        this.defragRuns = function (runs, trucks) {
+            var orderedRuns = runs.sort(function (a, b) {
+                return (b.truck || { skid_count: 0 }).skid_count - b.skids - ((a.truck || { skid_count: 0 }).skid_count - a.skids);
+            });
+            var i = 0;
+            while (i < orderedRuns.length) {
+                var useTruck = orderedRuns[i].truck || (0, Truck_1.newTruck)();
+                var orderedTruck = trucks
+                    .filter(function (f) { return !runs.some(function (r) { var _a; return ((_a = r.truck) === null || _a === void 0 ? void 0 : _a.code_name) === f.code_name; }); })
+                    .sort(function (a, b) { return b.skid_count - a.skid_count; });
+                if (!!orderedTruck.length) {
+                    if (useTruck.skid_count < orderedTruck[0].skid_count)
+                        useTruck = orderedTruck[0];
+                }
+                for (var r = 0; r < orderedRuns.length; r++)
+                    if (r !== i) {
+                        if (orderedRuns[r].skids + orderedRuns[i].skids <= useTruck.skid_count) {
+                            if (r < i) {
+                                orderedRuns[r] = __assign(__assign({}, orderedRuns[r]), { truck: useTruck });
+                                orderedRuns.splice(i, 1);
+                                i--;
+                                break;
+                            }
+                            else {
+                                orderedRuns[i] = __assign(__assign({}, orderedRuns[i]), { truck: useTruck });
+                                orderedRuns.splice(r, 1);
+                                break;
+                            }
+                        }
+                    }
+                i++;
+            }
+            return runs;
+        };
+        this.googleDirection = function (from, to, waypoints, departure, API_KEY, doReorder) { return __awaiter(_this, void 0, void 0, function () {
+            var url, wp, i, res, data, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        url = "https://maps.googleapis.com/maps/api/directions/json?" +
+                            "origin=".concat(encodeURI(from)) +
+                            "&destination=".concat(encodeURI(to)) +
+                            "&unit=metric" +
+                            "&mode=driving" +
+                            "&departureTime=".concat((0, moment_1.default)(departure).format()) +
+                            "&key=".concat(API_KEY);
+                        if (!!waypoints.length) {
+                            url += "&waypoints=";
+                            wp = 'optimize:' + (!!doReorder ? 'true' : 'false');
+                            for (i = 0; i < waypoints.length; i++) {
+                                wp += '|' + waypoints[i];
+                            }
+                            url += encodeURIComponent(wp);
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        return [4, (0, isomorphic_unfetch_1.default)(url)];
+                    case 2:
+                        res = _a.sent();
+                        return [4, res.json()];
+                    case 3:
+                        data = _a.sent();
+                        return [2, data];
+                    case 4:
+                        error_1 = _a.sent();
+                        console.log("error while fetching Google:", error_1);
+                        throw error_1;
+                    case 5: return [2];
+                }
+            });
+        }); };
+        this.getRouteFromGoogle = function (from, to, waypoints, departure, API_KEY, doReorder) { return __awaiter(_this, void 0, void 0, function () {
+            var data, citys, zips, cityData, realRoute, handledId, cityOffset, orderedCitys, failSafe, _loop_1, this_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(waypoints.length <= 25)) return [3, 2];
+                        return [4, this.googleDirection(from, to, waypoints, departure, API_KEY, doReorder)];
+                    case 1:
+                        data = _a.sent();
+                        return [2, data];
+                    case 2:
+                        citys = [];
+                        zips = [];
+                        waypoints.map(function (w) {
+                            var city = w.split(',')[1].trim();
+                            var zip = w.split(',')[2].trim();
+                            if (!citys.includes(city)) {
+                                citys.push(city);
+                                zips.push(city + ', ' + zip);
+                            }
+                        });
+                        console.log('Splited city :', citys);
+                        return [4, this.googleDirection(from, to, zips, departure, API_KEY, doReorder)];
+                    case 3:
+                        cityData = _a.sent();
+                        realRoute = [];
+                        handledId = [];
+                        cityOffset = -1;
+                        if (!this.validateGoogleRoute(cityData))
+                            throw 'BAD GOOGLE RESULT';
+                        orderedCitys = [];
+                        cityData.routes[0].waypoint_order.map(function (o) {
+                            orderedCitys.push(citys[o].toLowerCase());
+                        });
+                        console.log('orderedCitys :', orderedCitys);
+                        failSafe = 0;
+                        _loop_1 = function () {
+                            var thisFrom, thisTo, tempWP, subRef, subRun, off, i, o, i, o;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        failSafe++;
+                                        if (failSafe > 20)
+                                            throw 'Too many loop';
+                                        thisFrom = from;
+                                        thisTo = to;
+                                        if (!!realRoute.length) {
+                                            console.log('set from :', realRoute[realRoute.length - 1].end_address);
+                                            thisFrom = realRoute[realRoute.length - 1].end_address;
+                                        }
+                                        tempWP = [];
+                                        subRef = [];
+                                        cityOffset = -1;
+                                        while (cityOffset < orderedCitys.length && tempWP.length < 25) {
+                                            cityOffset++;
+                                            waypoints.map(function (w, idx) {
+                                                var city = w.split(',')[1].trim().toLowerCase();
+                                                if (orderedCitys[cityOffset] === city && !handledId.includes(idx) && tempWP.length < 25) {
+                                                    console.log('adding to run: ', w);
+                                                    tempWP.push(w);
+                                                    subRef.push(idx);
+                                                }
+                                            });
+                                        }
+                                        if (cityOffset < citys.length - 1)
+                                            thisTo = citys[cityOffset + 1];
+                                        console.log('getting direction from to: ', thisFrom, thisTo);
+                                        return [4, this_1.googleDirection(thisFrom, thisTo, tempWP, departure, API_KEY, doReorder)];
+                                    case 1:
+                                        subRun = _b.sent();
+                                        if (!this_1.validateGoogleRoute(subRun))
+                                            throw 'BAD GOOGLE RESULT';
+                                        if (tempWP.length + realRoute.length < waypoints.length) {
+                                            console.log('more to do...: ');
+                                            off = subRun.routes[0].legs.length - 2;
+                                            while (off > subRun.routes[0].legs.length - 6) {
+                                                if (subRun.routes[0].legs[off].end_address.split(',')[1].toLowerCase() !==
+                                                    subRun.routes[0].legs[off - 1].end_address.split(',')[1].toLowerCase()) {
+                                                    cityOffset--;
+                                                    break;
+                                                }
+                                                off--;
+                                            }
+                                            for (i = 0; i <= off; i++) {
+                                                console.log('adding to final run: ', subRun.routes[0].legs[i].end_address);
+                                                departure = (0, moment_1.default)(departure).add(subRun.routes[0].legs[i].duration.value, 'second').toDate();
+                                                realRoute.push(__assign({}, subRun.routes[0].legs[i]));
+                                                o = subRef[subRun.routes[0].waypoint_order[i]];
+                                                handledId.push(o);
+                                            }
+                                        }
+                                        else {
+                                            for (i = 0; i < subRun.routes[0].legs.length - 1; i++) {
+                                                console.log('adding to final run: ', subRun.routes[0].legs[i].end_address);
+                                                departure = (0, moment_1.default)(departure).add(subRun.routes[0].legs[i].duration.value, 'second').toDate();
+                                                realRoute.push(__assign({}, subRun.routes[0].legs[i]));
+                                                o = subRef[subRun.routes[0].waypoint_order[i]];
+                                                handledId.push(o);
+                                            }
+                                        }
+                                        console.log('Handled id : ', handledId);
+                                        console.log('count : ', handledId.length);
+                                        console.log('ttl count : ', waypoints.length);
+                                        return [2];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _a.label = 4;
+                    case 4:
+                        if (!(handledId.length < waypoints.length)) return [3, 6];
+                        return [5, _loop_1()];
+                    case 5:
+                        _a.sent();
+                        return [3, 4];
+                    case 6:
+                        console.log('done');
+                        return [2, __assign(__assign({}, cityData), { routes: [__assign(__assign({}, cityData.routes[0]), { legs: realRoute, waypoint_order: handledId })] })];
+                }
+            });
+        }); };
+        this.validateGoogleRoute = function (objJson) {
+            if (!!objJson && !!objJson.routes && !!objJson.routes.length) {
+                if (!!objJson.routes[0].legs && !!objJson.routes[0].legs.length) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        this.unpackGoogleRoute = function (objJson, orderList) {
+            if (!!objJson && !!objJson.routes && !!objJson.routes.length) {
+                var usedRoute = undefined;
+                for (var i = 0; i < objJson.routes.length; i++) {
+                    if (!!objJson.routes[i].legs && !!objJson.routes[i].legs.length) {
+                        usedRoute = objJson.routes[i];
+                        break;
+                    }
+                }
+                if (!!usedRoute) {
+                    var re_1 = [];
+                    usedRoute.legs.map(function (r) {
+                        re_1.push({
+                            distance: r.distance.value,
+                            duration: r.duration.value,
+                            full_address: r.end_address,
+                            position: r.end_location,
+                            city: r.end_address.split(',')[1].trim(),
+                            linked_order: undefined
+                        });
+                    });
+                    if (!!usedRoute.waypoint_order && !!usedRoute.waypoint_order.length) {
+                        for (var i = 0; i < usedRoute.waypoint_order.length; i++) {
+                            re_1[i].linked_order = orderList[usedRoute.waypoint_order[i]] || null;
+                        }
+                    }
+                    else {
+                        if (re_1.length == 1) {
+                            re_1[0].linked_order = orderList[0] || null;
+                        }
+                    }
+                    return re_1;
+                }
+            }
+            return [];
+        };
+        this.fillTruckInOrder = function (list, trucks, space) { return __awaiter(_this, void 0, void 0, function () {
+            var re, avaibleTrucks, currentRun, _i, list_1, routeEntry, quote, quotesReq, error_2, t, t;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        re = [];
+                        avaibleTrucks = __spreadArray([], trucks, true).sort(function (a, b) { return b.skid_count - a.skid_count; });
+                        currentRun = (0, ScheduledRun_1.newScheduledRun)();
+                        _i = 0, list_1 = list;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < list_1.length)) return [3, 7];
+                        routeEntry = list_1[_i];
+                        if (!!!routeEntry.linked_order)
+                            return [3, 6];
+                        quote = void 0;
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4, space.quotes.get({
+                                query: [{ field: 'id', operator: '==', value: routeEntry.linked_order.quote_id }]
+                            })];
+                    case 3:
+                        quotesReq = _a.sent();
+                        quote = quotesReq[0];
+                        return [3, 5];
+                    case 4:
+                        error_2 = _a.sent();
+                        throw new Error("Can't fetch quote with id ".concat(routeEntry.linked_order.id));
+                    case 5:
+                        if (!!routeEntry.linked_order) {
+                            if (!!avaibleTrucks.length && quote.getSkidPlateCount() + currentRun.skids > avaibleTrucks[0].skid_count) {
+                                t = 0;
+                                while (t < avaibleTrucks.length && currentRun.skids <= avaibleTrucks[t].skid_count)
+                                    t++;
+                                t--;
+                                currentRun = __assign(__assign({}, currentRun), { truck: avaibleTrucks[t] });
+                                avaibleTrucks.splice(t, 1);
+                                re.push(currentRun);
+                                currentRun = (0, ScheduledRun_1.newScheduledRun)();
+                            }
+                            currentRun.command_list.push(__assign(__assign({}, routeEntry.linked_order), { google_city: routeEntry.city.toLowerCase() }));
+                            currentRun = __assign(__assign({}, currentRun), { skids: currentRun.skids + quote.getSkidPlateCount() });
+                        }
+                        _a.label = 6;
+                    case 6:
+                        _i++;
+                        return [3, 1];
+                    case 7:
+                        if (currentRun.skids > 0) {
+                            if (!!avaibleTrucks.length) {
+                                t = 0;
+                                while (t < avaibleTrucks.length && currentRun.skids <= avaibleTrucks[t].skid_count)
+                                    t++;
+                                t--;
+                                currentRun = __assign(__assign({}, currentRun), { truck: avaibleTrucks[t] });
+                                avaibleTrucks.splice(t, 1);
+                            }
+                            re.push(currentRun);
+                        }
+                        return [2, re];
+                }
+            });
+        }); };
+        this.calcCrow = function (lat1, lon1, lat2, lon2) {
+            var R = 6371;
+            var dLat = _this.toRad(lat2 - lat1);
+            var dLon = _this.toRad(lon2 - lon1);
+            var lat1 = _this.toRad(lat1);
+            var lat2 = _this.toRad(lat2);
+            var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+                Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
+            var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+            var d = R * c;
+            return d;
+        };
+        this.toRad = function (Value) {
+            return (Value * Math.PI) / 180;
+        };
+        this.doAgregate = function (list, radius) {
+            var roadMatch = list.map(function (r) { return []; });
+            list.map(function (r, idx) {
+                if (!!r.linked_order) {
+                    list.map(function (b, idx2) {
+                        if (!!b.linked_order) {
+                            if (r.city == b.city)
+                                roadMatch[idx].push(idx2);
+                            else {
+                                if (_this.calcCrow(r.position.lat, r.position.lng, b.position.lat, b.position.lng) < radius)
+                                    roadMatch[idx].push(idx2);
+                            }
+                        }
+                    });
+                }
+            });
+            return roadMatch;
+        };
+        this.fillTruckByAgregation = function (list, trucks, startRadius, space) { return __awaiter(_this, void 0, void 0, function () {
+            var radius, decided, avaibleTrucks, re, _loop_2, this_2;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        radius = startRadius + 5;
+                        decided = false;
+                        avaibleTrucks = __spreadArray([], trucks, true).sort(function (a, b) { return b.skid_count - a.skid_count; });
+                        if (!!!avaibleTrucks.length)
+                            return [2, []];
+                        re = [];
+                        _loop_2 = function () {
+                            var agregations, currentRun, allMap, thisMap, nextLeft, nextRight, safe, orderR, orderL, quoteR, quoteL, quotesReqR, quotesReqL, error_3, t;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        radius -= 5;
+                                        agregations = this_2.doAgregate(list, radius);
+                                        agregations = agregations.filter(function (f) { return f.length > 0; });
+                                        agregations = agregations.filter(function (f) { return __awaiter(_this, void 0, void 0, function () {
+                                            var c, _i, f_1, e, plannedOrder, quotesReq, quote;
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        c = 0;
+                                                        _i = 0, f_1 = f;
+                                                        _a.label = 1;
+                                                    case 1:
+                                                        if (!(_i < f_1.length)) return [3, 4];
+                                                        e = f_1[_i];
+                                                        plannedOrder = list[e].linked_order;
+                                                        if (!!!plannedOrder)
+                                                            return [3, 3];
+                                                        return [4, space.quotes.get({
+                                                                query: [{ field: 'id', operator: '==', value: plannedOrder.quote_id }]
+                                                            })];
+                                                    case 2:
+                                                        quotesReq = _a.sent();
+                                                        quote = quotesReq[0];
+                                                        c += quote.getSkidPlateCount();
+                                                        _a.label = 3;
+                                                    case 3:
+                                                        _i++;
+                                                        return [3, 1];
+                                                    case 4: return [2, avaibleTrucks.length == 0 || c <= avaibleTrucks[0].skid_count];
+                                                }
+                                            });
+                                        }); });
+                                        if (!!!agregations.length)
+                                            return [2, "continue"];
+                                        agregations = agregations.sort(function (a, b) { return b.length - a.length; });
+                                        currentRun = (0, ScheduledRun_1.newScheduledRun)();
+                                        allMap = [];
+                                        _b.label = 1;
+                                    case 1:
+                                        if (!!!agregations.length) return [3, 9];
+                                        currentRun = (0, ScheduledRun_1.newScheduledRun)();
+                                        thisMap = __spreadArray([], agregations[0], true);
+                                        thisMap.map(function (a) {
+                                            allMap.push(a);
+                                            var order = list[a].linked_order;
+                                            if (!!order) {
+                                                currentRun.command_list.push(__assign(__assign({}, order), { google_city: list[a].city.toLowerCase() }));
+                                            }
+                                        });
+                                        nextLeft = thisMap[0];
+                                        nextRight = nextLeft + 1;
+                                        if (nextRight >= list.length - 2)
+                                            nextRight = 0;
+                                        safe = 1000;
+                                        _b.label = 2;
+                                    case 2:
+                                        if (!true) return [3, 8];
+                                        safe--;
+                                        if (safe <= 0) {
+                                            agregations = [];
+                                            return [3, 8];
+                                        }
+                                        if (allMap.length >= list.length - 1) {
+                                            return [3, 8];
+                                        }
+                                        while (allMap.includes(nextLeft)) {
+                                            if (nextLeft === 0)
+                                                nextLeft = list.length - 1;
+                                            nextLeft--;
+                                        }
+                                        while (allMap.includes(nextRight)) {
+                                            if (nextRight >= list.length - 2)
+                                                nextRight = -1;
+                                            nextRight++;
+                                        }
+                                        orderR = list[nextRight].linked_order;
+                                        orderL = list[nextLeft].linked_order;
+                                        if (!!!orderL || !!!orderR) {
+                                            return [3, 8];
+                                        }
+                                        quoteR = void 0;
+                                        quoteL = void 0;
+                                        _b.label = 3;
+                                    case 3:
+                                        _b.trys.push([3, 6, , 7]);
+                                        return [4, space.quotes.get({
+                                                query: [{ field: 'id', operator: '==', value: orderR.quote_id }]
+                                            })];
+                                    case 4:
+                                        quotesReqR = _b.sent();
+                                        quoteR = quotesReqR[0];
+                                        return [4, space.quotes.get({
+                                                query: [{ field: 'id', operator: '==', value: orderL.quote_id }]
+                                            })];
+                                    case 5:
+                                        quotesReqL = _b.sent();
+                                        quoteL = quotesReqL[0];
+                                        return [3, 7];
+                                    case 6:
+                                        error_3 = _b.sent();
+                                        throw error_3;
+                                    case 7:
+                                        if (!!avaibleTrucks.length &&
+                                            currentRun.skids + quoteL.getSkidPlateCount() > avaibleTrucks[0].skid_count &&
+                                            currentRun.skids + quoteR.getSkidPlateCount() > avaibleTrucks[0].skid_count)
+                                            return [3, 8];
+                                        if (!!avaibleTrucks.length && currentRun.skids + quoteL.getSkidPlateCount() > avaibleTrucks[0].skid_count) {
+                                            allMap.push(nextRight);
+                                            currentRun = __assign(__assign({}, currentRun), { command_list: __spreadArray(__spreadArray([], currentRun.command_list, true), [
+                                                    __assign(__assign({}, orderR), { google_city: list[nextRight].city.toLowerCase() })
+                                                ], false), skids: currentRun.skids + quoteR.getSkidPlateCount() });
+                                        }
+                                        else if (!!avaibleTrucks.length &&
+                                            currentRun.skids + quoteR.getSkidPlateCount() > avaibleTrucks[0].skid_count) {
+                                            allMap.push(nextLeft);
+                                            currentRun = __assign(__assign({}, currentRun), { command_list: __spreadArray(__spreadArray([], currentRun.command_list, true), [__assign(__assign({}, orderL), { google_city: list[nextLeft].city.toLowerCase() })], false), skids: currentRun.skids + quoteL.getSkidPlateCount() });
+                                        }
+                                        else if (list[nextRight].distance > list[nextLeft].distance) {
+                                            allMap.push(nextLeft);
+                                            currentRun = __assign(__assign({}, currentRun), { command_list: __spreadArray(__spreadArray([], currentRun.command_list, true), [__assign(__assign({}, orderL), { google_city: list[nextLeft].city.toLowerCase() })], false), skids: currentRun.skids + quoteL.getSkidPlateCount() });
+                                        }
+                                        else {
+                                            allMap.push(nextRight);
+                                            currentRun = __assign(__assign({}, currentRun), { command_list: __spreadArray(__spreadArray([], currentRun.command_list, true), [
+                                                    __assign(__assign({}, orderR), { google_city: list[nextRight].city.toLowerCase() })
+                                                ], false), skids: currentRun.skids + quoteR.getSkidPlateCount() });
+                                        }
+                                        return [3, 2];
+                                    case 8:
+                                        allMap.map(function (m) {
+                                            agregations.map(function (a) {
+                                                if (a.includes(m)) {
+                                                    var p = a.indexOf(m);
+                                                    a.splice(p, 1);
+                                                }
+                                            });
+                                        });
+                                        agregations = agregations.filter(function (f) { return f.length > 0; });
+                                        agregations = agregations.sort(function (a, b) { return b.length - a.length; });
+                                        if (!!avaibleTrucks.length) {
+                                            t = 0;
+                                            while (t < avaibleTrucks.length && currentRun.skids <= avaibleTrucks[t].skid_count)
+                                                t++;
+                                            t--;
+                                            currentRun = __assign(__assign({}, currentRun), { truck: avaibleTrucks[t] });
+                                            avaibleTrucks.splice(t, 1);
+                                        }
+                                        re.push(currentRun);
+                                        return [3, 1];
+                                    case 9:
+                                        if (!!re.length)
+                                            decided = true;
+                                        return [2];
+                                }
+                            });
+                        };
+                        this_2 = this;
+                        _a.label = 1;
+                    case 1:
+                        if (!(radius > 1 && !decided)) return [3, 3];
+                        return [5, _loop_2()];
+                    case 2:
+                        _a.sent();
+                        return [3, 1];
+                    case 3: return [2, re];
+                }
+            });
+        }); };
+        this.evaluateRoutes = function (runs) {
+            var result = 0;
+            var _loop_3 = function (i) {
+                runs[i].command_list.map(function (c) {
+                    for (var a = i + 1; a < runs.length; a++) {
+                        if (runs[a].command_list.some(function (e) { return e.google_city === c.google_city; }))
+                            result += 50;
+                    }
+                });
+            };
+            for (var i = 0; i < runs.length - 1; i++) {
+                _loop_3(i);
+            }
+            result += runs.length * 100;
+            runs.map(function (r) {
+                if (!!r.truck)
+                    result += (r.truck.skid_count - r.skids) * 10;
+            });
+            if (runs.some(function (r) { return !!!r.truck; }))
+                result += 500;
+            return result;
+        };
+        this.dispatchDay = function (dayInfo, orderList, trucks, _drivers, settings, space) { return __awaiter(_this, void 0, void 0, function () {
+            var currentDay, fullAddress, myJson, allPoints, runs, pts, _a, _b, _c, _d, _e, _f, _g, _h, i, bestRoutes, bestPts, i, run_1, amtot, otherDelivery, finalDelivery, finalGoogleRoute, googleRoute, from, addrs, routeAM, amPoints, i, deli, i, addrs, route, amPoints, i, deli, i, error_4, error_5;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        currentDay = (0, moment_1.default)(dayInfo.day)
+                            .set('hour', settings.departure_hour)
+                            .set('minute', settings.departure_minute)
+                            .toDate();
+                        fullAddress = orderList.map(function (plannedOrder) { return plannedOrder.fullAddress; });
+                        _j.label = 1;
+                    case 1:
+                        _j.trys.push([1, 17, , 18]);
+                        return [4, this.getRouteFromGoogle(settings.home_address, settings.home_address, fullAddress, currentDay, settings.api_key, !!settings.reorder_route)];
+                    case 2:
+                        myJson = _j.sent();
+                        allPoints = this.unpackGoogleRoute(myJson, orderList.map(function (obj) { return obj.data(); }));
+                        runs = [[], [], [], []];
+                        pts = [0, 0, 0, 0];
+                        if (!!!settings.dispatch_trucks) return [3, 6];
+                        _a = runs;
+                        _b = 1;
+                        return [4, this.fillTruckByAgregation(allPoints, trucks, 5, space)];
+                    case 3:
+                        _a[_b] = _j.sent();
+                        _c = runs;
+                        _d = 2;
+                        return [4, this.fillTruckByAgregation(allPoints, trucks, 10, space)];
+                    case 4:
+                        _c[_d] = _j.sent();
+                        _e = runs;
+                        _f = 3;
+                        return [4, this.fillTruckByAgregation(allPoints, trucks, 15, space)];
+                    case 5:
+                        _e[_f] = _j.sent();
+                        _j.label = 6;
+                    case 6:
+                        _g = runs;
+                        _h = 0;
+                        return [4, this.fillTruckInOrder(allPoints, trucks, space)];
+                    case 7:
+                        _g[_h] = _j.sent();
+                        if (!!settings.dispatch_trucks) {
+                            for (i = 0; i < 4; i++)
+                                pts[i] = this.evaluateRoutes(runs[i]);
+                        }
+                        bestRoutes = runs[0];
+                        bestPts = pts[0];
+                        if (!!settings.dispatch_trucks) {
+                            for (i = 0; i < 4; i++) {
+                                if (pts[i] < bestPts) {
+                                    bestPts = pts[i];
+                                    bestRoutes = runs[i];
+                                }
+                            }
+                        }
+                        run_1 = 0;
+                        _j.label = 8;
+                    case 8:
+                        if (!(run_1 < bestRoutes.length)) return [3, 16];
+                        _j.label = 9;
+                    case 9:
+                        _j.trys.push([9, 14, , 15]);
+                        amtot = [];
+                        otherDelivery = __spreadArray([], bestRoutes[run_1].command_list, true);
+                        if (!!settings.reorder_route) {
+                            amtot = bestRoutes[run_1].command_list.filter(function (f) { return f.is_AM; });
+                            otherDelivery = bestRoutes[run_1].command_list.filter(function (f) { return !f.is_AM; });
+                        }
+                        finalDelivery = [];
+                        finalGoogleRoute = [];
+                        googleRoute = undefined;
+                        from = settings.home_address;
+                        if (!!!amtot.length) return [3, 11];
+                        addrs = amtot.map(function (a) { return a.address + ', ' + a.city + ', ' + a.province; });
+                        return [4, this.getRouteFromGoogle(settings.home_address, !!otherDelivery.length ? addrs[addrs.length - 1] : settings.home_address, !!otherDelivery.length ? addrs.slice(0, addrs.length - 1) : addrs, currentDay, settings.api_key, !!settings.reorder_route)];
+                    case 10:
+                        routeAM = _j.sent();
+                        from = addrs[addrs.length - 1];
+                        amPoints = this.unpackGoogleRoute(routeAM, amtot);
+                        for (i = 0; i < amPoints.length; i++) {
+                            deli = amPoints[i].linked_order;
+                            if (!!deli)
+                                finalDelivery.push(__assign({}, deli));
+                        }
+                        for (i = 0; i < routeAM.routes[0].legs.length; i++) {
+                            finalGoogleRoute.push(__assign({}, routeAM.routes[0].legs[i]));
+                        }
+                        googleRoute = routeAM;
+                        _j.label = 11;
+                    case 11:
+                        if (!!!otherDelivery.length) return [3, 13];
+                        addrs = otherDelivery.map(function (a) { return a.address + ', ' + a.city + ', ' + a.province; });
+                        return [4, this.getRouteFromGoogle(from, settings.home_address, addrs, currentDay, settings.api_key, !!settings.reorder_route)];
+                    case 12:
+                        route = _j.sent();
+                        amPoints = this.unpackGoogleRoute(route, otherDelivery);
+                        for (i = 0; i < amPoints.length; i++) {
+                            deli = amPoints[i].linked_order;
+                            if (!!deli)
+                                finalDelivery.push(__assign({}, deli));
+                        }
+                        for (i = 0; i < route.routes[0].legs.length; i++) {
+                            finalGoogleRoute.push(__assign({}, route.routes[0].legs[i]));
+                        }
+                        googleRoute = route;
+                        _j.label = 13;
+                    case 13:
+                        bestRoutes[run_1] = __assign(__assign({}, bestRoutes[run_1]), { command_list: __spreadArray([], finalDelivery, true), day: dayInfo.day, google_route: __assign(__assign({}, googleRoute), { routes: [
+                                    __assign(__assign({}, googleRoute.routes[0]), { legs: finalGoogleRoute, waypoint_order: finalDelivery.map(function (c, idx) { return idx; }) })
+                                ] }) });
+                        return [3, 15];
+                    case 14:
+                        error_4 = _j.sent();
+                        console.log("in loop", error_4);
+                        return [3, 15];
+                    case 15:
+                        run_1++;
+                        return [3, 8];
+                    case 16: return [2, bestRoutes];
+                    case 17:
+                        error_5 = _j.sent();
+                        console.log(error_5);
+                        throw error_5;
+                    case 18: return [2];
+                }
+            });
+        }); };
+        this.deleteFromDispatch = function (space, quoteId) { return __awaiter(_this, void 0, void 0, function () {
+            var old, schList, l, pos, mySche;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, PlannedOrder_2.default.fetchByQuoteId(space, quoteId)];
+                    case 1:
+                        old = _a.sent();
+                        if (!(!!old && !!old.length)) return [3, 7];
+                        return [4, ScheduledRun_2.default.getList(space, old[0].day)];
+                    case 2:
+                        schList = _a.sent();
+                        if (!!!schList) return [3, 7];
+                        l = 0;
+                        _a.label = 3;
+                    case 3:
+                        if (!(l < schList.length)) return [3, 7];
+                        pos = schList[l].command_list.findIndex(function (f) { return f.quote_id == quoteId; });
+                        if (!(pos > -1)) return [3, 6];
+                        schList[l].command_list.splice(pos, 1);
+                        return [4, ScheduledRun_2.default.create(space)];
+                    case 4:
+                        mySche = _a.sent();
+                        if (!!!mySche) return [3, 6];
+                        return [4, mySche.save(__assign(__assign({}, schList[l]), { google_is_good: false }))];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6:
+                        l++;
+                        return [3, 3];
+                    case 7: return [4, PlannedOrder_2.default.deleteId(quoteId, space)];
+                    case 8:
+                        _a.sent();
+                        return [2];
+                }
+            });
+        }); };
+        this.addToDispatch = function (space, quote) { return __awaiter(_this, void 0, void 0, function () {
+            var quoteData, address, client, id, amTot, shipping_date, day, plannedOrdersReq, old, newOrder_1, schList, l, pos, mySche, error_6, list, customDay, sData, custom, drivers, daySettings_1, trucks, sche, existingSche, toBeReplaced, p, forSave, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 27, , 28]);
+                        quoteData = quote.data();
+                        address = quoteData.address, client = quoteData.client, id = quoteData.id, amTot = quoteData.amTot, shipping_date = quoteData.shipping_date;
+                        if (!!!address || !!!client || !!!id || !!!shipping_date)
+                            throw new Error('Not enought information in quote, try filling address, client and id');
+                        day = quote.shippingDate;
+                        return [4, space.plannedOrders.get({
+                                query: [{ field: 'quote_id', operator: '==', value: id }]
+                            })];
+                    case 1:
+                        plannedOrdersReq = _a.sent();
+                        old = undefined;
+                        if (!!plannedOrdersReq.length && !!plannedOrdersReq[0])
+                            old = __assign({}, plannedOrdersReq[0].data());
+                        newOrder_1 = !!plannedOrdersReq.length && !!plannedOrdersReq[0]
+                            ? plannedOrdersReq[0]
+                            : new PlannedOrder_2.default((0, PlannedOrder_1.newPlannedOrder)(), space, 'dispatch@addiocommerce.com');
+                        if (!!!newOrder_1)
+                            throw new Error("Unable to create new planned order");
+                        return [4, newOrder_1.save({
+                                day: (0, moment_1.default)(day).format('YYYY-MM-DD'),
+                                address: address.address,
+                                is_AM: !!amTot,
+                                customer: {
+                                    email: client.email,
+                                    name: client.name,
+                                    phone: client.phone
+                                },
+                                quote_id: id,
+                                status: 0
+                            })];
+                    case 2:
+                        _a.sent();
+                        if (!(!!!old ||
+                            old.address !== newOrder_1.data().address ||
+                            old.city !== newOrder_1.data().city ||
+                            old.day !== newOrder_1.data().day)) return [3, 26];
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 10, , 11]);
+                        if (!(!!old && old.day !== newOrder_1.data().day)) return [3, 9];
+                        return [4, ScheduledRun_2.default.getList(space, old.day)];
+                    case 4:
+                        schList = _a.sent();
+                        if (!!!schList) return [3, 9];
+                        l = 0;
+                        _a.label = 5;
+                    case 5:
+                        if (!(l < schList.length)) return [3, 9];
+                        pos = schList[l].command_list.findIndex(function (f) { return f.quote_id == newOrder_1.data().quote_id; });
+                        if (!(pos > -1)) return [3, 8];
+                        schList[l].command_list.splice(pos, 1);
+                        return [4, ScheduledRun_2.default.create(space)];
+                    case 6:
+                        mySche = _a.sent();
+                        if (!!!mySche) return [3, 8];
+                        return [4, mySche.save(__assign(__assign({}, schList[l]), { google_is_good: false }))];
+                    case 7:
+                        _a.sent();
+                        _a.label = 8;
+                    case 8:
+                        l++;
+                        return [3, 5];
+                    case 9: return [3, 11];
+                    case 10:
+                        error_6 = _a.sent();
+                        console.log("error while changing day", error_6);
+                        throw error_6;
+                    case 11: return [4, PlannedOrder_2.default.getList(space, newOrder_1.data().day)];
+                    case 12:
+                        list = _a.sent();
+                        if (!!!list) return [3, 26];
+                        customDay = void 0;
+                        sData = space.data();
+                        return [4, CalendarDay_1.default.getList(space, [newOrder_1.data().day])];
+                    case 13:
+                        custom = _a.sent();
+                        if (!!custom && custom.length) {
+                            customDay = custom[0];
+                        }
+                        return [4, Driver_1.default.getList(space)];
+                    case 14:
+                        drivers = _a.sent();
+                        daySettings_1 = {
+                            avaible_drivers: !!customDay ? customDay.avaible_drivers : (drivers || []).map(function (d) { return d.slug; }),
+                            max_run: !!customDay
+                                ? customDay.max_runs
+                                : !!sData.dispatch_settings
+                                    ? sData.dispatch_settings.normal_week_config[(0, moment_1.default)(newOrder_1.data().day).day()].max_run
+                                    : 1,
+                            max_time: !!customDay
+                                ? customDay.time_limit
+                                : !!sData.dispatch_settings
+                                    ? sData.dispatch_settings.day_max_driving_time
+                                    : 12,
+                            start_time: !!sData.dispatch_settings ? sData.dispatch_settings.day_start_time : 7 * 60,
+                            time_per_delivery: 5,
+                            time_per_skid: 5
+                        };
+                        return [4, Truck_2.default.getList(space)];
+                    case 15:
+                        trucks = _a.sent();
+                        return [4, this.dispatchDay({
+                                avaible_drivers: daySettings_1.avaible_drivers,
+                                day: newOrder_1.data().day,
+                                max_runs: daySettings_1.max_run,
+                                time_limit: daySettings_1.max_time,
+                                last_update_by: ''
+                            }, list, trucks || [], (drivers || []).filter(function (f) { return daySettings_1.avaible_drivers.includes(f.slug); }), {
+                                api_key: !!sData.dispatch_settings ? sData.dispatch_settings.api_key : '',
+                                departure_hour: Math.trunc(daySettings_1.start_time / 60),
+                                departure_minute: daySettings_1.start_time % 60,
+                                home_address: !!sData.dispatch_settings
+                                    ? sData.dispatch_settings.home_address
+                                    : '3150 Bd Hochelaga, Québec, QC G1W 2R2',
+                                reorder_route: true
+                            }, space)];
+                    case 16:
+                        sche = _a.sent();
+                        if (!!!sche) return [3, 26];
+                        return [4, ScheduledRun_2.default.getList(space, newOrder_1.data().day)];
+                    case 17:
+                        existingSche = _a.sent();
+                        toBeReplaced = [];
+                        if (!!existingSche) {
+                            toBeReplaced = existingSche;
+                        }
+                        p = 0;
+                        return [4, ScheduledRun_2.default.create(space)];
+                    case 18:
+                        forSave = _a.sent();
+                        _a.label = 19;
+                    case 19:
+                        if (!(p < sche.length && !!forSave)) return [3, 24];
+                        if (!(p < toBeReplaced.length)) return [3, 21];
+                        return [4, forSave.save(__assign(__assign({}, toBeReplaced[p]), { command_list: sche[p].command_list, google_is_good: true, google_route: sche[p].google_route, skids: sche[p].skids }))];
+                    case 20:
+                        _a.sent();
+                        return [3, 23];
+                    case 21: return [4, forSave.save(__assign(__assign({}, sche[p]), { google_is_good: true, skids: sche[p].skids, day: newOrder_1.data().day }))];
+                    case 22:
+                        _a.sent();
+                        _a.label = 23;
+                    case 23:
+                        p++;
+                        return [3, 19];
+                    case 24:
+                        if (!(p < toBeReplaced.length)) return [3, 26];
+                        return [4, ScheduledRun_2.default.deleteId(toBeReplaced[p].id, space)];
+                    case 25:
+                        _a.sent();
+                        return [3, 24];
+                    case 26: return [3, 28];
+                    case 27:
+                        error_7 = _a.sent();
+                        console.log("error while adding to dispatch", error_7);
+                        throw error_7;
+                    case 28: return [2];
+                }
+            });
+        }); };
+    }
+    return Dispatch;
+}());
+exports.default = Dispatch;
+//# sourceMappingURL=Dispatch.js.map