@golemio/pid 2.1.13-dev.504816437 → 2.1.13-dev.509077630

package/dist/integration-engine/vehicle-positions/VehiclePositionsWorker.d.ts

@@ -1,89 +1,10 @@
 /// <reference types="node" />
 import { BaseWorker } from "@golemio/core/dist/integration-engine/workers";
-import { IShape, IStopTime } from "../ropid-gtfs/RopidGTFSTripsModel";
-import { GTFSRouteTypeEnum } from "./";
-import { IVehiclePositionsRunCommon } from "./VehiclePositionsRunsTransformation";
-import { Feature, Point } from "@turf/turf";
-import { ITripPositionAttributes } from "./VehiclePositionsPositionsModel";
-interface IComputedPositionAtStopStreak {
-    firstPositionTimestamp: number | null;
-    firstPositionDelay: number | null;
-    stop_sequence: number | null;
-}
-export interface IPositionsContext {
-    lastPositionId: string | null;
-    lastPositionOriginTimestamp: number | null;
-    lastPositionTracking: Feature<Point, ITripPositionAttributes> | null;
-    lastPositionCanceled: boolean | null;
-    lastPositionLastStop: {
-        id: string | null;
-        sequence: number | null;
-        arrival_time: number | null;
-        departure_time: number | null;
-    };
-    lastPositionDelay: number | null;
-    atStopStreak: IComputedPositionAtStopStreak;
-    lastPositionBeforeTrackDelayed: {
-        delay: number;
-        origin_timestamp: number;
-    } | null;
-    isLastPositionAfterTrack: boolean;
-    tripId: string;
-}
-export interface IShapeAnchorPoint {
-    index: number;
-    at_stop: boolean;
-    bearing: number;
-    coordinates: [number, number];
-    distance_from_last_stop: number;
-    last_stop_sequence: number;
-    next_stop_sequence: number;
-    shape_dist_traveled: number;
-    this_stop_sequence: number | null;
-    time_scheduled_seconds: number;
-}
-export interface ISegmentShape extends IShape {
-    shape_at_stop: boolean;
-}
-interface IComputationTrip {
-    trip_id: string;
-    stop_times: IStopTime[];
-    shapes_anchor_points: IShapeAnchorPoint[];
-}
-interface ITripPositionsWithOrWithoutGTFS {
-    gtfsData: IComputationTrip | null;
-    id: string;
-    gtfs_trip_id: string;
-    gtfs_route_type: GTFSRouteTypeEnum;
-    start_timestamp: string;
-    agency_name_scheduled: string;
-    start_cis_stop_id: number;
-    positions: ITripPositionAttributes[];
-}
-export interface ITripPositionsWithGTFS extends ITripPositionsWithOrWithoutGTFS {
-    gtfsData: IComputationTrip;
-}
-export interface ICurrentPositionProperties {
-    id: string;
-    origin_time: string;
-    origin_timestamp: number;
-    tcp_event: string | null;
-}
-export interface ILastPositionProperties {
-    time_delay: number;
-    atStopStreak: IComputedPositionAtStopStreak;
-}
-export interface IPropagateDelay {
-    nextGtfsTrips: string[];
-    currentOriginTimestamp: number;
-    currentGtfsTripId: string;
-    currentRegistrationNumber: number;
-    currentDelay: number;
-    currentStartTime: string;
-    currentEndTime: string;
-}
+import { IVehiclePositionsRunCommon } from "./transformations";
+import type { IPropagateDelay } from "./VehiclePositionsInterfaces";
 export declare class VehiclePositionsWorker extends BaseWorker {
     private modelGTFSTrips;
+    private modelGTFSStopTimes;
     private modelPositions;
     private modelRuns;
     private modelStops;
@@ -93,26 +14,36 @@ export declare class VehiclePositionsWorker extends BaseWorker {
     private delayComputationTripsModel;
     private runTripsModel;
     private gtfsRtModel;
+    private tripStopsModel;
     private upsertTripsFQ;
     private readonly queuePrefix;
-    private modelGTFSStopTimes;
     constructor();
-    saveDataToDB: (msg: any) => Promise<void>;
-    saveStopsToDB: (msg: any) => Promise<void>;
-    updateGTFSTripId: (msg: any) => Promise<void>;
-    generateGtfsRt: (msg: any) => Promise<void>;
+    saveDataToDB: (msg: {
+        content: Buffer;
+    }) => Promise<void>;
+    saveStopsToDB: (msg: {
+        content: Buffer;
+    }) => Promise<void>;
+    updateGTFSTripId: (msg: {
+        content: Buffer;
+    }) => Promise<void>;
+    generateGtfsRt: () => Promise<void>;
     private isUpdateDelayRunTripsIdsData;
     private mapDelayedPositionsToRunTrips;
     propagateDelayForGtfsTrip: (data: IPropagateDelay) => Promise<void>;
-    propagateDelay: (msg: any) => Promise<void>;
-    updateDelay: (msg: any) => Promise<void>;
+    propagateDelay: (msg: {
+        content: Buffer;
+    }) => Promise<void>;
+    updateDelay: (msg: {
+        content: Buffer;
+    }) => Promise<void>;
     /**
      * Queue listener method - triggers processing of TCP input gateway runs data
      *
      * @param {object} msg - xml->json parsed run message
      * @returns {void}
      */
-    saveRunsToDB: (msg: any) => Promise<void>;
+    saveRunsToDB: (msg: Record<string, any>) => Promise<void>;
     /**
      * Process not public trips from runs data
      *
@@ -126,7 +57,9 @@ export declare class VehiclePositionsWorker extends BaseWorker {
      * @param {object} msg
      * @returns {void}
      */
-    updateRunsGTFSTripId: (msg: any) => Promise<void>;
+    updateRunsGTFSTripId: (msg: {
+        content: Buffer;
+    }) => Promise<void>;
     /**
      * Queue listener method - delete old data
      */
@@ -138,7 +71,14 @@ export declare class VehiclePositionsWorker extends BaseWorker {
      *
      * @returns {string[]} array of tripIds
      */
-    private getScheduledTrips;
+    private setAndReturnScheduledTrips;
+    /**
+     * Get trip stops schedule by block id
+     *
+     * @param {string} blockId - Target gtfs block id
+     * @param {string} tripIds - List of inserted gtfs trip ids
+     */
+    private setAndReturnTripStopsSchedule;
     /**
      * Takes all newly computed positions and saves it, then save the last ones to the trips
      *
@@ -266,4 +206,3 @@ export declare class VehiclePositionsWorker extends BaseWorker {
      */
     private divideSegmentLine;
 }
-export {};

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,71 @@ 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, tripIds]) => __awaiter(this, void 0, void 0, function* () {
+                const tripStops = yield acc;
+                try {
+                    tripStops[blockId] = yield this.setAndReturnTripStopsSchedule(blockId, [...tripIds]);
+                }
+                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];
+                    continue;
                 }
