@golemio/pid 5.0.0-rc.2095893792 → 5.0.0-rc.2149588470

package/dist/integration-engine/vehicle-positions/workers/vehicle-descriptors/data-access/DescriptorRepository.js

@@ -37,14 +37,15 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 var DescriptorRepository_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DescriptorRepository = void 0;
+const RepositoryUtils_1 = require("../../../../shared/RepositoryUtils");
 const const_1 = require("../../../../../schema-definitions/const");
 const models_1 = require("../../../../../schema-definitions/vehicle-descriptors/models");
+const CoreToken_1 = require("@golemio/core/dist/helpers/ioc/CoreToken");
 const models_2 = require("@golemio/core/dist/integration-engine/models");
 const golemio_errors_1 = require("@golemio/core/dist/shared/golemio-errors");
 const golemio_validator_1 = require("@golemio/core/dist/shared/golemio-validator");
 const sequelize_1 = __importStar(require("@golemio/core/dist/shared/sequelize"));
 const tsyringe_1 = require("@golemio/core/dist/shared/tsyringe");
-const CoreToken_1 = require("@golemio/core/dist/helpers/ioc/CoreToken");
 let DescriptorRepository = exports.DescriptorRepository = DescriptorRepository_1 = class DescriptorRepository extends models_2.PostgresModel {
     constructor(logger) {
         super(DescriptorRepository_1.REPOSITORY_NAME, {
@@ -83,7 +84,7 @@ let DescriptorRepository = exports.DescriptorRepository = DescriptorRepository_1
             throw new golemio_errors_1.GeneralError("findAccessDescByRegistrationNumbers: failed to get descriptors", this.name, err);
         }
     }
-    async saveData(descriptors) {
+    async refreshData(descriptors) {
         let transaction;
         try {
             await this.validate(descriptors);
@@ -97,10 +98,8 @@ let DescriptorRepository = exports.DescriptorRepository = DescriptorRepository_1
             await transaction?.commit();
         }
         catch (err) {
-            const exception = new golemio_errors_1.GeneralError(`[${this.constructor.name}] Could not save data: ${err.message}`, this.constructor.name, err);
-            this.logger.error(exception);
             await transaction?.rollback();
-            throw exception;
+            RepositoryUtils_1.RepositoryUtils.mapSequelizeError(err, this.constructor.name, "refreshData");
         }
     }
 };

package/dist/integration-engine/vehicle-positions/workers/vehicle-descriptors/data-access/DescriptorRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"DescriptorRepository.js","sourceRoot":"","sources":["../../../../../../src/integration-engine/vehicle-positions/workers/vehicle-descriptors/data-access/DescriptorRepository.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"DescriptorRepository.js","sourceRoot":"","sources":["../../../../../../src/integration-engine/vehicle-positions/workers/vehicle-descriptors/data-access/DescriptorRepository.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,wEAA6D;AAC7D,mEAAuC;AACvC,yFAAkE;AAElE,wEAAqE;AAErE,yEAAqF;AACrF,6EAAwE;AACxE,mFAAkF;AAClF,iFAAiF;AACjF,iEAAwE;AAGjE,IAAM,oBAAoB,2DAA1B,MAAM,oBAAqB,SAAQ,sBAAa;IAGnD,YAAsC,MAAuB;QACzD,KAAK,CACD,sBAAoB,CAAC,eAAe,EACpC;YACI,WAAW,EAAE,wBAAe,CAAC,SAAS;YACtC,QAAQ,EAAE,iBAAS;YACnB,yBAAyB,EAAE,wBAAe,CAAC,cAAc;YACzD,UAAU,EAAE,gBAAgB;SAC/B,EACD,IAAI,uCAAmB,CAAC,sBAAoB,CAAC,eAAe,GAAG,WAAW,EAAE,wBAAe,CAAC,eAAe,CAAC,CAC/G,CAAC;QAVwC,WAAM,GAAN,MAAM,CAAS;QAkDtD,wBAAmB,GAAG,KAAK,EAAE,KAAa,EAAmB,EAAE;YAClE,IAAI;gBACA,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;oBACrC,KAAK,EAAE;wBACH,UAAU,EAAE;4BACR,CAAC,cAAE,CAAC,EAAE,CAAC,EAAE,mBAAS,CAAC,OAAO,CAAC,qBAAqB,KAAK,SAAS,CAAC;yBAClE;qBACJ;iBACJ,CAAC,CAAC;aACN;YAAC,OAAO,GAAG,EAAE;gBACV,MAAM,IAAI,6BAAY,CAAC,8BAA8B,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;aACtF;QACL,CAAC,CAAC;IAnDF,CAAC;IAEM,KAAK,CAAC,mCAAmC,CAC5C,mBAA6B,EAC7B,aAAgC;QAEhC,IAAI;YACA,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAkB;gBACtD,UAAU,EAAE,CAAC,0BAA0B,EAAE,qBAAqB,CAAC;gBAC/D,KAAK,EAAE;oBACH,mBAAmB,EAAE,mBAAmB;oBACxC,eAAe,EAAE,aAAa;iBACjC;aACJ,CAAC,CAAC;SACN;QAAC,OAAO,GAAG,EAAE;YACV,MAAM,IAAI,6BAAY,CAAC,gEAAgE,EAAE,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;SAC5G;IACL,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,WAAmC;QACxD,IAAI,WAAoC,CAAC;QAEzC,IAAI;YACA,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YAEjC,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC;YACjE,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;YAC9D,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAkB,WAAW,EAAE;gBAC/D,gBAAgB,EAAE,IAAI;gBACtB,SAAS,EAAE,KAAK;gBAChB,WAAW;aACd,CAAC,CAAC;YACH,MAAM,WAAW,EAAE,MAAM,EAAE,CAAC;SAC/B;QAAC,OAAO,GAAG,EAAE;YACV,MAAM,WAAW,EAAE,QAAQ,EAAE,CAAC;YAC9B,iCAAe,CAAC,iBAAiB,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;SAChF;IACL,CAAC;;AAlDc,oCAAe,GAAG,wBAAwB,AAA3B,CAA4B;+BADjD,oBAAoB;IADhC,IAAA,qBAAU,GAAE;IAII,WAAA,IAAA,iBAAM,EAAC,qBAAS,CAAC,MAAM,CAAC,CAAA;;GAH5B,oBAAoB,CAkEhC"}

package/dist/integration-engine/vehicle-positions/workers/vehicle-descriptors/tasks/RefreshDescriptorsTask.js

@@ -41,7 +41,7 @@ let RefreshDescriptorsTask = exports.RefreshDescriptorsTask = class RefreshDescr
             this.logger.warn(`${this.queueName}: no descriptors out of ${descriptorsResult.length} were transformed or were filtered out`);
             return;
         }
-        await this.descriptorRepository.saveData(descriptorsFiltered);
+        await this.descriptorRepository.refreshData(descriptorsFiltered);
         this.logger.info(`${this.queueName}: ${descriptorsFiltered.length}/${descriptorsResult.length} vehicle descriptors were saved`);
     }
 };

