@golemio/pid 2.1.13-dev.510658546 → 2.1.13

package/dist/integration-engine/vehicle-positions/VehiclePositionsWorker.js

@@ -27,6 +27,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -45,13 +52,12 @@ const helpers_1 = require("@golemio/core/dist/integration-engine/helpers");
 const models_1 = require("@golemio/core/dist/integration-engine/models");
 const workers_1 = require("@golemio/core/dist/integration-engine/workers");
 const ropid_gtfs_1 = require("../../schema-definitions/ropid-gtfs");
+const RopidGTFSTripsModel_1 = require("../ropid-gtfs/RopidGTFSTripsModel");
 const vehicle_positions_1 = require("../../schema-definitions/vehicle-positions");
+const _1 = require("./");
 const const_1 = require("../../const");
-const RopidGTFSTripsModel_1 = require("../ropid-gtfs/RopidGTFSTripsModel");
+const VehiclePositionsRunsTransformation_1 = require("./VehiclePositionsRunsTransformation");
 const RopidGTFSStopTimesModel_1 = require("../ropid-gtfs/RopidGTFSStopTimesModel");
-const models_2 = require("./models");
-const transformations_1 = require("./transformations");
-const VehiclePositionsUtils_1 = require("./VehiclePositionsUtils");
 var PositionHandlerEnum;
 (function (PositionHandlerEnum) {
     PositionHandlerEnum["TRACKING"] = "TRACKING";
@@ -103,11 +109,10 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 }
             }
             for (const key in chunks) {
-                const positions = transformedData.positions.filter((position) => chunks[key].includes(position.trips_id));
-                const updatedTrips = yield this.modelTrips.findAllAssocTripIds(chunks[key]);
+                const allIds = yield this.modelTrips.findAllAssocTripIds(chunks[key]);
                 yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateDelay", JSON.stringify({
-                    positions,
-                    updatedTrips,
+                    positions: transformedData.positions.filter((position) => chunks[key].includes(position.trips_id)),
+                    updatedTrips: allIds,
                 }));
             }
         });
@@ -126,7 +131,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
         this.updateGTFSTripId = (msg) => __awaiter(this, void 0, void 0, function* () {
             const inputData = JSON.parse(msg.content.toString());
             // unique ids in input data in key-value (id-positions) structure
-            let positionsByIds = {};
+            const positionsByIds = {};
             for (const position of inputData.positions) {
                 positionsByIds[position.trips_id] = position;
             }
@@ -135,13 +140,13 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 if (!trip.origin_route_name || !trip.sequence_id || !positionsByIds[trip.id].origin_timestamp)
                     return;
                 const timestampLast = (0, moment_timezone_1.default)(positionsByIds[trip.id].origin_timestamp).tz("Europe/Prague").format();
-                return this.setAndReturnScheduledTrips({
+                return this.getScheduledTrips({
                     route_id: trip.origin_route_name,
                     run_number: trip.sequence_id,
                     msg_last_timestamp: timestampLast,
                 });
             }));
-            // find gtfs data for each trip
+            // find for each trip gtfs data
             const promiseValues = yield Promise.all(inputData.trips.map((trip) => __awaiter(this, void 0, void 0, function* () {
                 try {
                     return yield this.modelTrips.findGTFSTripId(trip);
@@ -151,76 +156,35 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                     return err;
                 }
             })));
-            let existingTripsPromiseValues = [], existingTripsPromiseErrors = [];
             // filter only trips with found gtfs data
-            for (const trip of promiseValues) {
-                if (trip instanceof golemio_errors_1.CustomError) {
-                    existingTripsPromiseErrors.push(trip);
-                }
-                else if (trip instanceof Array) {
-                    existingTripsPromiseValues.push(...trip);
-                }
-                else if ((trip === null || trip === void 0 ? void 0 : trip.constructor) === Object) {
-                    existingTripsPromiseValues.push(trip);
-                }
-            }
-            let tripsByBlockId = {};
-            for (const trip of existingTripsPromiseValues) {
-                if (!trip.gtfs_block_id || !trip.gtfs_trip_id)
-                    continue;
-                if (!tripsByBlockId[trip.gtfs_block_id]) {
-                    tripsByBlockId[trip.gtfs_block_id] = new Set();
-                }
-                tripsByBlockId[trip.gtfs_block_id].add(trip.gtfs_trip_id);
-            }
-            // create cache for trip stops (grouped by block id)
-            const tripStopsSchedulesByBlockIds = yield Object.entries(tripsByBlockId).reduce((acc, [blockId, gtfsTripIds]) => __awaiter(this, void 0, void 0, function* () {
-                const tripStops = yield acc;
-                try {
-                    tripStops[blockId] = yield this.setAndReturnTripStopsSchedule(blockId, [...gtfsTripIds]);
-                }
-                catch (err) {
-                    helpers_1.IntegrationErrorHandler.handle(err);
-                }
-                return acc;
-            }), Promise.resolve({}));
+            const foundedTripsPromiseValues = [].concat(...promiseValues.filter((result) => !(result instanceof golemio_errors_1.CustomError)));
+            const foundedTripsPromiseErrors = promiseValues.filter((result) => result instanceof golemio_errors_1.CustomError);
             let currentPosition;
-            for (const trip of existingTripsPromiseValues) {
+            for (const trip of foundedTripsPromiseValues) {
                 if (positionsByIds[trip.id]) {
                     currentPosition = positionsByIds[trip.id];
-                    if (trip.gtfs_block_id) {
-                        // Determine current position tracking status
-                        currentPosition.tracking = VehiclePositionsUtils_1.VehiclePositionsUtils.determineTrackingStatus(trip.gtfs_trip_id, tripStopsSchedulesByBlockIds[trip.gtfs_block_id], currentPosition);
-                    }
-                    continue;
-                }
-                if (!currentPosition) {
-                    continue;
                 }
-                // Determine position duplication and new position tracking status
-                const { shouldCreateNewPosition, trackingStatus: newPositionTrackingStatus } = VehiclePositionsUtils_1.VehiclePositionsUtils.determineNewPositionTracking(tripStopsSchedulesByBlockIds[trip.gtfs_block_id], trip, currentPosition);
-                if (shouldCreateNewPosition) {
-                    // duplicate position with new created trip for second trip
+                else {
+                    // duplicate position with new created trip for second train trip
                     const newPosition = Object.assign({}, currentPosition);
                     newPosition.trips_id = trip.id;
-                    newPosition.tracking = newPositionTrackingStatus;
                     inputData.positions.push(newPosition);
                 }
             }
             yield this.modelPositions.save(inputData.positions);
             // successfully updated gtfs ids
-            for (let i = 0, chunkSize = 100, imax = existingTripsPromiseValues.length; i < imax; i += chunkSize) {
+            for (let i = 0, chunkSize = 100, imax = foundedTripsPromiseValues.length; i < imax; i += chunkSize) {
                 yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateDelay", JSON.stringify({
                     positions: [],
-                    updatedTrips: existingTripsPromiseValues.slice(i, i + chunkSize),
+                    updatedTrips: foundedTripsPromiseValues.slice(i, i + chunkSize),
                 }));
             }
             // gtfsId updating errors
-            for (let i = 0, imax = existingTripsPromiseErrors.length; i < imax; i++) {
-                helpers_1.IntegrationErrorHandler.handle(existingTripsPromiseErrors[i]);
+            for (let i = 0, imax = foundedTripsPromiseErrors.length; i < imax; i++) {
+                helpers_1.IntegrationErrorHandler.handle(foundedTripsPromiseErrors[i]);
             }
         });
