@golemio/pid 2.1.13 → 2.1.14-dev.511689839

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

@@ -27,13 +27,6 @@ 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 };
 };
@@ -52,12 +45,13 @@ 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 VehiclePositionsRunsTransformation_1 = require("./VehiclePositionsRunsTransformation");
+const RopidGTFSTripsModel_1 = require("../ropid-gtfs/RopidGTFSTripsModel");
 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";
@@ -109,10 +103,11 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 }
             }
             for (const key in chunks) {
-                const allIds = yield this.modelTrips.findAllAssocTripIds(chunks[key]);
+                const positions = transformedData.positions.filter((position) => chunks[key].includes(position.trips_id));
+                const updatedTrips = yield this.modelTrips.findAllAssocTripIds(chunks[key]);
                 yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateDelay", JSON.stringify({
-                    positions: transformedData.positions.filter((position) => chunks[key].includes(position.trips_id)),
-                    updatedTrips: allIds,
+                    positions,
+                    updatedTrips,
                 }));
             }
         });
@@ -131,7 +126,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
-            const positionsByIds = {};
+            let positionsByIds = {};
             for (const position of inputData.positions) {
                 positionsByIds[position.trips_id] = position;
             }
@@ -140,13 +135,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.getScheduledTrips({
+                return this.setAndReturnScheduledTrips({
                     route_id: trip.origin_route_name,
                     run_number: trip.sequence_id,
                     msg_last_timestamp: timestampLast,
                 });
             }));
-            // find for each trip gtfs data
+            // find gtfs data for each trip
             const promiseValues = yield Promise.all(inputData.trips.map((trip) => __awaiter(this, void 0, void 0, function* () {
                 try {
                     return yield this.modelTrips.findGTFSTripId(trip);
@@ -156,35 +151,76 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                     return err;
                 }
             })));
+            let existingTripsPromiseValues = [], existingTripsPromiseErrors = [];
             // filter only trips with found gtfs data
-            const foundedTripsPromiseValues = [].concat(...promiseValues.filter((result) => !(result instanceof golemio_errors_1.CustomError)));
-            const foundedTripsPromiseErrors = promiseValues.filter((result) => result instanceof golemio_errors_1.CustomError);
+            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({}));
             let currentPosition;
-            for (const trip of foundedTripsPromiseValues) {
+            for (const trip of existingTripsPromiseValues) {
                 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;
                 }
-                else {
-                    // duplicate position with new created trip for second train trip
+                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);
                     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 = foundedTripsPromiseValues.length; i < imax; i += chunkSize) {
+            for (let i = 0, chunkSize = 100, imax = existingTripsPromiseValues.length; i < imax; i += chunkSize) {
                 yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateDelay", JSON.stringify({
                     positions: [],
-                    updatedTrips: foundedTripsPromiseValues.slice(i, i + chunkSize),
+                    updatedTrips: existingTripsPromiseValues.slice(i, i + chunkSize),
                 }));
             }
             // gtfsId updating errors
-            for (let i = 0, imax = foundedTripsPromiseErrors.length; i < imax; i++) {
-                helpers_1.IntegrationErrorHandler.handle(foundedTripsPromiseErrors[i]);
+            for (let i = 0, imax = existingTripsPromiseErrors.length; i < imax; i++) {
+                helpers_1.IntegrationErrorHandler.handle(existingTripsPromiseErrors[i]);
             }
         });