package/dist/integration-engine/vehicle-positions/workers/vehicle-descriptors/tasks/RefreshDescriptorsTask.js.map

@@ -1 +1 @@
-{"version":3,"file":"RefreshDescriptorsTask.js","sourceRoot":"","sources":["../../../../../../src/integration-engine/vehicle-positions/workers/vehicle-descriptors/tasks/RefreshDescriptorsTask.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,oEAA8E;AAG9E,8EAA0E;AAC1E,6FAA0F;AAC1F,iEAAwE;AACxE,4CAA2C;AAC3C,8EAA2E;AAC3E,4FAA6G;AAE7G,0FAAuF;AAGhF,IAAM,sBAAsB,oCAA5B,MAAM,sBAAuB,SAAQ,sCAAiB;IAIzD,YAEI,iBAAsD,EAEtD,gBAA2C,EAE3C,oBAAkD,EAElD,wBAA0D,EAC3B,MAAuB;QAEtD,KAAK,CAAC,uBAAW,CAAC,CAAC;QATX,sBAAiB,GAAjB,iBAAiB,CAA6B;QAE9C,qBAAgB,GAAhB,gBAAgB,CAAmB;QAEnC,yBAAoB,GAApB,oBAAoB,CAAsB;QAE1C,6BAAwB,GAAxB,wBAAwB,CAA0B;QACnB,WAAM,GAAN,MAAM,CAAS;QAZ1C,cAAS,GAAG,oBAAoB,CAAC;QACjC,aAAQ,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,aAAa;IAcxD,CAAC;IAES,KAAK,CAAC,OAAO;QACnB,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,gDAAkB,CAAC,cAAc,CAAC,CAAC;QAC3F,MAAM,iBAAiB,GAAG,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC;QACpD,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;QAChG,MAAM,mBAAmB,GAAG,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,wBAAwB,CAAC,sBAAsB,CAAC,CAAC,CAAC;QAExG,IAAI,mBAAmB,CAAC,MAAM,KAAK,CAAC,EAAE;YAClC,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ,GAAG,IAAI,CAAC,SAAS,2BAA2B,iBAAiB,CAAC,MAAM,wCAAwC,CAC/G,CAAC;YACF,OAAO;SACV;QAED,MAAM,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;QAC9D,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ,GAAG,IAAI,CAAC,SAAS,KAAK,mBAAmB,CAAC,MAAM,IAAI,iBAAiB,CAAC,MAAM,iCAAiC,CAChH,CAAC;IACN,CAAC;CACJ,CAAA;iCApCY,sBAAsB;IADlC,IAAA,qBAAU,GAAE;IAMJ,WAAA,IAAA,iBAAM,EAAC,mCAAgB,CAAC,2BAA2B,CAAC,CAAA;IAEpD,WAAA,IAAA,iBAAM,EAAC,mCAAgB,CAAC,gBAAgB,CAAC,CAAA;IAEzC,WAAA,IAAA,iBAAM,EAAC,mCAAgB,CAAC,oBAAoB,CAAC,CAAA;IAE7C,WAAA,IAAA,iBAAM,EAAC,mCAAgB,CAAC,wBAAwB,CAAC,CAAA;IAEjD,WAAA,IAAA,iBAAM,EAAC,+BAAc,CAAC,MAAM,CAAC,CAAA;qCAPH,yDAA2B,UAIxB,2CAAoB;QAEhB,mDAAwB;GAZrD,sBAAsB,CAoClC"}
+{"version":3,"file":"RefreshDescriptorsTask.js","sourceRoot":"","sources":["../../../../../../src/integration-engine/vehicle-positions/workers/vehicle-descriptors/tasks/RefreshDescriptorsTask.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,oEAA8E;AAE9E,8EAA0E;AAC1E,6FAA0F;AAC1F,iEAAwE;AACxE,4CAA2C;AAC3C,8EAA2E;AAC3E,4FAA6G;AAE7G,0FAAuF;AAGhF,IAAM,sBAAsB,oCAA5B,MAAM,sBAAuB,SAAQ,sCAAiB;IAIzD,YAEI,iBAAsD,EAEtD,gBAA2C,EAE3C,oBAAkD,EAElD,wBAA0D,EAC3B,MAAuB;QAEtD,KAAK,CAAC,uBAAW,CAAC,CAAC;QATX,sBAAiB,GAAjB,iBAAiB,CAA6B;QAE9C,qBAAgB,GAAhB,gBAAgB,CAAmB;QAEnC,yBAAoB,GAApB,oBAAoB,CAAsB;QAE1C,6BAAwB,GAAxB,wBAAwB,CAA0B;QACnB,WAAM,GAAN,MAAM,CAAS;QAZ1C,cAAS,GAAG,oBAAoB,CAAC;QACjC,aAAQ,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,aAAa;IAcxD,CAAC;IAES,KAAK,CAAC,OAAO;QACnB,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC,gDAAkB,CAAC,cAAc,CAAC,CAAC;QAC3F,MAAM,iBAAiB,GAAG,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC;QACpD,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAC;QAChG,MAAM,mBAAmB,GAAG,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,wBAAwB,CAAC,sBAAsB,CAAC,CAAC,CAAC;QAExG,IAAI,mBAAmB,CAAC,MAAM,KAAK,CAAC,EAAE;YAClC,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ,GAAG,IAAI,CAAC,SAAS,2BAA2B,iBAAiB,CAAC,MAAM,wCAAwC,CAC/G,CAAC;YACF,OAAO;SACV;QAED,MAAM,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC;QACjE,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ,GAAG,IAAI,CAAC,SAAS,KAAK,mBAAmB,CAAC,MAAM,IAAI,iBAAiB,CAAC,MAAM,iCAAiC,CAChH,CAAC;IACN,CAAC;CACJ,CAAA;iCApCY,sBAAsB;IADlC,IAAA,qBAAU,GAAE;IAMJ,WAAA,IAAA,iBAAM,EAAC,mCAAgB,CAAC,2BAA2B,CAAC,CAAA;IAEpD,WAAA,IAAA,iBAAM,EAAC,mCAAgB,CAAC,gBAAgB,CAAC,CAAA;IAEzC,WAAA,IAAA,iBAAM,EAAC,mCAAgB,CAAC,oBAAoB,CAAC,CAAA;IAE7C,WAAA,IAAA,iBAAM,EAAC,mCAAgB,CAAC,wBAAwB,CAAC,CAAA;IAEjD,WAAA,IAAA,iBAAM,EAAC,+BAAc,CAAC,MAAM,CAAC,CAAA;qCAPH,yDAA2B,UAIxB,2CAAoB;QAEhB,mDAAwB;GAZrD,sBAAsB,CAoClC"}

package/dist/integration-engine/vehicle-positions/workers/vehicle-positions/helpers/DelayComputationManager.d.ts

@@ -12,7 +12,11 @@ export declare class DelayComputationManager {
      * @param {string} tripId - Internal DB trip id
      * @returns {IComputationTrip} - Result with shape anchor points
      */
-    getComputationObject: (tripId: string) => Promise<IComputationTrip | null>;
+    getComputationObject(tripId: string): Promise<IComputationTrip | null>;
+    private roundToDecimals;
+    private shouldReadCoordsFromPrevPoint;
+    private setupBearingBetweenPoints;
+    private shapePointCompareDistance;
     /**
      * Return geometry of anchor points with distance from start along trip track shape
      *
@@ -22,6 +26,7 @@ export declare class DelayComputationManager {
      * @returns {IShapeGeometryAnchorPoint[]} - Result array of geometry points along trip track shape
      */
     private getShapesGeometryAnchorPoints;
+    private getAnchorPointProps;
     /**
      * Generate new shape points from segment of trip shape along original one
      *   - preserving start and end shape points belonging to stops

package/dist/integration-engine/vehicle-positions/workers/vehicle-positions/helpers/DelayComputationManager.js

@@ -34,257 +34,309 @@ class DelayComputationManager {
     constructor(gtfsTripsRepository) {
         this.gtfsTripsRepository = gtfsTripsRepository;
         this.METRO_TRIP_PREFIX_REGEX = /^(991|992|993)/;
-        /**
-         * Return shape anchor points along trip track shape with stop times parameters
-         *
-         * @param {string} tripId - Internal DB trip id
-         * @returns {IComputationTrip} - Result with shape anchor points
-         */
-        this.getComputationObject = async (tripId) => {
-            const gtfsTrip = await this.gtfsTripsRepository.findByIdForDelayComputation(tripId);
-            if (!gtfsTrip) {
-                helpers_1.log.info(`getComputationObject: GTFS trip ${tripId} was not found`);
-                return null;
+        const simpleConfig = ioc_1.IntegrationEngineContainer.resolve(CoreToken_1.CoreToken.SimpleConfig);
+        this.stepBetweenPoints = config_1.config.vehiclePositions.stepBetweenPoints;
+        this.stepBetweenPointsforMetro = Number(simpleConfig.getValue("module.pid.vehicle-positions.shapes.metro.stepBetweenPointsForMetro", "0.05"));
+    }
+    /**
+     * Return shape anchor points along trip track shape with stop times parameters
+     *
+     * @param {string} tripId - Internal DB trip id
+     * @returns {IComputationTrip} - Result with shape anchor points
+     */
+    async getComputationObject(tripId) {
+        const gtfsTrip = await this.gtfsTripsRepository.findByIdForDelayComputation(tripId);
+        if (!gtfsTrip) {
+            helpers_1.log.info(`getComputationObject: GTFS trip ${tripId} was not found`);
+            return null;
+        }
+        const { shape_id, shapes, stop_times } = gtfsTrip;
+        if (!shapes?.length) {
+            throw new golemio_errors_1.GeneralError(`getComputationObject: GTFS trip ${tripId} has no shapes`, this.constructor.name);
+        }
+        else if (!stop_times?.length) {
+            throw new golemio_errors_1.GeneralError(`getComputationObject: GTFS trip ${tripId} has no stop_times`, this.constructor.name);
+        }
+        const isMetro = this.METRO_TRIP_PREFIX_REGEX.test(tripId);
+        const shapesGeometryAnchorPoints = this.getShapesGeometryAnchorPoints(shape_id, shapes, stop_times, isMetro);
+        // MAKING COPY
+        const shapePoints = [];
+        const lastPointIndex = shapesGeometryAnchorPoints.length - 1;
+        // const to determine shape points of stops (in meters)
+        const distanceBefore = 0.1;
+        const distanceAfter = 0.05;
+        for (let i = 0; i < shapesGeometryAnchorPoints.length; i++) {
+            const isLastPoint = i === lastPointIndex;
+            const bearing = this.setupBearingBetweenPoints(i, shapesGeometryAnchorPoints, shapePoints, isLastPoint);
+            // init values
+            let thisStopSequence = null;
+            let lastStopSequence = shapesGeometryAnchorPoints[i].last_stop_sequence;
+            let nextStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
+            // these are origin stop_times shape point fron shapes table, clearly at stops points
+            if (shapesGeometryAnchorPoints[i].this_stop_sequence) {
+                thisStopSequence = shapesGeometryAnchorPoints[i].this_stop_sequence;
             }
-            const { shape_id, shapes, stop_times } = gtfsTrip;
-            if (!shapes?.length) {
-                throw new golemio_errors_1.GeneralError(`getComputationObject: GTFS trip ${tripId} has no shapes`, this.constructor.name);
+            // if is shape anchor point in close distance AFTER LAST stop, then set it also AT STOP
+            else if (i > 0 &&
+                shapesGeometryAnchorPoints[i].shape_dist_traveled -
+                    stop_times[shapesGeometryAnchorPoints[i].last_stop_sequence - 1].shape_dist_traveled <=
+                    distanceAfter) {
+                thisStopSequence = shapesGeometryAnchorPoints[i].last_stop_sequence;
             }
-            else if (!stop_times?.length) {
-                throw new golemio_errors_1.GeneralError(`getComputationObject: GTFS trip ${tripId} has no stop_times`, this.constructor.name);
+            // if is shape anchor point in close distance BEFORE NEXT stop, then set it also AT STOP
+            else if (i < shapesGeometryAnchorPoints.length - 1 &&
+                stop_times[shapesGeometryAnchorPoints[i].next_stop_sequence - 1].shape_dist_traveled -
+                    shapesGeometryAnchorPoints[i].shape_dist_traveled <=
+                    distanceBefore) {
+                thisStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
+                lastStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
+                nextStopSequence = Math.min(shapesGeometryAnchorPoints[i].next_stop_sequence + 1, stop_times.length);
             }
-            const isMetro = this.METRO_TRIP_PREFIX_REGEX.test(tripId);
-            const shapesGeometryAnchorPoints = this.getShapesGeometryAnchorPoints(shape_id, shapes, stop_times, isMetro);
-            // MAKING COPY
-            const shapePoints = [];
-            // const to determine shape points of stops (in meters)
-            const distanceBefore = 0.1;
-            const distanceAfter = 0.05;
-            for (let i = 0; i < shapesGeometryAnchorPoints.length; i++) {
-                let bearing = 0;
-                // add bearing from shape computed for previous shapePoint
-                if (i > 0) {
-                    // compute bearing from two shape points
-                    let shapePointBearing = Math.round(turf.bearing(turf.point(shapesGeometryAnchorPoints[i - 1].coordinates), turf.point(shapesGeometryAnchorPoints[i].coordinates)));
-                    // turf.bearing returns -180 to 180, when 0 is north
-                    // we need 0 to 359, for negative value we substract from 360
-                    if (shapePointBearing < 0) {
-                        shapePointBearing = 360 - Math.abs(shapePointBearing);
-                    }
-                    // save bearing
-                    shapePoints[i - 1].bearing = shapePointBearing;
-                    // for the last shapePoint copy the bearing from last one
-                    if (shapesGeometryAnchorPoints.length - 1 === i) {
-                        bearing = shapePoints[i - 1].bearing;
-                    }
-                }
-                // init values
-                let thisStopSequence = null;
-                let lastStopSequence = shapesGeometryAnchorPoints[i].last_stop_sequence;
-                let nextStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
-                // these are origin stop_times shape point fron shapes table, clearly at stops points
-                if (shapesGeometryAnchorPoints[i].this_stop_sequence) {
-                    thisStopSequence = shapesGeometryAnchorPoints[i].this_stop_sequence;
-                }
-                // if is shape anchor point in close distance AFTER LAST stop, then set it also AT STOP
-                else if (i > 0 &&
-                    shapesGeometryAnchorPoints[i].shape_dist_traveled -
-                        stop_times[shapesGeometryAnchorPoints[i].last_stop_sequence - 1].shape_dist_traveled <=
-                        distanceAfter) {
-                    thisStopSequence = shapesGeometryAnchorPoints[i].last_stop_sequence;
-                }
-                // if is shape anchor point in close distance BEFORE NEXT stop, then set it also AT STOP
-                else if (i < shapesGeometryAnchorPoints.length - 1 &&
-                    stop_times[shapesGeometryAnchorPoints[i].next_stop_sequence - 1].shape_dist_traveled -
-                        shapesGeometryAnchorPoints[i].shape_dist_traveled <=
-                        distanceBefore) {
-                    thisStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
-                    lastStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
-                    nextStopSequence = Math.min(shapesGeometryAnchorPoints[i].next_stop_sequence + 1, stop_times.length);
-                }
-                let shapeDistTraveled = shapesGeometryAnchorPoints[i].shape_dist_traveled;
-                let distanceFromLastStop;
-                // fallback to shape_dist_traveled from GTFS stop_times, if the vehicle is at stop
-                // and set distance from last stop to 0 (the stop is literally at stop)
-                if (thisStopSequence !== null) {
-                    shapeDistTraveled = stop_times[thisStopSequence - 1].shape_dist_traveled;
-                    distanceFromLastStop = 0;
-                }
-                else {
-                    distanceFromLastStop =
-                        Math.round((shapeDistTraveled - stop_times[lastStopSequence - 1].shape_dist_traveled) * 1000) / 1000;
-                }
-                // if is trip at stop than set departure by this stop
-                // between stops do linear interpolation from departure from last stop and arrival of next stop
-                const timeScheduledSeconds = thisStopSequence !== null
-                    ? stop_times[lastStopSequence - 1].arrival_time_seconds
-                    : stop_times[lastStopSequence - 1].departure_time_seconds +
-                        Math.round(((stop_times[nextStopSequence - 1].arrival_time_seconds -
-                            stop_times[lastStopSequence - 1].departure_time_seconds) *
-                            distanceFromLastStop) /
-                            (stop_times[nextStopSequence - 1].shape_dist_traveled -
-                                stop_times[lastStopSequence - 1].shape_dist_traveled));
-                shapePoints.push({
-                    index: i,
-                    at_stop: thisStopSequence !== null,
-                    bearing,
-                    coordinates: shapesGeometryAnchorPoints[i].coordinates,
-                    distance_from_last_stop: distanceFromLastStop,
-                    last_stop_sequence: lastStopSequence,
-                    next_stop_sequence: nextStopSequence,
-                    shape_dist_traveled: shapeDistTraveled,
-                    this_stop_sequence: thisStopSequence,
-                    time_scheduled_seconds: timeScheduledSeconds,
-                });
+            let shapeDistTraveled = shapesGeometryAnchorPoints[i].shape_dist_traveled;
+            let distanceFromLastStop;
+            // fallback to shape_dist_traveled from GTFS stop_times, if the vehicle is at stop
+            // and set distance from last stop to 0 (the stop is literally at stop)
+            if (thisStopSequence !== null) {
+                shapeDistTraveled = stop_times[thisStopSequence - 1].shape_dist_traveled;
+                distanceFromLastStop = 0;
             }
-            return {
-                trip_id: tripId,
-                stop_times: stop_times,
-                shapes_anchor_points: shapePoints,
-                shapes: this.mapGtfsShapesToTripShapes(shapes),
-            };
+            else {
+                distanceFromLastStop = this.roundToDecimals(shapeDistTraveled - stop_times[lastStopSequence - 1].shape_dist_traveled, 1000);
+            }
+            // if is trip at stop than set departure by this stop
+            // between stops do linear interpolation from departure from last stop and arrival of next stop
+            const timeScheduledSeconds = thisStopSequence !== null
+                ? stop_times[lastStopSequence - 1].arrival_time_seconds
+                : stop_times[lastStopSequence - 1].departure_time_seconds +
+                    Math.round(((stop_times[nextStopSequence - 1].arrival_time_seconds -
+                        stop_times[lastStopSequence - 1].departure_time_seconds) *
+                        distanceFromLastStop) /
+                        (stop_times[nextStopSequence - 1].shape_dist_traveled -
+                            stop_times[lastStopSequence - 1].shape_dist_traveled));
+            shapePoints.push({
+                index: i,
+                at_stop: thisStopSequence !== null,
+                bearing,
+                coordinates: shapesGeometryAnchorPoints[i].coordinates,
+                distance_from_last_stop: distanceFromLastStop,
+                last_stop_sequence: lastStopSequence,
+                next_stop_sequence: nextStopSequence,
+                shape_dist_traveled: shapeDistTraveled,
+                this_stop_sequence: thisStopSequence,
+                time_scheduled_seconds: timeScheduledSeconds,
+            });
+        }
+        return {
+            trip_id: tripId,
+            stop_times: stop_times,
+            shapes_anchor_points: shapePoints,
+            shapes: this.mapGtfsShapesToTripShapes(shapes),
         };
-        /**
-         * Return geometry of anchor points with distance from start along trip track shape
-         *
-         * @param {string} shapeId - GTFS shape id
-         * @param {ITransformedTripShape[]} shapes - GTFS shape points
-         * @param {IStopTime[]} stops
-         * @returns {IShapeGeometryAnchorPoint[]} - Result array of geometry points along trip track shape
-         */
-        this.getShapesGeometryAnchorPoints = (shapeId, shapes, stops, isMetro = false) => {
-            try {
-                let segmentShapes = [];
-                // Splits shapes array to multiple arrays "delimited" by stops
-                for (let st = 0; st < stops.length; st++) {
-                    let currentSegment = [];
-                    for (let sh = 0; sh < shapes.length; sh++) {
-                        let shapePoint = { ...shapes[sh], shape_at_stop: false };
-                        if (stops[st].shape_dist_traveled === shapes[sh].shape_dist_traveled) {
-                            shapePoint.shape_at_stop = true;
-                        }
-                        if (st < stops.length - 1 &&
-                            shapePoint.shape_dist_traveled >= stops[st].shape_dist_traveled &&
-                            shapePoint.shape_dist_traveled <= stops[st + 1].shape_dist_traveled) {
-                            currentSegment.push(shapePoint);
-                        }
+    }
+    roundToDecimals(n, fraction = 100000) {
+        return Math.round(n * fraction) / fraction;
+    }
+    shouldReadCoordsFromPrevPoint(points, i) {
+        if (i <= 1) {
+            return false;
+        }
+        return (points[i].coordinates[0] === points[i - 1].coordinates[0] && points[i].coordinates[1] === points[i - 1].coordinates[1]);
+    }
+    setupBearingBetweenPoints(index, source, target, isLast) {
+        // add bearing from shape computed for previous shapePoint
+        if (index === 0) {
+            return 0;
+        }
+        let bearing;
+        if (index > 1 && source[index - 1].this_stop_sequence && !source[index].this_stop_sequence) {
+            // Was the previous point at_stop? We'll ignore any bearing computation,
+            // it would point possibly to the after stop segment, usually behind a cross
+            // or after a curve. Thus we'll use the at_stop's incoming (prev point) bearing,
+            // because vehicle stays at_stop for some time, then it starts moving
+            // and we compute bearing in the 1st point after the stop in next iteration
+            return target[index - 1].bearing;
+        }
+        if (this.shouldReadCoordsFromPrevPoint(source, index)) {
+            // take bearing of the previous point (i - 1),
+            // as long as current point and prev. point have same coords
+            // ... to be saved into previous point (i - 1)
+            bearing = target[index - 1].bearing;
+        }
+        else {
+            // compute bearing from two shape points
+            bearing = turf.bearing(turf.point(source[index - 1].coordinates), turf.point(source[index].coordinates));
+        }
+        // turf.bearing returns -180 to 180, when 0 is north
+        // we need 0 to 359 => modulo 360
+        bearing = Math.round((360 + bearing) % 360);
+        // save bearing
+        target[index - 1].bearing = bearing;
+        // for the last shapePoint copy the bearing from last computed one
+        if (isLast) {
+            bearing = target[index - 1].bearing;
+        }
+        return bearing;
+    }
+    shapePointCompareDistance(point, currentStop, nextStop) {
+        if (currentStop.shape_dist_traveled === point.shape_dist_traveled) {
+            point.shape_at_stop = true;
+        }
+        if (nextStop) {
+            if (point.shape_dist_traveled >= currentStop.shape_dist_traveled &&
+                point.shape_dist_traveled <= nextStop.shape_dist_traveled) {
+                // current segment
+                return 0;
+            }
+            else if (point.shape_dist_traveled > nextStop.shape_dist_traveled) {
+                // future segment
+                return 1;
+            }
+        }
+        // previous stop segment OR missing nextStop (currentStop is last stop)
+        return -1;
+    }
+    /**
+     * Return geometry of anchor points with distance from start along trip track shape
+     *
+     * @param {string} shapeId - GTFS shape id
+     * @param {ITransformedTripShape[]} shapes - GTFS shape points
+     * @param {IStopTime[]} stops
+     * @returns {IShapeGeometryAnchorPoint[]} - Result array of geometry points along trip track shape
+     */
+    getShapesGeometryAnchorPoints(shapeId, shapes, stops, isMetro = false) {
+        try {
+            let segmentShapes = [];
+            // Splits shapes array to multiple arrays "delimited" by stops
+            let startShapeIndex = 0;
+            for (let st = 0; st < stops.length; st++) {
+                const currentSegment = [];
+                for (let sh = startShapeIndex; sh < shapes.length; sh++) {
+                    const shapePoint = { ...shapes[sh], shape_at_stop: false };
+                    const shapePointSituation = this.shapePointCompareDistance(shapePoint, stops[st], stops[st + 1]);
+                    if (shapePointSituation === 0) {
+                        // next stop iteration (outer for-cycle) can be shorter
+                        startShapeIndex = sh;
+                        // each segment starts with "at_stop=true" point
+                        currentSegment.push(shapePoint);
                     }
-                    if (currentSegment.length) {
-                        segmentShapes.push(currentSegment);
+                    else if (shapePointSituation === 1) {
+                        // no need to iterate over all future stops segments
+                        break;
                     }
                 }
-                let segmentArr = [];
-                // concat arrays of stop divided segments with distributed shape points
-                for (const segment of segmentShapes) {
-                    segmentArr = [
-                        ...segmentArr,
-                        ...this.divideSegmentLine(segment, isMetro ? this.stepBetweenPointsforMetro : this.stepBetweenPoints),
-                    ];
+                if (currentSegment.length) {
+                    segmentShapes.push(currentSegment);
                 }
-                // Make initial shapesGeometryAnchorPoints
-                let stopCounter = 0;
-                const resultArr = segmentArr.map((segment, index) => {
-                    let this_stop_sequence;
-                    let last_stop_sequence;
-                    let next_stop_sequence;
-                    if (segment.shape_at_stop) {
-                        stopCounter++;
-                        this_stop_sequence = stopCounter;
-                    }
-                    else {
-                        this_stop_sequence = null;
-                    }
-                    last_stop_sequence = stopCounter;
-                    next_stop_sequence = stopCounter + 1;
-                    return {
-                        index,
-                        coordinates: [
-                            Math.round(segment.shape_pt_lon * 100000) / 100000,
-                            Math.round(segment.shape_pt_lat * 100000) / 100000,
-                        ],
-                        last_stop_sequence,
-                        next_stop_sequence,
-                        shape_dist_traveled: Math.round(segment.shape_dist_traveled * 1000) / 1000,
-                        this_stop_sequence,
-                    };
-                });
-                stopCounter++;
-                // and lastly shape point for last stop as there is no segment for last stop
-                resultArr.push({
-                    index: resultArr.length,
-                    coordinates: [
-                        Math.round(shapes[shapes.length - 1].shape_pt_lon * 100000) / 100000,
-                        Math.round(shapes[shapes.length - 1].shape_pt_lat * 100000) / 100000,
-                    ],
-                    last_stop_sequence: stopCounter,
-                    next_stop_sequence: stopCounter,
-                    shape_dist_traveled: Math.round(shapes[shapes.length - 1].shape_dist_traveled * 1000) / 1000,
-                    this_stop_sequence: stopCounter,
-                });
-                return resultArr;
             }
-            catch (err) {
-                helpers_1.log.error(err);
-                helpers_1.log.error(shapeId);
-                return [];
+            let segmentArr = [];
+            // concat arrays of stop divided segments with distributed shape points
+            for (const segment of segmentShapes) {
+                const line = this.divideSegmentLine(segment, isMetro ? this.stepBetweenPointsforMetro : this.stepBetweenPoints);
+                segmentArr.push(...line);
             }
-        };
-        /**
-         * Generate new shape points from segment of trip shape along original one
-         *   - preserving start and end shape points belonging to stops
-         *   - creates new set of shape points between stops to get same point distance along original shape
-         *
-         * @param {ISegmentShape[]} segmentsArr - Original shape points segment between two stops
-         * @param {number} distance - Minimal distance for two consequent shape points
-         * @returns {ISegmentShape[]} - Result array of new shape points
-         */
-        this.divideSegmentLine = (segmentArr, distance = config_1.config.vehiclePositions.stepBetweenPoints) => {
-            const shapeId = segmentArr[0].shape_id;
-            const shapeCount = segmentArr.length;
-            const startShapeDistTraveled = segmentArr[0].shape_dist_traveled;
-            const endShapeDistTraveled = segmentArr[shapeCount - 1].shape_dist_traveled;
-            const shapeDistLength = endShapeDistTraveled - startShapeDistTraveled;
-            const segmentLine = turf.lineString(segmentArr.map((s) => {
-                return [s.shape_pt_lon, s.shape_pt_lat];
-            }));
-            // because we dont believe source shape distances, rather compute length with turf.js
-            const segmentLength = turf.length(segmentLine);
-            const middlePointsCount = Math.floor(segmentLength / distance);
-            const distanceOffset = (segmentLength - distance * middlePointsCount) / 2;
-            // put first shape point
-            const resultSegmentPoints = [
-                {
-                    ...segmentArr[0],
-                    shape_pt_sequence: 1,
-                },
-            ];
-            // for each middle point create acording shape point with interpolated origin shape dist traveled
-            for (let i = 0; i < middlePointsCount; i++) {
-                const currentDistance = i * distance + distanceOffset;
-                const currentDistDistance = (shapeDistLength / segmentLength) * currentDistance;
-                const newPoint = turf.along(segmentLine, i * distance + distanceOffset);
-                resultSegmentPoints.push({
-                    shape_id: shapeId,
-                    shape_at_stop: false,
-                    shape_pt_sequence: resultSegmentPoints.length + 1,
-                    shape_pt_lat: newPoint.geometry.coordinates[1],
-                    shape_pt_lon: newPoint.geometry.coordinates[0],
-                    shape_dist_traveled: startShapeDistTraveled + currentDistDistance,
-                });
-            }
-            return resultSegmentPoints;
-        };
-        this.mapGtfsShapesToTripShapes = (shapes) => {
-            return shapes.map((shape) => {
+            // Make initial shapesGeometryAnchorPoints
+            let stopCounter = 0;
+            const resultArr = segmentArr.map((segment, index) => {
+                let this_stop_sequence;
+                if (segment.shape_at_stop) {
+                    stopCounter++;
+                    this_stop_sequence = stopCounter;
+                }
+                else {
+                    this_stop_sequence = null;
+                }
                 return {
-                    dist: shape.shape_dist_traveled,
-                    coords: [shape.shape_pt_lon, shape.shape_pt_lat],
+                    index,
+                    ...this.getAnchorPointProps(segment.shape_pt_lon, segment.shape_pt_lat, stopCounter, stopCounter + 1, segment.shape_dist_traveled),
+                    this_stop_sequence,
                 };
             });
+            stopCounter++;
+            // and lastly shape point for last stop as there is no segment for last stop
+            resultArr.push({
+                index: resultArr.length,
+                ...this.getAnchorPointProps(shapes[shapes.length - 1].shape_pt_lon, shapes[shapes.length - 1].shape_pt_lat, stopCounter, stopCounter, shapes[shapes.length - 1].shape_dist_traveled),
+                this_stop_sequence: stopCounter,
+            });
+            return resultArr;
+        }
+        catch (err) {
+            helpers_1.log.error(err);
+            helpers_1.log.error(shapeId);
+            return [];
+        }
+    }
+    getAnchorPointProps(lon, lat, last, next, dist) {
+        return {
+            coordinates: [this.roundToDecimals(lon), this.roundToDecimals(lat)],
+            last_stop_sequence: last,
+            next_stop_sequence: next,
+            shape_dist_traveled: this.roundToDecimals(dist, 1000),
         };
-        const simpleConfig = ioc_1.IntegrationEngineContainer.resolve(CoreToken_1.CoreToken.SimpleConfig);
-        this.stepBetweenPoints = config_1.config.vehiclePositions.stepBetweenPoints;
-        this.stepBetweenPointsforMetro = Number(simpleConfig.getValue("module.pid.vehicle-positions.shapes.metro.stepBetweenPointsForMetro", "0.025"));
+    }
+    /**
+     * Generate new shape points from segment of trip shape along original one
+     *   - preserving start and end shape points belonging to stops
+     *   - creates new set of shape points between stops to get same point distance along original shape
+     *
+     * @param {ISegmentShape[]} segmentsArr - Original shape points segment between two stops
+     * @param {number} distance - Minimal distance for two consequent shape points
+     * @returns {ISegmentShape[]} - Result array of new shape points
+     */
+    divideSegmentLine(segmentArr, distance = config_1.config.vehiclePositions.stepBetweenPoints) {
+        const shapeId = segmentArr[0].shape_id;
+        const shapeCount = segmentArr.length;
+        const startShapeDistTraveled = segmentArr[0].shape_dist_traveled;
+        const endShapeDistTraveled = segmentArr[shapeCount - 1].shape_dist_traveled;
+        const shapeDistLength = endShapeDistTraveled - startShapeDistTraveled;
+        const segmentLine = turf.lineString(segmentArr.map((s) => {
+            return [s.shape_pt_lon, s.shape_pt_lat];
+        }));
+        // because we dont believe source shape distances, rather compute length with turf.js
+        const segmentLength = turf.length(segmentLine);
+        const middlePointsCount = Math.floor(segmentLength / distance);
+        const distanceOffset = (segmentLength - distance * middlePointsCount) / 2;
+        // put first shape point
+        const resultSegmentPoints = [
+            {
+                ...segmentArr[0],
+                shape_pt_sequence: 1,
+            },
+        ];
+        // for each middle point create acording shape point with interpolated origin shape dist traveled
+        for (let i = 0; i < middlePointsCount; i++) {
+            const currentDistance = i * distance + distanceOffset;
+            const currentDistDistance = (shapeDistLength / segmentLength) * currentDistance;
+            // There was an idea to skip possibly really small remaining shape distance
+            // to the first computed segment point... but it created possibly more issues
+            // with trams/buses having stops at crossings and having bearing into next point
+            // behind the crossing. Possibly investigate an option to compute points
+            // dynamically on a distance +- 50 meters apart between stops, not just shapes
+            // between stops (excluding next stop)
+            // const minimalDistanceLimit = distance / 10;
+            // if (currentDistDistance < minimalDistanceLimit) {
+            //     // point would be too close, skip it
+            //     // continue;
+            // }
+            const newPoint = turf.along(segmentLine, i * distance + distanceOffset);
+            resultSegmentPoints.push({
+                shape_id: shapeId,
+                shape_at_stop: false,
+                shape_pt_sequence: resultSegmentPoints.length + 1,
+                shape_pt_lat: this.roundToDecimals(newPoint.geometry.coordinates[1]),
+                shape_pt_lon: this.roundToDecimals(newPoint.geometry.coordinates[0]),
+                shape_dist_traveled: this.roundToDecimals(startShapeDistTraveled + currentDistDistance, 1000),
+            });
+        }
+        return resultSegmentPoints;
+    }
+    mapGtfsShapesToTripShapes(shapes) {
+        return shapes.map((shape) => {
+            return {
+                dist: shape.shape_dist_traveled,
+                coords: [shape.shape_pt_lon, shape.shape_pt_lat],
+            };
+        });
     }
 }
 exports.DelayComputationManager = DelayComputationManager;