-        this.generateGtfsRt = () => __awaiter(this, void 0, void 0, function* () {
+        this.generateGtfsRt = (msg) => __awaiter(this, void 0, void 0, function* () {
             const results = yield this.modelTrips.findAllForGTFSRt();
             const updatesMessage = gtfsRealtime.FeedMessage.create();
             const positionsMessage = gtfsRealtime.FeedMessage.create();
@@ -241,7 +205,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                     tripId: r.gtfs_trip_id,
                     routeId: r.gtfs_route_id,
                 };
-                const vehicleDescriptor = Object.assign({ id: r.gtfs_route_type === models_2.GTFSRouteTypeEnum.TRAIN
+                const vehicleDescriptor = Object.assign({ id: r.gtfs_route_type === _1.GTFSRouteTypeEnum.TRAIN
                         ? "train-" + r.cis_trip_number
                         : "service-" + r.gtfs_route_type + "-" + r.vehicle_registration_number }, (r.vehicle_registration_number && {
                     label: r.vehicle_registration_number,
@@ -370,67 +334,32 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
             const tripIds = inputData.updatedTrips.map((trip) => trip.id);
             if (((_b = inputData.positions) === null || _b === void 0 ? void 0 : _b.length) > 0) {
                 // unique ids in input data in key-value (id-positions) structure
-                let positionsByIds = {};
-                for (const position of inputData.positions) {
-                    positionsByIds[position.trips_id] = position;
-                }
-                // unique block_ids and its parent input trips_id in key-value structure
-                let tripsIdsByBlockIds = {};
-                // unique block_ids and its parent gtfs_trip_id in key-value structure
-                let gtfsTripIdsByBlockIds = {};
-                for (const trip of inputData.updatedTrips) {
-                    if (!trip.gtfs_block_id) {
-                        continue;
-                    }
-                    if (!tripsIdsByBlockIds[trip.gtfs_block_id]) {
-                        tripsIdsByBlockIds[trip.gtfs_block_id] = trip.id;
+                const positionsByIds = inputData.positions.reduce((acc, position) => {
+                    acc[position.trips_id] = position;
+                    return acc;
+                }, {});
+                // unique block_id's and its parent input trips_id in key-value (block_id-trips_id) structure
+                const blockIdsToParentTripsId = inputData.updatedTrips.reduce((acc, currentTrip) => {
+                    if (!acc[currentTrip.gtfs_block_id]) {
+                        // init key value pair if not exists
+                        acc[currentTrip.gtfs_block_id] = currentTrip.id;
                     }
                     else {
-                        // save only the shorter trip_id (it is the raw input id with no suffixes)
-                        tripsIdsByBlockIds[trip.gtfs_block_id] =
-                            tripsIdsByBlockIds[trip.gtfs_block_id] > trip.id ? trip.id : tripsIdsByBlockIds[trip.gtfs_block_id];
-                    }
-                    if (!gtfsTripIdsByBlockIds[trip.gtfs_block_id]) {
-                        gtfsTripIdsByBlockIds[trip.gtfs_block_id] = new Set();
-                    }
-                    if (trip.gtfs_trip_id) {
-                        gtfsTripIdsByBlockIds[trip.gtfs_block_id].add(trip.gtfs_trip_id);
-                    }
-                }
-                // Get cached schedule for each unique block_id
-                const tripStopsSchedulesByBlockIds = yield Object.entries(gtfsTripIdsByBlockIds).reduce((acc, [blockId, gtfsTripIds]) => __awaiter(this, void 0, void 0, function* () {
-                    const tripStops = yield acc;
-                    try {
-                        const schedule = yield this.setAndReturnTripStopsSchedule(blockId, [...gtfsTripIds]);
-                        tripStops[blockId] = schedule;
-                    }
-                    catch (err) {
-                        helpers_1.IntegrationErrorHandler.handle(err);
+                        // otherwise save only the shorter trip_id (it is the raw input id with no suffixes)
+                        acc[currentTrip.gtfs_block_id] =
+                            acc[currentTrip.gtfs_block_id] > currentTrip.id
+                                ? currentTrip.id
+                                : acc[currentTrip.gtfs_block_id];
                     }
                     return acc;
-                }), Promise.resolve({}));
+                }, {});
                 // duplicate positions for trips with block_ids
                 for (const trip of inputData.updatedTrips) {
-                    if (positionsByIds[trip.id]) {
-                        if (trip.gtfs_block_id) {
-                            // Determine current position tracking status
-                            positionsByIds[trip.id].tracking = VehiclePositionsUtils_1.VehiclePositionsUtils.determineTrackingStatus(trip.gtfs_trip_id, tripStopsSchedulesByBlockIds[trip.gtfs_block_id], positionsByIds[trip.id]);
-                        }
-                        continue;
-                    }
-                    const currentPosition = inputData.positions.find((position) => {
-                        return position.trips_id === tripsIdsByBlockIds[trip.gtfs_block_id];
-                    });
-                    if (!currentPosition) {
-                        continue;
-                    }
-                    // Determine position duplication and new position tracking status
-                    const { shouldCreateNewPosition, trackingStatus: newPositionTrackingStatus } = VehiclePositionsUtils_1.VehiclePositionsUtils.determineNewPositionTracking(tripStopsSchedulesByBlockIds[trip.gtfs_block_id], trip, currentPosition);
-                    if (shouldCreateNewPosition) {
-                        // duplicate position with new created trip for second trip
-                        const newPosition = Object.assign({}, currentPosition);
+                    if (!positionsByIds[trip.id]) {
+                        const newPosition = Object.assign({}, inputData.positions.find((position) => {
+                            return position.trips_id === blockIdsToParentTripsId[trip.gtfs_block_id];
+                        }));
                         newPosition.trips_id = trip.id;
-                        newPosition.tracking = newPositionTrackingStatus;
                         inputData.positions.push(newPosition);
                     }
                 }
@@ -453,7 +382,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                             helpers_1.log.debug("Delay Computation data (Redis) was not found. (gtfsTripId = " + trip.gtfs_trip_id + ")");
                             try {
                                 const gtfs = yield this.getResultObjectForDelayCalculation(trip.gtfs_trip_id);
-                                yield this.delayComputationTripsModel.set("trip_id", gtfs, VehiclePositionsUtils_1.VehiclePositionsUtils.DELAY_COMPUTATION_CACHE_TTL);
+                                yield this.delayComputationTripsModel.set("trip_id", gtfs, 7200);
                                 trip.gtfsData = gtfs;
                             }
                             catch (err) {
@@ -470,7 +399,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                     }));
                 }
                 catch (err) {
-                    throw new golemio_errors_1.CustomError(`Error while updating delay. For trip ids:${tripIds.slice(0, 10).join(",")}`, true, this.constructor.name, 5001, err);
+                    throw new golemio_errors_1.CustomError(`Error while updating delay.`, true, this.constructor.name, 5001, err);
                 }
             }
         });
@@ -527,8 +456,9 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
          * @returns {void}
          */
         this.updateRunsGTFSTripId = (msg) => __awaiter(this, void 0, void 0, function* () {
+            var e_1, _e;
             const input = JSON.parse(msg.content.toString());
-            const schedule = yield this.setAndReturnScheduledTrips(input.run);
+            const schedule = yield this.getScheduledTrips(input.run);
             const { actual_stop_timestamp_scheduled: actualStopTimestampScheduled, msg_timestamp: msgTimestamp, events: event, } = input.run_message;
             const delayMsg = {
                 updatedTrips: [],
@@ -543,51 +473,62 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 }
                 return;
             }
-            if (!actualStopTimestampScheduled) {
-                helpers_1.log.warn(`updateRunsGTFSTripId: actualStopTimestampScheduled is not provided for current run: ${JSON.stringify(input.run)}`);
-                return;
-            }
-            const asts = (0, moment_timezone_1.default)(+actualStopTimestampScheduled);
-            // current gtfs trip for run
-            const gtfsCurrentTrip = schedule.find((el, i) => {
-                return asts.isBetween((0, moment_timezone_1.default)(el.start_timestamp), (0, moment_timezone_1.default)(el.end_timestamp), "second", "[]");
-            });
-            let isCurrentTripTracking = false;
-            if (gtfsCurrentTrip &&
-                // tram is always on track while pushes messages only on stops
-                (gtfsCurrentTrip.route_type === models_2.GTFSRouteTypeEnum.TRAM ||
-                    // when bus announces DEPARTURE TCP event, it means that trip is on track
-                    (gtfsCurrentTrip.route_type === models_2.GTFSRouteTypeEnum.BUS && event === const_1.TCPEventEnum.DEPARTURED) ||
-                    // when trip has set first stop time, and message timestamp is after scheduled start, set as tracking
-                    (asts.isSame((0, moment_timezone_1.default)(gtfsCurrentTrip.start_timestamp)) &&
-                        (0, moment_timezone_1.default)(msgTimestamp).isSameOrAfter((0, moment_timezone_1.default)(gtfsCurrentTrip.start_timestamp))) ||
-                    // of course when trip announcing some next stop time in schedule, then set as tracking
-                    asts.isAfter((0, moment_timezone_1.default)(gtfsCurrentTrip.start_timestamp)))) {
-                isCurrentTripTracking = true;
-            }
-            const gtfsCurrentTripId = gtfsCurrentTrip && gtfsCurrentTrip.trip_id;
-            if (!gtfsCurrentTripId) {
-                helpers_1.log.warn(`updateRunsGTFSTripId: could not find current gtfsTrip for run: ${JSON.stringify(input)}`);
+            if (actualStopTimestampScheduled) {
+                const asts = (0, moment_timezone_1.default)(+actualStopTimestampScheduled);
+                // current gtfs trip for run
+                const gtfsCurrentTrip = schedule.find((el, i) => {
+                    return asts.isBetween((0, moment_timezone_1.default)(el.start_timestamp), (0, moment_timezone_1.default)(el.end_timestamp), "second", "[]");
+                });
+                let isCurrentTripTracking = false;
+                if (gtfsCurrentTrip &&
+                    // tram is always on track while pushes messages only on stops
+                    (gtfsCurrentTrip.route_type === _1.GTFSRouteTypeEnum.TRAM ||
+                        // when bus announces DEPARTURE TCP event, it means that trip is on track
+                        (gtfsCurrentTrip.route_type === _1.GTFSRouteTypeEnum.BUS && event === const_1.TCPEventEnum.DEPARTURED) ||
+                        // when trip has set first stop time, and message timestamp is after scheduled start, set as tracking
+                        (asts.isSame((0, moment_timezone_1.default)(gtfsCurrentTrip.start_timestamp)) &&
+                            (0, moment_timezone_1.default)(msgTimestamp).isSameOrAfter((0, moment_timezone_1.default)(gtfsCurrentTrip.start_timestamp))) ||
+                        // of course when trip announcing some next stop time in schedule, then set as tracking
+                        asts.isAfter((0, moment_timezone_1.default)(gtfsCurrentTrip.start_timestamp)))) {
+                    isCurrentTripTracking = true;
+                }
+                const gtfsCurrentTripId = gtfsCurrentTrip && gtfsCurrentTrip.trip_id;
+                if (!gtfsCurrentTripId) {
+                    helpers_1.log.warn(`updateRunsGTFSTripId: could not find current gtfsTrip for run: ${JSON.stringify(input)}`);
+                }
+                else {
+                    const currentTrip = yield this.modelTrips.upsertRunTrip(input, gtfsCurrentTrip);
+                    yield this.modelPositions.upsertRunPosition(input, gtfsCurrentTrip, isCurrentTripTracking);
+                    delayMsg.updatedTrips.push(currentTrip);
+                }
+                // last/next gtfs trip for run
+                const gtfsLastNextTrips = schedule.filter((el) => {
+                    return (((asts.clone().subtract(15, "minutes") <= (0, moment_timezone_1.default)(el.end_timestamp) && (0, moment_timezone_1.default)(el.end_timestamp) <= asts) ||
+                        (asts <= (0, moment_timezone_1.default)(el.start_timestamp) && (0, moment_timezone_1.default)(el.start_timestamp) <= asts.clone().add(60, "minutes"))) &&
+                        el.trip_id !== (gtfsCurrentTrip === null || gtfsCurrentTrip === void 0 ? void 0 : gtfsCurrentTrip.trip_id));
+                });
+                try {
+                    for (var gtfsLastNextTrips_1 = __asyncValues(gtfsLastNextTrips), gtfsLastNextTrips_1_1; gtfsLastNextTrips_1_1 = yield gtfsLastNextTrips_1.next(), !gtfsLastNextTrips_1_1.done;) {
+                        const gtfsTrip = gtfsLastNextTrips_1_1.value;
+                        const trip = yield this.modelTrips.upsertRunTrip(input, gtfsTrip);
+                        yield this.modelPositions.upsertRunPosition(input, gtfsTrip, false);
+                        delayMsg.updatedTrips.push(trip);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (gtfsLastNextTrips_1_1 && !gtfsLastNextTrips_1_1.done && (_e = gtfsLastNextTrips_1.return)) yield _e.call(gtfsLastNextTrips_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                // send to updateDelay only if there are some trips updated
+                if (delayMsg.updatedTrips.length > 0) {
+                    yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateDelay", JSON.stringify(delayMsg));
+                }
             }
             else {
-                const currentTrip = yield this.modelTrips.upsertRunTrip(input, gtfsCurrentTrip);
-                yield this.modelPositions.upsertRunPosition(input, gtfsCurrentTrip, isCurrentTripTracking);
-                delayMsg.updatedTrips.push(currentTrip);
-            }
-            // last/next gtfs trip for run
-            const gtfsLastNextTrips = schedule.filter((el) => {
-                return (((asts.clone().subtract(15, "minutes") <= (0, moment_timezone_1.default)(el.end_timestamp) && (0, moment_timezone_1.default)(el.end_timestamp) <= asts) ||
-                    (asts <= (0, moment_timezone_1.default)(el.start_timestamp) && (0, moment_timezone_1.default)(el.start_timestamp) <= asts.clone().add(60, "minutes"))) &&
-                    el.trip_id !== (gtfsCurrentTrip === null || gtfsCurrentTrip === void 0 ? void 0 : gtfsCurrentTrip.trip_id));
-            });
-            for (const gtfsTrip of gtfsLastNextTrips) {
-                const trip = yield this.modelTrips.upsertRunTrip(input, gtfsTrip);
-                yield this.modelPositions.upsertRunPosition(input, gtfsTrip, false);
-                delayMsg.updatedTrips.push(trip);
-            }
-            // send to updateDelay only if there are some trips updated
-            if (delayMsg.updatedTrips.length > 0) {
-                yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateDelay", JSON.stringify(delayMsg));
+                helpers_1.log.warn(`updateRunsGTFSTripId: actualStopTimestampScheduled is not provided for current run: ${JSON.stringify(input.run)}`);
             }
         });
         /**
@@ -617,7 +558,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
          *
          * @returns {string[]} array of tripIds
          */
-        this.setAndReturnScheduledTrips = (scheduleData) => __awaiter(this, void 0, void 0, function* () {
+        this.getScheduledTrips = (scheduleData) => __awaiter(this, void 0, void 0, function* () {
             const { route_id, run_number, msg_last_timestamp } = scheduleData;
             const scheduledTripIds = yield this.runTripsModel.get(`${route_id}_${run_number}`);
             if (!(scheduledTripIds === null || scheduledTripIds === void 0 ? void 0 : scheduledTripIds.schedule)) {
@@ -627,36 +568,11 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                     el.start_timestamp = (0, moment_timezone_1.default)(el.start_timestamp).tz("Europe/Prague").format();
                     el.end_timestamp = (0, moment_timezone_1.default)(el.end_timestamp).tz("Europe/Prague").format();
                 });
-                yield this.runTripsModel.set(`${route_id}_${run_number}`, { schedule: result }, VehiclePositionsUtils_1.VehiclePositionsUtils.RUN_TRIPS_CACHE_TTL);
+                yield this.runTripsModel.set(`${route_id}_${run_number}`, { schedule: result }, 21600);
                 return result;
             }
             return scheduledTripIds.schedule;
         });
-        /**
-         * Get trip stops schedule by block id
-         *
-         * @param {string} blockId - Target gtfs block id
-         * @param {string} tripIds - List of inserted gtfs trip ids
-         */
-        this.setAndReturnTripStopsSchedule = (blockId, tripIds) => __awaiter(this, void 0, void 0, function* () {
-            const schedule = yield this.tripStopsModel.get(blockId);
-            if (schedule) {
-                return schedule;
-            }
-            try {
-                const tripStops = yield this.modelGTFSStopTimes.findTripStops(tripIds);
-                const tripStopsSchedule = tripStops.reduce((acc, curr) => {
-                    acc[curr.trip_id] = { trip_stops: curr.trip_stops };
-                    return acc;
-                }, {});
-                yield this.tripStopsModel.set(blockId, tripStopsSchedule, VehiclePositionsUtils_1.VehiclePositionsUtils.TRIP_STOPS_CACHE_TTL);
-                return tripStopsSchedule;
-            }
-            catch (err) {
-                helpers_1.log.warn("Unable to retrieve trip stops", err);
-                return {};
-            }
-        });
         /**
          * Takes all newly computed positions and saves it, then save the last ones to the trips
          *
@@ -764,9 +680,9 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 return PositionHandlerEnum.DO_NOTHING;
             if (position.is_canceled)
                 return PositionHandlerEnum.CANCELED;
-            if (position.lat && position.lng && position.tracking === const_1.PositionTrackingEnum.TRACKING)
+            if (position.lat && position.lng && position.tracking === 2)
                 return PositionHandlerEnum.TRACKING;
-            if (position.tracking !== const_1.PositionTrackingEnum.TRACKING)
+            if (position.tracking !== 2)
                 return PositionHandlerEnum.NOT_TRACKING;
             return PositionHandlerEnum.NOT_TRACKING;
         };
@@ -816,7 +732,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                     }
                     else {
                         // if there is tracking 2 position with same origin_timestamp then this position is duplicate
-                        const statePosition = tripPositions.positions.find((e) => e.origin_timestamp === position.origin_timestamp && e.tracking === const_1.PositionTrackingEnum.TRACKING)
+                        const statePosition = tripPositions.positions.find((e) => e.origin_timestamp === position.origin_timestamp && e.tracking === 2)
                             ? const_1.StatePositionEnum.DUPLICATE
                             : const_1.StatePositionEnum.AFTER_TRACK;
                         const lastShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[tripPositions.gtfsData.shapes_anchor_points.length - 1];
@@ -909,6 +825,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 .valueOf();
         };
         // FIND ALL SHAPE POINTS IN POLYGON CIRCLE, GET SEGMENTS WITH CONSEQUENTING POINTS
+        // TODO this should a class method
         this.getShapePointsAroundPosition = (tripShapePoints, radius) => __awaiter(this, void 0, void 0, function* () {
             const ptsInRadius = [];
             let segmentIndex = 0;
@@ -1066,9 +983,9 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 if (Math.abs(timeRealDiff) < Math.abs(minTimeRealDiff)) {
                     minTimeRealDiff = timeRealDiff;
                     // push trip into nearest at_stop shape anchor point if trip "P" event (tram) / "V" event (bus)
-                    if (((gtfsRouteType === models_2.GTFSRouteTypeEnum.TRAM &&
+                    if (((gtfsRouteType === _1.GTFSRouteTypeEnum.TRAM &&
                         currentPosition.properties.tcp_event === const_1.TCPEventEnum.ARRIVAL_ANNOUNCED) ||
-                        (gtfsRouteType === models_2.GTFSRouteTypeEnum.BUS && currentPosition.properties.tcp_event === const_1.TCPEventEnum.V)) &&
+                        (gtfsRouteType === _1.GTFSRouteTypeEnum.BUS && currentPosition.properties.tcp_event === const_1.TCPEventEnum.V)) &&
                         thisClosestPoint.this_stop_sequence === null) {
                         let movingShapePointIndex = thisClosestPoint.index;
                         while (thisClosestPoint.this_stop_sequence === null && movingShapePointIndex < lastTripShapePoint.index) {
@@ -1083,7 +1000,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                         statePosition = const_1.StatePositionEnum.ON_TRACK;
                     }
                     // if tram position has "V" avent tram is after track
-                    if (gtfsRouteType === models_2.GTFSRouteTypeEnum.TRAM && currentPosition.properties.tcp_event === const_1.TCPEventEnum.V) {
+                    if (gtfsRouteType === _1.GTFSRouteTypeEnum.TRAM && currentPosition.properties.tcp_event === const_1.TCPEventEnum.V) {
                         statePosition = const_1.StatePositionEnum.AFTER_TRACK;
                         thisClosestPoint = lastTripShapePoint;
                         timeDelay = null;
@@ -1145,17 +1062,17 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
          * @returns {IPositionToUpdate} - Position object to update
          */
         this.getEstimatedPoint = (tripGtfsData, currentPosition, context, startDayTimestamp, gtfsRouteType) => __awaiter(this, void 0, void 0, function* () {
-            var _e, _f, _g, _h, _j, _k;
+            var _f, _g, _h, _j, _k, _l;
             // init radius around GPS position ( 200 meters radius, 16 points polygon aka circle)
             const radius = turf.circle(currentPosition, 0.2, { steps: 16 });
             //Initial value
             let estimatedPoint = Object.assign({ id: currentPosition.properties.id, state_position: const_1.StatePositionEnum.OFF_TRACK, state_process: const_1.StateProcessEnum.PROCESSED, tcp_event: currentPosition.properties.tcp_event }, (context &&
-                ((_e = context.lastPositionTracking) === null || _e === void 0 ? void 0 : _e.properties.last_stop_sequence) && {
-                shape_dist_traveled: (_f = context.lastPositionTracking) === null || _f === void 0 ? void 0 : _f.properties.shape_dist_traveled,
-                last_stop_arrival_time: (_g = context.lastPositionTracking) === null || _g === void 0 ? void 0 : _g.properties.last_stop_arrival_time,
-                last_stop_departure_time: (_h = context.lastPositionTracking) === null || _h === void 0 ? void 0 : _h.properties.last_stop_departure_time,
-                last_stop_sequence: (_j = context.lastPositionTracking) === null || _j === void 0 ? void 0 : _j.properties.last_stop_sequence,
-                last_stop_id: (_k = context.lastPositionTracking) === null || _k === void 0 ? void 0 : _k.properties.last_stop_id,
+                ((_f = context.lastPositionTracking) === null || _f === void 0 ? void 0 : _f.properties.last_stop_sequence) && {
+                shape_dist_traveled: (_g = context.lastPositionTracking) === null || _g === void 0 ? void 0 : _g.properties.shape_dist_traveled,
+                last_stop_arrival_time: (_h = context.lastPositionTracking) === null || _h === void 0 ? void 0 : _h.properties.last_stop_arrival_time,
+                last_stop_departure_time: (_j = context.lastPositionTracking) === null || _j === void 0 ? void 0 : _j.properties.last_stop_departure_time,
+                last_stop_sequence: (_k = context.lastPositionTracking) === null || _k === void 0 ? void 0 : _k.properties.last_stop_sequence,
+                last_stop_id: (_l = context.lastPositionTracking) === null || _l === void 0 ? void 0 : _l.properties.last_stop_id,
             }));
             // returns array of segments (row of points) of shape anchor points around gps
             const ptsInRadius = yield this.getShapePointsAroundPosition(tripGtfsData.shapes_anchor_points, radius);
@@ -1186,13 +1103,59 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 if (!stopTimes || !stopTimes.stop_times || stopTimes.stop_times.length === 0) {
                     throw new Error(`"trip.stop_times" was not found for id ${tripId}.`);
                 }
-                const shapesGeometryAnchorPoints = this.getShapesGeometryAnchorPoints(stopTimes.shape_id, shapes.shapes, stopTimes.stop_times);
+                // { <tripData>, stop_times: [ <stopTimesDataWithStop> ], shapes: [ <shapesData> ] }
+                const shapesGeometryAnchorPoints = yield this.getShapesGeometryAnchorPoints(stopTimes.shape_id, shapes.shapes);
+                // ----------------------------------------------
+                // TEMP constS
+                const stopSequenceMaximum = stopTimes.stop_times.length;
                 // 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++) {
+                const distanceBefore = 100;
+                const distanceAfter = 50;
+                // TODO this should a class method
+                const shapesAnchorPointsIterator = (i, cb) => {
+                    // end of iteration
+                    if (shapesGeometryAnchorPoints.length === i) {
+                        return cb();
+                    }
+                    // find stop in near distance
+                    const stopNearby = stopTimes.stop_times.reduce((r, s, j) => {
+                        if (shapesGeometryAnchorPoints[i].shape_dist_traveled >=
+                            s.shape_dist_traveled - (distanceBefore * 1.0) / 1000 &&
+                            shapesGeometryAnchorPoints[i].shape_dist_traveled <=
+                                s.shape_dist_traveled + (distanceAfter * 1.0) / 1000) {
+                            const thisDistanceToStop = Math.abs(shapesGeometryAnchorPoints[i].shape_dist_traveled - s.shape_dist_traveled);
+                            if (r.distanceToStop > thisDistanceToStop) {
+                                r.distanceToStop = thisDistanceToStop;
+                                r.this_stop_sequence = s.stop_sequence;
+                                r.at_stop = true;
+                            }
+                        }
+                        return r;
+                    }, { at_stop: false, stop_sequence: null, distanceToStop: Infinity, this_stop_sequence: null });
+                    let lastStopSequence;
+                    let nextStopSequence;
+                    // SET THIS STOP
+                    if (stopNearby.at_stop) {
+                        lastStopSequence = Math.min(stopNearby.this_stop_sequence, stopSequenceMaximum);
+                        nextStopSequence = Math.min(stopNearby.this_stop_sequence + 1, stopSequenceMaximum);
+                    }
+                    else {
+                        const lastNextSequences = stopTimes.stop_times.reduce((r, s, j) => {
+                            if (j < stopTimes.stop_times.length - 1) {
+                                if (shapesGeometryAnchorPoints[i].shape_dist_traveled >= s.shape_dist_traveled &&
+                                    shapesGeometryAnchorPoints[i].shape_dist_traveled <=
+                                        stopTimes.stop_times[j + 1].shape_dist_traveled) {
+                                    r.last_stop_sequence = j + 1;
+                                    r.next_stop_sequence = j + 1 + 1;
+                                }
+                            }
+                            return r;
+                        }, { last_stop_sequence: 1, next_stop_sequence: 2 });
+                        lastStopSequence = lastNextSequences.last_stop_sequence;
+                        nextStopSequence = lastNextSequences.next_stop_sequence;
+                    }
                     let bearing = 0;
                     // add bearing from shape computed for previous shapePoint
                     if (i > 0) {
@@ -1210,37 +1173,13 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                             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 -
-                            stopTimes.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 &&
-                        stopTimes.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, stopTimes.stop_times.length);
-                    }
                     const distanceFromLastStop = Math.round((shapesGeometryAnchorPoints[i].shape_dist_traveled -
                         stopTimes.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
-                        ? stopTimes.stop_times[lastStopSequence - 1].arrival_time_seconds
+                    const timeScheduledSeconds = stopNearby.at_stop
+                        ? stopTimes.stop_times[lastStopSequence - 1].departure_time_seconds
                         : stopTimes.stop_times[lastStopSequence - 1].departure_time_seconds +
                             Math.round(((stopTimes.stop_times[nextStopSequence - 1].arrival_time_seconds -
                                 stopTimes.stop_times[lastStopSequence - 1].departure_time_seconds) *
@@ -1249,22 +1188,29 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                                     stopTimes.stop_times[lastStopSequence - 1].shape_dist_traveled));
                     shapePoints.push({
                         index: i,
-                        at_stop: thisStopSequence !== null,
+                        at_stop: stopNearby.at_stop,
                         bearing,
                         coordinates: shapesGeometryAnchorPoints[i].coordinates,
                         distance_from_last_stop: distanceFromLastStop,
                         last_stop_sequence: lastStopSequence,
                         next_stop_sequence: nextStopSequence,
-                        shape_dist_traveled: Math.round(shapesGeometryAnchorPoints[i].shape_dist_traveled * 100000) / 100000,
-                        this_stop_sequence: thisStopSequence,
+                        shape_dist_traveled: shapesGeometryAnchorPoints[i].shape_dist_traveled,
+                        this_stop_sequence: stopNearby.at_stop ? stopNearby.this_stop_sequence : null,
                         time_scheduled_seconds: timeScheduledSeconds,
                     });
-                }
-                return {
-                    trip_id: tripId,
-                    stop_times: stopTimes.stop_times,
-                    shapes_anchor_points: shapePoints,
+                    // next step
+                    shapesAnchorPointsIterator(i + 1, cb);
                 };
+                return new Promise((resolve, reject) => {
+                    shapesAnchorPointsIterator(0, () => {
+                        // FINAL OBJECT
+                        resolve({
+                            trip_id: tripId,
+                            stop_times: stopTimes.stop_times,
+                            shapes_anchor_points: shapePoints,
+                        });
+                    });
+                });
             }
             catch (err) {
                 helpers_1.log.error(err);
@@ -1276,156 +1222,75 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
          *
          * @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) => {
+        this.getShapesGeometryAnchorPoints = (shapeId, shapes) => __awaiter(this, void 0, void 0, function* () {
+            var _m;
+            const shapesAnchorPoints = [];
             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 = Object.assign(Object.assign({}, 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);
-                        }
-                    }
-                    if (currentSegment.length) {
-                        segmentShapes.push(currentSegment);
-                    }
-                }
-                let segmentArr = [];
-                // concat arrays of stop divided segments with distributed shape points
-                for (const segment of segmentShapes) {
-                    segmentArr = [...segmentArr, ...this.divideSegmentLine(segment)];
-                }
-                // 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;
+                // CREATE turf LineString OBJECT FOR GIVEN COORDINATES
+                const line = turf.lineString(shapes.map((p) => {
+                    return [p.shape_pt_lon, p.shape_pt_lat];
+                }));
+                // DEFAULT step BETWEEN TWO POINTS ON PATH [km] - SHORT DISTANCE IMPACTS PROCESS DURATION
+                const step = config_1.config.vehiclePositions.stepBetweenPoints;
+                const distance = ruler.lineDistance((_m = line.geometry) === null || _m === void 0 ? void 0 : _m.coordinates);
+                // TODO this should a class method
+                const lineIterator = (i, cb) => {
+                    var _a;
+                    // end of iteration
+                    if (i >= distance) {
+                        return cb();
                     }
-                    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,
+                    // ADD ALL POINTS TO shapes_anchor_points
+                    shapesAnchorPoints.push({
+                        // RETURNS coordinates ALONG path WITH GIVER i (DISTANCE) IN 5 DECIMAL PLACES
+                        coordinates: ruler.along((_a = line.geometry) === null || _a === void 0 ? void 0 : _a.coordinates, i).map((c) => {
+                            return Math.round(c * 100000) / 100000;
+                        }),
+                        // shape_dist_traveled IS IMPORTANT FOR DECIDING LAST STOP
+                        shape_dist_traveled: Math.round(i * 1000) / 1000, // 1 METER PRECISSION
+                    });
+                    // next step
+                    lineIterator(i + step, cb);
+                };
+                return new Promise((resolve, reject) => {
+                    lineIterator(0, () => {
+                        resolve(shapesAnchorPoints);
+                    });
                 });
-                return resultArr;
             }
             catch (err) {
                 helpers_1.log.error(err);
                 helpers_1.log.error(shapeId);
-                return [];
+                return shapesAnchorPoints;
             }
-        };
-        /**
-         * Generates 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 = [
-                Object.assign(Object.assign({}, 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.modelPositions = new models_2.VehiclePositionsPositionsModel();
-        this.modelStops = new models_2.VehiclePositionsStopsModel();
-        this.modelRuns = new models_2.VehiclePositionsRunsModel();
-        this.transformationRuns = new transformations_1.VehiclePositionsRunsTransformation();
-        this.modelTrips = new models_2.VehiclePositionsTripsModel();
-        this.transformation = new transformations_1.VehiclePositionsTransformation();
+        });
+        this.modelPositions = new _1.VehiclePositionsPositionsModel();
+        this.modelStops = new _1.VehiclePositionsStopsModel();
+        this.modelRuns = new _1.VehiclePositionsRunsModel();
+        this.transformationRuns = new VehiclePositionsRunsTransformation_1.VehiclePositionsRunsTransformation();
+        this.modelTrips = new _1.VehiclePositionsTripsModel();
+        this.transformation = new _1.VehiclePositionsTransformation();
         this.delayComputationTripsModel = new models_1.RedisModel(ropid_gtfs_1.RopidGTFS.delayComputationTrips.name + "Model", {
             decodeDataAfterGet: JSON.parse,
             encodeDataBeforeSave: JSON.stringify,
             isKeyConstructedFromData: true,
             prefix: ropid_gtfs_1.RopidGTFS.delayComputationTrips.mongoCollectionName,
         }, new golemio_validator_1.Validator(ropid_gtfs_1.RopidGTFS.delayComputationTrips.name + "ModelValidator", ropid_gtfs_1.RopidGTFS.delayComputationTrips.outputMongooseSchemaObject));
-        this.runTripsModel = new models_1.RedisModel(vehicle_positions_1.VehiclePositions.runsTrips.name + "Model", {
+        this.runTripsModel = new models_1.RedisModel(vehicle_positions_1.VehiclePositions.runs_trips.name + "Model", {
             decodeDataAfterGet: JSON.parse,
             encodeDataBeforeSave: JSON.stringify,
             isKeyConstructedFromData: false,
-            prefix: vehicle_positions_1.VehiclePositions.runsTrips.namespacePrefix,
-        }, new golemio_validator_1.Validator(vehicle_positions_1.VehiclePositions.runsTrips.name + "ModelValidator", vehicle_positions_1.VehiclePositions.runsTrips.outputMongooseSchemaObject));
+            prefix: vehicle_positions_1.VehiclePositions.runs_trips.namespacePrefix,
+        }, new golemio_validator_1.Validator(vehicle_positions_1.VehiclePositions.runs_trips.name + "ModelValidator", vehicle_positions_1.VehiclePositions.runs_trips.outputMongooseSchemaObject));
         this.queuePrefix = config_1.config.RABBIT_EXCHANGE_NAME + "." + vehicle_positions_1.VehiclePositions.name.toLowerCase();
         this.gtfsRtModel = new models_1.RedisModel("GTFSRealTimeModel", {
             isKeyConstructedFromData: false,
             prefix: "files:gtfsRt",
         });
-        this.tripStopsModel = new models_1.RedisModel(vehicle_positions_1.VehiclePositions.tripStops.name + "Model", {
-            decodeDataAfterGet: JSON.parse,
-            encodeDataBeforeSave: JSON.stringify,
-            isKeyConstructedFromData: false,
-            prefix: vehicle_positions_1.VehiclePositions.tripStops.namespacePrefix,
-        }, new golemio_validator_1.Validator(vehicle_positions_1.VehiclePositions.tripStops.name + "ModelValidator", vehicle_positions_1.VehiclePositions.tripStops.outputMongooseSchemaObject));
-        this.modelGTFSTrips = new RopidGTFSTripsModel_1.RopidGTFSTripsModel();
         this.modelGTFSStopTimes = new RopidGTFSStopTimesModel_1.RopidGTFSStopTimesModel();
+        this.modelGTFSTrips = new RopidGTFSTripsModel_1.RopidGTFSTripsModel();
         // Create trips upsert queue for preventing transaction deadlocks
         this.upsertTripsFQ = fastq_1.default.promise(this.modelTrips.bulkUpsert, 1);
     }