-        this.generateGtfsRt = (msg) => __awaiter(this, void 0, void 0, function* () {
+        this.generateGtfsRt = () => __awaiter(this, void 0, void 0, function* () {
             const results = yield this.modelTrips.findAllForGTFSRt();
             const updatesMessage = gtfsRealtime.FeedMessage.create();
             const positionsMessage = gtfsRealtime.FeedMessage.create();
@@ -205,7 +241,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 === _1.GTFSRouteTypeEnum.TRAIN
+                const vehicleDescriptor = Object.assign({ id: r.gtfs_route_type === models_2.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,
@@ -334,32 +370,67 @@ 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
-                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;
+                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;
                     }
                     else {
-                        // 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];
+                        // 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);
                     }
                     return acc;
-                }, {});
+                }), Promise.resolve({}));
                 // duplicate positions for trips with block_ids
                 for (const trip of inputData.updatedTrips) {
-                    if (!positionsByIds[trip.id]) {
-                        const newPosition = Object.assign({}, inputData.positions.find((position) => {
-                            return position.trips_id === blockIdsToParentTripsId[trip.gtfs_block_id];
-                        }));
+                    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);
                         newPosition.trips_id = trip.id;
+                        newPosition.tracking = newPositionTrackingStatus;
                         inputData.positions.push(newPosition);
                     }
                 }
@@ -382,7 +453,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, 7200);
+                                yield this.delayComputationTripsModel.set("trip_id", gtfs, VehiclePositionsUtils_1.VehiclePositionsUtils.DELAY_COMPUTATION_CACHE_TTL);
                                 trip.gtfsData = gtfs;
                             }
                             catch (err) {
@@ -399,7 +470,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                     }));
                 }
                 catch (err) {
-                    throw new golemio_errors_1.CustomError(`Error while updating delay.`, true, this.constructor.name, 5001, 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);
                 }
             }
         });
@@ -456,9 +527,8 @@ 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.getScheduledTrips(input.run);
+            const schedule = yield this.setAndReturnScheduledTrips(input.run);
             const { actual_stop_timestamp_scheduled: actualStopTimestampScheduled, msg_timestamp: msgTimestamp, events: event, } = input.run_message;
             const delayMsg = {
                 updatedTrips: [],
@@ -473,62 +543,51 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 }
                 return;
             }
-            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));
-                }
+            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)}`);
             }
             else {
-                helpers_1.log.warn(`updateRunsGTFSTripId: actualStopTimestampScheduled is not provided for current run: ${JSON.stringify(input.run)}`);
+                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));
             }
         });
         /**
@@ -558,7 +617,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
          *
          * @returns {string[]} array of tripIds
          */
-        this.getScheduledTrips = (scheduleData) => __awaiter(this, void 0, void 0, function* () {
+        this.setAndReturnScheduledTrips = (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)) {
@@ -568,11 +627,36 @@ 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 }, 21600);
+                yield this.runTripsModel.set(`${route_id}_${run_number}`, { schedule: result }, VehiclePositionsUtils_1.VehiclePositionsUtils.RUN_TRIPS_CACHE_TTL);
                 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
          *
@@ -680,9 +764,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 === 2)
+            if (position.lat && position.lng && position.tracking === const_1.PositionTrackingEnum.TRACKING)
                 return PositionHandlerEnum.TRACKING;
-            if (position.tracking !== 2)
+            if (position.tracking !== const_1.PositionTrackingEnum.TRACKING)
                 return PositionHandlerEnum.NOT_TRACKING;
             return PositionHandlerEnum.NOT_TRACKING;
         };
@@ -732,7 +816,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 === 2)
+                        const statePosition = tripPositions.positions.find((e) => e.origin_timestamp === position.origin_timestamp && e.tracking === const_1.PositionTrackingEnum.TRACKING)
                             ? const_1.StatePositionEnum.DUPLICATE
                             : const_1.StatePositionEnum.AFTER_TRACK;
                         const lastShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[tripPositions.gtfsData.shapes_anchor_points.length - 1];
@@ -825,7 +909,6 @@ 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;
@@ -983,9 +1066,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 === _1.GTFSRouteTypeEnum.TRAM &&
+                    if (((gtfsRouteType === models_2.GTFSRouteTypeEnum.TRAM &&
                         currentPosition.properties.tcp_event === const_1.TCPEventEnum.ARRIVAL_ANNOUNCED) ||
-                        (gtfsRouteType === _1.GTFSRouteTypeEnum.BUS && currentPosition.properties.tcp_event === const_1.TCPEventEnum.V)) &&
+                        (gtfsRouteType === models_2.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) {
@@ -1000,7 +1083,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 === _1.GTFSRouteTypeEnum.TRAM && currentPosition.properties.tcp_event === const_1.TCPEventEnum.V) {
+                    if (gtfsRouteType === models_2.GTFSRouteTypeEnum.TRAM && currentPosition.properties.tcp_event === const_1.TCPEventEnum.V) {
                         statePosition = const_1.StatePositionEnum.AFTER_TRACK;
                         thisClosestPoint = lastTripShapePoint;
                         timeDelay = null;
@@ -1062,17 +1145,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 _f, _g, _h, _j, _k, _l;
+            var _e, _f, _g, _h, _j, _k;
             // 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 &&
-                ((_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,
+                ((_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,
             }));
             // returns array of segments (row of points) of shape anchor points around gps
             const ptsInRadius = yield this.getShapePointsAroundPosition(tripGtfsData.shapes_anchor_points, radius);
@@ -1103,59 +1186,13 @@ 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}.`);
                 }
