@golemio/pid 2.4.1 → 2.4.2-dev.761535455

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

@@ -1,887 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VehiclePositionsWorker = void 0;
-const GtfsRtAlertsController_1 = require("../gtfsrt-alerts/GtfsRtAlertsController");
-const GtfsRtAlertTransformation_1 = require("../gtfsrt-alerts/transformations/GtfsRtAlertTransformation");
-const RopidGTFSStopTimesModel_1 = require("../ropid-gtfs/RopidGTFSStopTimesModel");
-const RopidGTFSTripsModel_1 = require("../ropid-gtfs/RopidGTFSTripsModel");
-const ropid_vymi_1 = require("../ropid-vymi");
-const ropid_gtfs_1 = require("../../schema-definitions/ropid-gtfs");
-const vehicle_positions_1 = require("../../schema-definitions/vehicle-positions");
-const config_1 = require("@golemio/core/dist/integration-engine/config");
-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 golemio_errors_1 = require("@golemio/core/dist/shared/golemio-errors");
-const golemio_validator_1 = require("@golemio/core/dist/shared/golemio-validator");
-const moment_timezone_1 = __importDefault(require("@golemio/core/dist/shared/moment-timezone"));
-const turf = __importStar(require("@turf/turf"));
-const const_1 = require("../../const");
-const GTFSTripRunManagerFactory_1 = require("./helpers/gtfs-trip-run/GTFSTripRunManagerFactory");
-const PositionsManager_1 = __importDefault(require("./helpers/PositionsManager"));
-const models_2 = require("./models");
-const VehiclePositionsPositionsHistoryModel_1 = require("./models/VehiclePositionsPositionsHistoryModel");
-const VehiclePositionsTripsHistoryModel_1 = require("./models/VehiclePositionsTripsHistoryModel");
-const transformations_1 = require("./transformations");
-const VehiclePositionsUtils_1 = require("./VehiclePositionsUtils");
-const RunTripsRedisRepository_1 = require("./workers/runs/tasks/data-access/RunTripsRedisRepository");
-const GtfsOvapi = require("@golemio/ovapi-gtfs-realtime-bindings/dist/gtfs-realtime");
-const gtfsRealtime = GtfsOvapi.transit_realtime;
-class VehiclePositionsWorker extends workers_1.BaseWorker {
-    constructor() {
-        super();
-        this.saveDataToDB = (msg) => __awaiter(this, void 0, void 0, function* () {
-            const inputData = JSON.parse(msg.content.toString()).m.spoj;
-            const transformedData = yield this.transformation.transform(inputData);
-            const rows = yield this.modelTrips.bulkUpsert(transformedData.trips);
-            // send message for update GTFSTripIds
-            for (let i = 0, chunkSize = 50; i < rows.inserted.length; i += chunkSize) {
-                const inserted = rows.inserted.slice(i, i + chunkSize);
-                const insertedIds = inserted.map((ins) => {
-                    return ins.id;
-                });
-                yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateGTFSTripId", JSON.stringify({
-                    trips: inserted,
-                    positions: transformedData.positions.filter((position) => insertedIds.includes(position.trips_id)),
-                }));
-            }
-            // send message for update delay
-            // aggregate runs by origin_route_name & sequence_id to keep related messages in same bulk
-            const runTripMap = rows.updated.length ? { unknown: [] } : {};
-            for (const trip of rows.updated) {
-                if (!trip.origin_route_name || !trip.sequence_id) {
-                    runTripMap.unknown.push(trip.id);
-                }
-                else {
-                    const key = `${trip.origin_route_name}_${trip.sequence_id}`;
-                    runTripMap[key] ? runTripMap[key].push(trip.id) : (runTripMap[key] = [trip.id]);
-                }
-            }
-            const chunks = [];
-            let idx = 0;
-            for (const key in runTripMap) {
-                if (!chunks[idx]) {
-                    chunks[idx] = [];
-                }
-                chunks[idx] = chunks[idx].concat(runTripMap[key]);
-                if (chunks[idx].length > 200) {
-                    idx++;
-                }
-            }
-            for (const key in chunks) {
-                const positions = transformedData.positions.filter((position) => chunks[key].includes(position.trips_id));
-                const updatedTrips = yield this.modelTrips.findAllAssocTripIds(chunks[key]);
-                yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateDelay", JSON.stringify({
-                    positions,
-                    updatedTrips,
-                }));
-            }
-        });
-        this.updateGTFSTripId = (msg) => __awaiter(this, void 0, void 0, function* () {
-            const inputData = JSON.parse(msg.content.toString());
-            // unique ids in input data in key-value (id-positions) structure
-            let positionsByIds = {};
-            for (const position of inputData.positions) {
-                positionsByIds[position.trips_id] = position;
-            }
-            // find and set schedules for trips
-            yield Promise.all(inputData.trips.map((trip) => {
-                if (!trip.origin_route_name || !trip.sequence_id || !positionsByIds[trip.id].origin_timestamp)
-                    return;
-                const timestampLast = new Date(positionsByIds[trip.id].origin_timestamp).toISOString();
-                return this.gtfsTripRunManager.setAndReturnScheduledTrips({
-                    route_id: trip.origin_route_name,
-                    run_number: trip.sequence_id,
-                    msg_last_timestamp: timestampLast,
-                });
-            }));
-            // 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);
-                }
-                catch (err) {
-                    helpers_1.log.error(err);
-                    return err;
-                }
-            })));
-            let existingTripsPromiseValues = [], existingTripsPromiseErrors = [];
-            // filter only trips with found gtfs data
-            for (const trip of promiseValues) {
-                if (trip instanceof golemio_errors_1.CustomError) {
-                    existingTripsPromiseErrors.push(trip);
-                }
-                else if (trip instanceof Array) {
-                    existingTripsPromiseValues.push(...trip);
-                }
-                else if ((trip === null || trip === void 0 ? void 0 : trip.constructor) === Object) {
-                    existingTripsPromiseValues.push(trip);
-                }
-            }
-            let tripsByBlockId = {};
-            for (const trip of existingTripsPromiseValues) {
-                if (!trip.gtfs_block_id || !trip.gtfs_trip_id)
-                    continue;
-                if (!tripsByBlockId[trip.gtfs_block_id]) {
-                    tripsByBlockId[trip.gtfs_block_id] = new Set();
-                }
-                tripsByBlockId[trip.gtfs_block_id].add(trip.gtfs_trip_id);
-            }
-            // create cache for trip stops (grouped by block id)
-            const tripStopsSchedulesByBlockIds = yield Object.entries(tripsByBlockId).reduce((acc, [blockId, gtfsTripIds]) => __awaiter(this, void 0, void 0, function* () {
-                const tripStops = yield acc;
-                try {
-                    tripStops[blockId] = yield this.setAndReturnTripStopsSchedule(blockId, [...gtfsTripIds]);
-                }
-                catch (err) {
-                    helpers_1.IntegrationErrorHandler.handle(err);
-                }
-                return acc;
-            }), Promise.resolve({}));
-            let currentPosition;
-            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;
-                }
-                if (!currentPosition) {
-                    continue;
-                }
-                // Determine new position tracking status
-                const newPositionTrackingStatus = VehiclePositionsUtils_1.VehiclePositionsUtils.determineNewPositionTracking(tripStopsSchedulesByBlockIds[trip.gtfs_block_id], trip, currentPosition);
-                // 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 = existingTripsPromiseValues.length; i < imax; i += chunkSize) {
-                yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateDelay", JSON.stringify({
-                    positions: [],
-                    updatedTrips: existingTripsPromiseValues.slice(i, i + chunkSize),
-                }));
-            }
-            // gtfsId updating errors
-            for (let i = 0, imax = existingTripsPromiseErrors.length; i < imax; i++) {
-                helpers_1.IntegrationErrorHandler.handle(existingTripsPromiseErrors[i]);
-            }
-        });
-        this.generateGtfsRt = () => __awaiter(this, void 0, void 0, function* () {
-            const currentDate = new Date();
-            const results = yield this.modelTrips.findAllForGTFSRt();
-            const updatesMessage = gtfsRealtime.FeedMessage.create();
-            const positionsMessage = gtfsRealtime.FeedMessage.create();
-            const header = {
-                gtfsRealtimeVersion: "2.0",
-                incrementality: "FULL_DATASET",
-                timestamp: Math.round(currentDate.valueOf() / 1000),
-            };
-            updatesMessage.header = gtfsRealtime.FeedHeader.fromObject(header);
-            positionsMessage.header = gtfsRealtime.FeedHeader.fromObject(header);
-            results.forEach((r) => {
-                const tripDescriptor = {
-                    scheduleRelationship: r.last_position.is_canceled ? "CANCELED" : "SCHEDULED",
-                    startDate: (0, moment_timezone_1.default)(+r.start_timestamp).utc().format("YYYYMMDD"),
-                    startTime: r.start_time,
-                    tripId: r.gtfs_trip_id,
-                    routeId: r.gtfs_route_id,
-                };
-                const vehicleDescriptor = Object.assign(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,
-                })), { ".transit_realtime.ovapiVehicleDescriptor": {
-                        wheelchairAccessible: r.wheelchair_accessible,
-                    } });
-                const entityTimestamp = Math.round(+r.last_position.origin_timestamp / 1000).toString();
-                const stopTimeUpdates = [];
-                // if last_stop_esquence is null, set default to 1 to include all stops (works for before track trips)
-                const startingStopSequence = r.last_position.last_stop_sequence || 1;
-                if (startingStopSequence) {
-                    for (let i = startingStopSequence; i <= r.stop_times.length; i++) {
-                        const delayObject = r.last_position.delay === null
-                            ? null
-                            : {
-                                delay: r.last_position.delay,
-                            };
-                        if (typeof r.stop_times[i - 1] !== undefined) {
-                            stopTimeUpdates.push({
-                                arrival: delayObject,
-                                departure: delayObject,
-                                stopSequence: i,
-                                stopId: r.stop_times[i - 1].stop_id,
-                            });
-                        }
-                    }
-                }
-                const updateEntity = {
-                    id: r.id,
-                    tripUpdate: {
-                        stopTimeUpdate: stopTimeUpdates,
-                        timestamp: entityTimestamp,
-                        trip: tripDescriptor,
-                        vehicle: vehicleDescriptor,
-                    },
-                };
-                const positionEntity = {
-                    id: r.gtfs_trip_id,
-                    vehicle: {
-                        currentStopSequence: r.last_position.last_stop_sequence,
-                        position: Object.assign({ bearing: r.last_position.bearing, latitude: r.last_position.lat, longitude: r.last_position.lng }, (r.last_position.speed && {
-                            speed: (r.last_position.speed / 3.6).toFixed(2),
-                        })),
-                        timestamp: entityTimestamp,
-                        trip: tripDescriptor,
-                        vehicle: vehicleDescriptor,
-                    },
-                };
-                const updatesMessageEntity = gtfsRealtime.FeedEntity.fromObject(updateEntity);
-                updatesMessage.entity.push(updatesMessageEntity);
-                const positionsMessageEntity = gtfsRealtime.FeedEntity.fromObject(positionEntity);
-                positionsMessage.entity.push(positionsMessageEntity);
-            });
-            if (gtfsRealtime.FeedMessage.verify(updatesMessage) === null) {
-                const buffer = gtfsRealtime.FeedMessage.encode(updatesMessage).finish();
-                // save to Redis
-                yield this.gtfsRtModel.hset("trip_updates.pb", buffer.toString("binary"));
-                // await fs.writeFile("trip_updates.pb", buffer); // debug
-                yield this.gtfsRtModel.hset("trip_updates.json", JSON.stringify(updatesMessage));
-            }
-            if (gtfsRealtime.FeedMessage.verify(positionsMessage) === null) {
-                const buffer = gtfsRealtime.FeedMessage.encode(positionsMessage).finish();
-                // save to Redis
-                yield this.gtfsRtModel.hset("vehicle_positions.pb", buffer.toString("binary"));
-                // await fs.writeFile("vehicle_positions.pb", buffer); // debug
-                yield this.gtfsRtModel.hset("vehicle_positions.json", JSON.stringify(positionsMessage));
-            }
-            yield this.gtfsRtAlertsController.generateGtfsRtAlerts(currentDate);
-        });
-        this.isUpdateDelayRunTripsIdsData = (data) => {
-            const { origin_route_name, sequence_id, gtfs_trip_id } = data;
-            return !!(origin_route_name && sequence_id && gtfs_trip_id);
-        };
-        this.mapDelayedPositionsToRunTrips = (processedPositions, updatedTrips) => {
-            const tripPositionMap = [];
-            for (const batch of processedPositions) {
-                if (batch.context.lastPositionTracking === null) {
-                    continue;
-                }
-                const { properties: { state_position }, } = batch.context.lastPositionTracking;
-                if (state_position !== const_1.StatePositionEnum.ON_TRACK && state_position !== const_1.StatePositionEnum.AT_STOP) {
-                    continue;
-                }
-                const trip = updatedTrips.find((el) => el.id === batch.context.tripId);
-                if (trip && this.isUpdateDelayRunTripsIdsData(trip)) {
-                    tripPositionMap.push({
-                        position: batch.context.lastPositionTracking,
-                        trip: trip,
-                    });
-                }
-            }
-            return tripPositionMap;
-        };
-        this.propagateDelayForGtfsTrip = (data) => __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.modelTrips.getPropagateDelayTripsWithPositions(data);
-            if (!results.length)
-                return;
-            let turnTimeAcc = (+results[0].start_timestamp - moment_timezone_1.default.utc(data.currentEndTime).valueOf()) / 1000;
-            const positionsToUpdate = results.map((item, i) => {
-                turnTimeAcc += i > 0 ? (results[i].start_timestamp - results[i - 1].end_timestamp) / 1000 : 0;
-                return {
-                    id: item.last_position_id,
-                    delay: Math.max(0, data.currentDelay - turnTimeAcc),
-                    state_position: const_1.StatePositionEnum.BEFORE_TRACK_DELAYED,
-                };
-            });
-            yield this.modelPositions.bulkUpdate(positionsToUpdate);
-        });
-        this.propagateDelay = (msg) => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const inputData = JSON.parse(msg.content.toString());
-            const delayedPositionsWithRunTrips = this.mapDelayedPositionsToRunTrips(inputData.processedPositions, inputData.trips);
-            for (const delayedPositions of delayedPositionsWithRunTrips) {
-                const { origin_route_name, sequence_id, gtfs_trip_id, vehicle_registration_number, start_timestamp } = delayedPositions.trip;
-                const scheduledTrips = yield this.runTripsModel.get(`${origin_route_name}_${sequence_id}`);
-                if ((_a = scheduledTrips === null || scheduledTrips === void 0 ? void 0 : scheduledTrips.schedule) === null || _a === void 0 ? void 0 : _a.length) {
-                    const gtfsCurrentTrip = scheduledTrips.schedule.find((trip) => trip.trip_id === gtfs_trip_id && (0, moment_timezone_1.default)(trip.start_timestamp).isSame((0, moment_timezone_1.default)(+start_timestamp), "seconds"));
-                    const gtfsNextTrips = scheduledTrips.schedule.filter((trip) => {
-                        return ((0, moment_timezone_1.default)(gtfsCurrentTrip.end_timestamp).clone().add(60, "minutes") >= (0, moment_timezone_1.default)(trip.start_timestamp) &&
-                            (0, moment_timezone_1.default)(gtfsCurrentTrip.end_timestamp) <= (0, moment_timezone_1.default)(trip.start_timestamp));
-                    });
-                    yield this.propagateDelayForGtfsTrip({
-                        currentGtfsTripId: gtfs_trip_id,
-                        currentOriginTimestamp: delayedPositions.position.properties.origin_timestamp,
-                        currentDelay: delayedPositions.position.properties.delay,
-                        currentRegistrationNumber: vehicle_registration_number,
-                        currentStartTime: gtfsCurrentTrip.start_timestamp,
-                        currentEndTime: gtfsCurrentTrip.end_timestamp,
-                        nextGtfsTrips: gtfsNextTrips.map((trip) => trip.trip_id),
-                    });
-                }
-            }
-        });
-        this.updateDelay = (msg) => __awaiter(this, void 0, void 0, function* () {
-            var _b, _c;
-            const inputData = JSON.parse(msg.content.toString());
-            const tripIds = inputData.updatedTrips.map((trip) => trip.id);
-            if (((_b = inputData.positions) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-                // unique ids in input data in key-value (id-positions) structure
-                let positionsByIds = {};
-                for (const position of inputData.positions) {
-                    positionsByIds[position.trips_id] = position;
-                }
-                // unique block_ids and its parent input trips_id in key-value structure
-                let tripsIdsByBlockIds = {};
-                // unique block_ids and its parent gtfs_trip_id in key-value structure
-                let gtfsTripIdsByBlockIds = {};
-                for (const trip of inputData.updatedTrips) {
-                    if (!trip.gtfs_block_id) {
-                        continue;
-                    }
-                    if (!tripsIdsByBlockIds[trip.gtfs_block_id]) {
-                        tripsIdsByBlockIds[trip.gtfs_block_id] = trip.id;
-                    }
-                    else {
-                        // save only the shorter trip_id (it is the raw input id with no suffixes)
-                        tripsIdsByBlockIds[trip.gtfs_block_id] =
-                            tripsIdsByBlockIds[trip.gtfs_block_id] > trip.id ? trip.id : tripsIdsByBlockIds[trip.gtfs_block_id];
-                    }
-                    if (!gtfsTripIdsByBlockIds[trip.gtfs_block_id]) {
-                        gtfsTripIdsByBlockIds[trip.gtfs_block_id] = new Set();
-                    }
-                    if (trip.gtfs_trip_id) {
-                        gtfsTripIdsByBlockIds[trip.gtfs_block_id].add(trip.gtfs_trip_id);
-                    }
-                }
-                // Get cached schedule for each unique block_id
-                const tripStopsSchedulesByBlockIds = yield Object.entries(gtfsTripIdsByBlockIds).reduce((acc, [blockId, gtfsTripIds]) => __awaiter(this, void 0, void 0, function* () {
-                    const tripStops = yield acc;
-                    try {
-                        const schedule = yield this.setAndReturnTripStopsSchedule(blockId, [...gtfsTripIds]);
-                        tripStops[blockId] = schedule;
-                    }
-                    catch (err) {
-                        helpers_1.IntegrationErrorHandler.handle(err);
-                    }
-                    return acc;
-                }), Promise.resolve({}));
-                // duplicate positions for trips with block_ids
-                for (const trip of inputData.updatedTrips) {
-                    if (positionsByIds[trip.id]) {
-                        if (trip.gtfs_block_id) {
-                            // Determine current position tracking status
-                            positionsByIds[trip.id].tracking = VehiclePositionsUtils_1.VehiclePositionsUtils.determineTrackingStatus(trip.gtfs_trip_id, tripStopsSchedulesByBlockIds[trip.gtfs_block_id], positionsByIds[trip.id]);
-                        }
-                        continue;
-                    }
-                    const currentPosition = inputData.positions.find((position) => {
-                        return position.trips_id === tripsIdsByBlockIds[trip.gtfs_block_id];
-                    });
-                    if (!currentPosition) {
-                        continue;
-                    }
-                    // Determine position duplication and new position tracking status
-                    const newPositionTrackingStatus = VehiclePositionsUtils_1.VehiclePositionsUtils.determineNewPositionTracking(tripStopsSchedulesByBlockIds[trip.gtfs_block_id], trip, currentPosition);
-                    // 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);
-                }
-                // save all new positions
-                yield this.modelPositions.save(inputData.positions);
-            }
-            if (((_c = inputData.updatedTrips) === null || _c === void 0 ? void 0 : _c.length) > 0) {
-                try {
-                    // Get all positions for each trip
-                    const tripsPositionsToUpdate = yield this.modelPositions.getPositionsForUpdateDelay(tripIds);
-                    // Append gtfs data to each trip
-                    const tripsPositionsWithOrWithoutGTFSDataToUpdate = yield Promise.all(tripsPositionsToUpdate.map((trip) => __awaiter(this, void 0, void 0, function* () {
-                        const gtfsData = (yield this.delayComputationTripsModel.get(trip.gtfs_trip_id));
-                        return Object.assign(Object.assign({}, trip), { gtfsData });
-                    })));
-                    // Process every position
-                    const processedPositions = yield Promise.all(tripsPositionsWithOrWithoutGTFSDataToUpdate.map((trip) => __awaiter(this, void 0, void 0, function* () {
-                        // if gtfs shape points and schedules data is not ready, calculate it first
-                        if (trip.gtfsData === null) {
-                            helpers_1.log.debug("Delay Computation data (Redis) was not found. (gtfsTripId = " + trip.gtfs_trip_id + ")");
-                            try {
-                                const gtfs = yield this.getResultObjectForDelayCalculation(trip.gtfs_trip_id);
-                                yield this.delayComputationTripsModel.set("trip_id", gtfs, VehiclePositionsUtils_1.VehiclePositionsUtils.DELAY_COMPUTATION_CACHE_TTL);
-                                trip.gtfsData = gtfs;
-                            }
-                            catch (err) {
-                                return;
-                            }
-                        }
-                        return PositionsManager_1.default.computePositions(trip, inputData.schedule);
-                    })));
-                    const validProcessedPositions = processedPositions.filter((e) => !!e);
-                    yield this.updateComputedPositionsAndTrips(validProcessedPositions);
-                    yield this.sendMessageToExchange("workers." + this.queuePrefix + ".propagateDelay", JSON.stringify({
-                        processedPositions: validProcessedPositions,
-                        trips: inputData.updatedTrips,
-                    }));
-                }
-                catch (err) {
-                    throw new golemio_errors_1.CustomError(`Error while updating delay. For trip ids:${tripIds.slice(0, 10).join(",")}`, true, this.constructor.name, 5001, err);
-                }
-            }
-        });
-        /**
-         * Queue listener method - triggers processing of TCP tram runs data
-         *
-         * @todo Move to RunsWorker after refactoring VehiclePositionsWorker
-         */
-        this.saveTramRunsToDB = (msg) => __awaiter(this, void 0, void 0, function* () {
-            const { data, timestamp } = VehiclePositionsUtils_1.VehiclePositionsUtils.parseRunsMessageData(msg);
-            const transformedData = yield this.transformationRuns.transform({ data: data.M.V, timestamp }, true);
-            for (const element of transformedData) {
-                yield this.processTransformedRun(element);
-            }
-        });
-        /**
-         * Queue listener method - triggers processing of TCP bus runs data
-         *
-         * @todo Move to RunsWorker after refactoring VehiclePositionsWorker
-         */
-        this.saveBusRunsToDB = (msg) => __awaiter(this, void 0, void 0, function* () {
-            var _d;
-            const { data, timestamp } = VehiclePositionsUtils_1.VehiclePositionsUtils.parseRunsMessageData(msg);
-            const transformedData = yield this.transformationRuns.transform({ data: data.M.V, timestamp });
-            for (const element of transformedData) {
-                // Internal bus lines should not interfere with tram runs
-                if (((_d = element.run.route_id) === null || _d === void 0 ? void 0 : _d.length) < 3) {
-                    continue;
-                }
-                yield this.processTransformedRun(element);
-            }
-        });
-        /**
-         * Process not public trips from runs data
-         *
-         * @param {object} input
-         * @returns {void}
-         */
-        this.updateNotPublicRunTrip = (input) => __awaiter(this, void 0, void 0, function* () {
-            const id = `NOT_PUBLIC_${input.run.route_id}_${input.run.run_number}_` +
-                `${input.run.msg_start_timestamp}_${input.run.registration_number}`;
-            const createdPosition = yield this.modelPositions.createNotPublic(input, id);
-            yield this.modelTrips.upsertNotPublic(input, id, createdPosition.toJSON().id);
-            return;
-        });
-        /**
-         * Queue listener method -  processing trips from runs data
-         *
-         * @param {AMQPMessage} msg
-         * @returns {void}
-         */
-        this.updateRunsGTFSTripId = (msg) => __awaiter(this, void 0, void 0, function* () {
-            const input = JSON.parse(msg.content.toString());
-            const schedule = yield this.gtfsTripRunManager.setAndReturnScheduledTrips(input.run);
-            if (schedule.length === 0) {
-                if (const_1.ArrayNotPublicRegistrationNumbers.includes(input.run.registration_number)) {
-                    yield this.updateNotPublicRunTrip(input);
-                }
-                else {
-                    helpers_1.log.verbose(`updateRunsGTFSTripId: no schedule for run: ${JSON.stringify(input.run)}`);
-                }
-                return;
-            }
-            if (!input.run_message.actual_stop_timestamp_scheduled) {
-                helpers_1.log.warn(`updateRunsGTFSTripId: actualStopTimestampScheduled is not provided for current run: ${JSON.stringify(input.run)}`);
-                return;
-            }
-            const delayMsg = yield this.gtfsTripRunManager.generateDelayMsg(schedule, input);
-            // 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));
-            }
-        });
-        /**
-         * Queue listener method - delete old data
-         */
-        this.deleteOldVehiclePositionsData = (msg) => __awaiter(this, void 0, void 0, function* () {
-            let targetHours;
-            try {
-                targetHours = +JSON.parse(msg.content.toString()).targetHours;
-                // Target hours should be an integer
-                // Also disallow deletion of new data
-                if (!Number.isInteger(targetHours) || targetHours < 8) {
-                    helpers_1.log.warn("New data cannot be deleted. Fallbacking to 8 hours");
-                    targetHours = 8;
-                }
-            }
-            catch (err) {
-                throw new golemio_errors_1.CustomError("Error while parsing cron message", true, this.constructor.name, 5050, err);
-            }
-            // TODO Move model runs deletion to RunsWorker's DeleteDataTask after refactoring VehiclePositionsWorker
-            yield this.modelRuns.deleteNHoursOldData(targetHours);
-            yield this.modelTrips.deleteNHoursOldData(targetHours);
-            yield this.modelPositions.deleteNHoursOldData(targetHours);
-            yield this.modelTripsHistory.deleteNHoursOldData(targetHours);
-            yield this.modelPositionsHistory.deleteNHoursOldData(targetHours);
-        });
-        /**
-         * Create/update and process transformed run
-         */
-        this.processTransformedRun = (element) => __awaiter(this, void 0, void 0, function* () {
-            const record = yield this.modelRuns.getRunRecordForUpdate(element.run);
-            let outputMsg;
-            if (record) {
-                if (!element.run_message.actual_stop_timestamp_scheduled) {
-                    const lastRecordMessage = yield this.modelRuns["runsMessagesModel"].getLastMessage(record.id);
-                    if (!lastRecordMessage || !lastRecordMessage.actual_stop_timestamp_scheduled)
-                        return;
-                    element.run_message.actual_stop_timestamp_scheduled = lastRecordMessage.actual_stop_timestamp_scheduled;
-                }
-                outputMsg = yield this.modelRuns.updateAndAssociate(element, record.id);
-            }
-            else {
-                outputMsg = yield this.modelRuns.createAndAssociate(element);
-            }
-            yield this.sendMessageToExchange("workers." + this.queuePrefix + ".updateRunsGTFSTripId", JSON.stringify(outputMsg));
-        });
-        /**
-         * 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, undefined, VehiclePositionsUtils_1.VehiclePositionsUtils.getNextExpireTimestamp());
-                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
-         *
-         * @param {IProcessedPositions[]} computedResult - Arrays of all newly computed positions
-         * @returns {Object[]} - Arrays of inserted/updated positions and array of (inserted)/updated trips
-         */
-        this.updateComputedPositionsAndTrips = (computedResult) => __awaiter(this, void 0, void 0, function* () {
-            const positionsUpdated = yield this.modelPositions.bulkUpdate(computedResult.flatMap((e) => e.positions));
-            const tripsUpdated = yield this.modelTrips.bulkUpdate(computedResult.map((e) => ({
-                id: e.context.tripId,
-                last_position_id: e.context.lastPositionId,
-                last_position_context: e.context,
-                is_canceled: e.context.lastPositionCanceled,
-            })));
-            return {
-                positionsUpdated,
-                tripsUpdated,
-            };
-        });
-        /**
-         * Returns shape anchor points along trip track shape with stop times parameters
-         *
-         * @param {string} tripId - Internal DB trip id
-         * @returns {IComputationTrip} - Result with shape anchor points
-         */
-        this.getResultObjectForDelayCalculation = (tripId) => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const stopTimes = yield this.modelGTFSTrips.findByIdWithStopTimes(tripId);
-                const shapes = yield this.modelGTFSTrips.findByIdWithShapes(tripId);
-                if (!shapes || !shapes.shape_id || !shapes.shapes || shapes.shapes.length === 0) {
-                    throw new Error(`"trip.shape_id" or "trip.shapes" was not found for id ${tripId}.`);
-                }
-                if (!stopTimes || !stopTimes.stop_times || stopTimes.stop_times.length === 0) {
-                    throw new Error(`"trip.stop_times" was not found for id ${tripId}.`);
-                }
-                const shapesGeometryAnchorPoints = this.getShapesGeometryAnchorPoints(stopTimes.shape_id, shapes.shapes, stopTimes.stop_times);
-                // MAKING COPY
-                const shapePoints = [];
-                // const to determine shape points of stops (in meters)
-                const distanceBefore = 0.1;
-                const distanceAfter = 0.05;
-                for (let i = 0; i < shapesGeometryAnchorPoints.length; i++) {
-                    let bearing = 0;
-                    // add bearing from shape computed for previous shapePoint
-                    if (i > 0) {
-                        // compute bearing from two shape points
-                        let shapePointBearing = Math.round(turf.bearing(turf.point(shapesGeometryAnchorPoints[i - 1].coordinates), turf.point(shapesGeometryAnchorPoints[i].coordinates)));
-                        // turf.bearing returns -180 to 180, when 0 is north
-                        // we need 0 to 359, for negative value we substract from 360
-                        if (shapePointBearing < 0) {
-                            shapePointBearing = 360 - Math.abs(shapePointBearing);
-                        }
-                        // save bearing
-                        shapePoints[i - 1].bearing = shapePointBearing;
-                        // for the last shapePoint copy the bearing from last one
-                        if (shapesGeometryAnchorPoints.length - 1 === i) {
-                            bearing = shapePoints[i - 1].bearing;
-                        }
-                    }
-                    // init values
-                    let thisStopSequence = null;
-                    let lastStopSequence = shapesGeometryAnchorPoints[i].last_stop_sequence;
-                    let nextStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
-                    // these are origin stop_times shape point fron shapes table, clearly at stops points
-                    if (shapesGeometryAnchorPoints[i].this_stop_sequence) {
-                        thisStopSequence = shapesGeometryAnchorPoints[i].this_stop_sequence;
-                    }
-                    // if is shape anchor point in close distance AFTER LAST stop, then set it also AT STOP
-                    else if (i > 0 &&
-                        shapesGeometryAnchorPoints[i].shape_dist_traveled -
-                            stopTimes.stop_times[shapesGeometryAnchorPoints[i].last_stop_sequence - 1].shape_dist_traveled <=
-                            distanceAfter) {
-                        thisStopSequence = shapesGeometryAnchorPoints[i].last_stop_sequence;
-                    }
-                    // if is shape anchor point in close distance BEFORE NEXT stop, then set it also AT STOP
-                    else if (i < shapesGeometryAnchorPoints.length - 1 &&
-                        stopTimes.stop_times[shapesGeometryAnchorPoints[i].next_stop_sequence - 1].shape_dist_traveled -
-                            shapesGeometryAnchorPoints[i].shape_dist_traveled <=
-                            distanceBefore) {
-                        thisStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
-                        lastStopSequence = shapesGeometryAnchorPoints[i].next_stop_sequence;
-                        nextStopSequence = Math.min(shapesGeometryAnchorPoints[i].next_stop_sequence + 1, stopTimes.stop_times.length);
-                    }
-                    const distanceFromLastStop = Math.round((shapesGeometryAnchorPoints[i].shape_dist_traveled -
-                        stopTimes.stop_times[lastStopSequence - 1].shape_dist_traveled) *
-                        1000) / 1000;
-                    // if is trip at stop than set departure by this stop
-                    // between stops do linear interpolation from departure from last stop and arrival of next stop
-                    const timeScheduledSeconds = thisStopSequence !== null
-                        ? stopTimes.stop_times[lastStopSequence - 1].arrival_time_seconds
-                        : 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) *
-                                distanceFromLastStop) /
-                                (stopTimes.stop_times[nextStopSequence - 1].shape_dist_traveled -
-                                    stopTimes.stop_times[lastStopSequence - 1].shape_dist_traveled));
-                    shapePoints.push({
-                        index: i,
-                        at_stop: thisStopSequence !== null,
-                        bearing,
-                        coordinates: shapesGeometryAnchorPoints[i].coordinates,
-                        distance_from_last_stop: distanceFromLastStop,
-                        last_stop_sequence: lastStopSequence,
-                        next_stop_sequence: nextStopSequence,
-                        shape_dist_traveled: Math.round(shapesGeometryAnchorPoints[i].shape_dist_traveled * 100000) / 100000,
-                        this_stop_sequence: thisStopSequence,
-                        time_scheduled_seconds: timeScheduledSeconds,
-                    });
-                }
-                return {
-                    trip_id: tripId,
-                    stop_times: stopTimes.stop_times,
-                    shapes_anchor_points: shapePoints,
-                };
-            }
-            catch (err) {
-                helpers_1.log.error(err);
-                throw new golemio_errors_1.CustomError("Error while getting object for delay calculation (trip_id=" + tripId + ").", true, undefined, undefined, err);
-            }
-        });
-        /**
-         * Returns geometry of anchor points with distance from start along trip track shape
-         *
-         * @param {string} shapeId - GTFS shape id
-         * @param {ITransformedTripShape[]} shapes - GTFS shape points
-         * @param {IStopTime[]} stops
-         * @returns {IShapeGeometryAnchorPoint[]} - Result array of geometry points along trip track shape
-         */
-        this.getShapesGeometryAnchorPoints = (shapeId, shapes, stops) => {
-            try {
-                let segmentShapes = [];
-                // Splits shapes array to multiple arrays "delimited" by stops
-                for (let st = 0; st < stops.length; st++) {
-                    let currentSegment = [];
-                    for (let sh = 0; sh < shapes.length; sh++) {
-                        let shapePoint = Object.assign(Object.assign({}, shapes[sh]), { shape_at_stop: false });
-                        if (stops[st].shape_dist_traveled === shapes[sh].shape_dist_traveled) {
-                            shapePoint.shape_at_stop = true;
-                        }
-                        if (st < stops.length - 1 &&
-                            shapePoint.shape_dist_traveled >= stops[st].shape_dist_traveled &&
-                            shapePoint.shape_dist_traveled <= stops[st + 1].shape_dist_traveled) {
-                            currentSegment.push(shapePoint);
-                        }
-                    }
-                    if (currentSegment.length) {
-                        segmentShapes.push(currentSegment);
-                    }
-                }
-                let segmentArr = [];
-                // concat arrays of stop divided segments with distributed shape points
-                for (const segment of segmentShapes) {
-                    segmentArr = [...segmentArr, ...this.divideSegmentLine(segment)];
-                }
-                // Make initial shapesGeometryAnchorPoints
-                let stopCounter = 0;
-                const resultArr = segmentArr.map((segment, index) => {
-                    let this_stop_sequence;
-                    let last_stop_sequence;
-                    let next_stop_sequence;
-                    if (segment.shape_at_stop) {
-                        stopCounter++;
-                        this_stop_sequence = stopCounter;
-                    }
-                    else {
-                        this_stop_sequence = null;
-                    }
-                    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 [];
-            }
-        };
-        /**
-         * 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.modelPositionsHistory = new VehiclePositionsPositionsHistoryModel_1.VehiclePositionsPositionsHistoryModel();
-        this.modelRuns = new models_2.VehiclePositionsRunsModel();
-        this.transformationRuns = new transformations_1.VehiclePositionsRunsTransformation();
-        this.modelTrips = new models_2.VehiclePositionsTripsModel();
-        this.modelTripsHistory = new VehiclePositionsTripsHistoryModel_1.VehiclePositionsTripsHistoryModel();
-        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 RunTripsRedisRepository_1.RunTripsRedisRepository();
-        this.queuePrefix = config_1.config.RABBIT_EXCHANGE_NAME + "." + vehicle_positions_1.VehiclePositions.name.toLowerCase();
-        this.gtfsRtModel = new models_1.RedisModel("GTFSRealTimeModel", {
-            isKeyConstructedFromData: false,
-            prefix: "files:gtfsRt",
-        });
-        this.tripStopsModel = new models_1.RedisModel(vehicle_positions_1.VehiclePositions.tripStops.name + "Model", {
-            decodeDataAfterGet: JSON.parse,
-            encodeDataBeforeSave: JSON.stringify,
-            isKeyConstructedFromData: false,
-            prefix: vehicle_positions_1.VehiclePositions.tripStops.namespacePrefix,
-        }, new golemio_validator_1.Validator(vehicle_positions_1.VehiclePositions.tripStops.name + "ModelValidator", vehicle_positions_1.VehiclePositions.tripStops.outputMongooseSchemaObject));
-        this.modelGTFSTrips = new RopidGTFSTripsModel_1.RopidGTFSTripsModel();
-        this.modelGTFSStopTimes = new RopidGTFSStopTimesModel_1.RopidGTFSStopTimesModel();
-        this.gtfsRtAlertsController = new GtfsRtAlertsController_1.GtfsRtAlertsController(this.gtfsRtModel, new ropid_vymi_1.RopidVYMIEventsModel(), new GtfsRtAlertTransformation_1.GtfsRtAlertTransformation(new ropid_vymi_1.RopidVYMIEventsRoutesModel()));
-        this.gtfsTripRunManager = GTFSTripRunManagerFactory_1.GTFSTripRunManagerFactory.create(GTFSTripRunManagerFactory_1.GTFSTripRunType.Common, this.modelPositions, this.modelTrips, this.modelRuns, this.runTripsModel);
-    }
-}
-exports.VehiclePositionsWorker = VehiclePositionsWorker;
-//# sourceMappingURL=VehiclePositionsWorker.js.map