-                else {
-                    // duplicate position with new created trip for second train trip
+                if (!currentPosition) {
+                    continue;
+                }
+                const { shouldCreateNewPosition, trackingStatus } = 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 = trackingStatus !== null && trackingStatus !== void 0 ? trackingStatus : newPosition.tracking;
                     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 +236,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,10 +365,10 @@ 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;
-                }, {});
+                let positionsByIds = {};
+                for (const position of inputData.positions) {
+                    positionsByIds[position.trips_id] = position;
+                }
                 // 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]) {
@@ -353,13 +384,34 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                     }
                     return acc;
                 }, {});
+                // Get cached schedule for each unique block_id
+                const tripStopsSchedulesByBlockIds = yield Object.keys(blockIdsToParentTripsId).reduce((acc, blockId) => __awaiter(this, void 0, void 0, function* () {
+                    const tripStops = yield acc;
+                    try {
+                        const schedule = yield this.tripStopsModel.get(blockId);
+                        if (schedule) {
+                            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]) {
+                        continue;
+                    }
+                    const currentPosition = inputData.positions.find((position) => {
+                        return position.trips_id === blockIdsToParentTripsId[trip.gtfs_block_id];
+                    });
+                    const { shouldCreateNewPosition, trackingStatus } = 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 = trackingStatus !== null && trackingStatus !== void 0 ? trackingStatus : newPosition.tracking;
                         inputData.positions.push(newPosition);
                     }
                 }
@@ -382,7 +434,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) {
@@ -456,9 +508,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 +524,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 +598,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 +608,34 @@ 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* () {
+            var _e;
+            const schedule = (_e = (yield this.tripStopsModel.get(blockId))) !== null && _e !== void 0 ? _e : {};
+            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;
+                }, schedule);
+                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 schedule;
+            }
+        });
         /**
          * Takes all newly computed positions and saves it, then save the last ones to the trips
          *
@@ -680,9 +743,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 +795,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 +888,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 +1045,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 +1062,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;
@@ -1312,31 +1374,37 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
             }
             return resultSegmentPoints;
         };
-        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.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);
     }