-                // { <tripData>, stop_times: [ <stopTimesDataWithStop> ], shapes: [ <shapesData> ] }
-                const shapesGeometryAnchorPoints = yield this.getShapesGeometryAnchorPoints(stopTimes.shape_id, shapes.shapes);
-                // ----------------------------------------------
-                // TEMP constS
-                const stopSequenceMaximum = stopTimes.stop_times.length;
+                const shapesGeometryAnchorPoints = this.getShapesGeometryAnchorPoints(stopTimes.shape_id, shapes.shapes, stopTimes.stop_times);
                 // MAKING COPY
                 const shapePoints = [];
                 // const to determine shape points of stops (in meters)
-                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;
-                    }
+                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) {
@@ -1173,13 +1210,37 @@ 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 = stopNearby.at_stop
-                        ? stopTimes.stop_times[lastStopSequence - 1].departure_time_seconds
+                    const timeScheduledSeconds = thisStopSequence !== null
+                        ? stopTimes.stop_times[lastStopSequence - 1].arrival_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) *
@@ -1188,29 +1249,22 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                                     stopTimes.stop_times[lastStopSequence - 1].shape_dist_traveled));
                     shapePoints.push({
                         index: i,
-                        at_stop: stopNearby.at_stop,
+                        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: shapesGeometryAnchorPoints[i].shape_dist_traveled,
-                        this_stop_sequence: stopNearby.at_stop ? stopNearby.this_stop_sequence : null,
+                        shape_dist_traveled: Math.round(shapesGeometryAnchorPoints[i].shape_dist_traveled * 100000) / 100000,
+                        this_stop_sequence: thisStopSequence,
                         time_scheduled_seconds: timeScheduledSeconds,
                     });
-                    // next step
-                    shapesAnchorPointsIterator(i + 1, cb);
+                }
+                return {
+                    trip_id: tripId,
+                    stop_times: stopTimes.stop_times,
+                    shapes_anchor_points: shapePoints,
                 };
-                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);
@@ -1222,75 +1276,156 @@ 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) => __awaiter(this, void 0, void 0, function* () {
-            var _m;
-            const shapesAnchorPoints = [];
+        this.getShapesGeometryAnchorPoints = (shapeId, shapes, stops) => {
             try {
-                // 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();
+                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);
+                        }
                     }
-                    // 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);
-                    });
+                    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;
+                    }
+                    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 shapesAnchorPoints;
+                return [];
             }
-        });
-        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();
+        };
+        /**
+         * 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.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.runs_trips.name + "Model", {
+        this.runTripsModel = new models_1.RedisModel(vehicle_positions_1.VehiclePositions.runsTrips.name + "Model", {
             decodeDataAfterGet: JSON.parse,
             encodeDataBeforeSave: JSON.stringify,
             isKeyConstructedFromData: false,
-            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));
+            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));
         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.modelGTFSStopTimes = new RopidGTFSStopTimesModel_1.RopidGTFSStopTimesModel();
+        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();
         // Create trips upsert queue for preventing transaction deadlocks
         this.upsertTripsFQ = fastq_1.default.promise(this.modelTrips.bulkUpsert, 1);
     }