From efd7bd3322d52cd5e039788ee92f1d06da0276d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Anton=20Jyrki=C3=A4inen?= <anton.jyrkiainen@helsinki.fi>
Date: Thu, 23 Apr 2026 13:48:30 +0300
Subject: [PATCH] logic change for selecting valid journey data

---
 src/datasources/JoreDataSource.ts |  6 +++
 src/utils/filterByDateGroups.ts   | 62 ++++++++++++++++++++++---------
 2 files changed, 51 insertions(+), 17 deletions(-)

diff --git a/src/datasources/JoreDataSource.ts b/src/datasources/JoreDataSource.ts
index 7249ac1..0535d55 100644
--- a/src/datasources/JoreDataSource.ts
+++ b/src/datasources/JoreDataSource.ts
@@ -53,6 +53,7 @@ export class JoreDataSource extends SQLDataSource {
                        route.date_begin,
                        route.date_end,
                        route.date_modified,
+                       route.date_imported,
                        route.route_length,
                        trunk_route,
                        jore.route_mode(route) as mode
@@ -78,6 +79,7 @@ export class JoreDataSource extends SQLDataSource {
                        route.date_begin,
                        route.date_end,
                        route.date_modified,
+                       route.date_imported,
                        route.route_length,
                        trunk_route,
                        jore.route_mode(route) as mode
@@ -139,6 +141,7 @@ export class JoreDataSource extends SQLDataSource {
               route_segment.timing_stop_type,
               route_segment.stop_index,
               route_segment.date_modified,
+              route_segment.date_imported,
               jore.route_mode(route) as mode,
               stop.lat,
               stop.lon,
@@ -189,6 +192,7 @@ export class JoreDataSource extends SQLDataSource {
                  stop.name_fi,
                  stop.stop_radius,
                  route_segment.date_modified,
+                 route_segment.date_imported,
                  route_segment.route_id,
                  route_segment.direction,
                  route_segment.timing_stop_type,
@@ -327,6 +331,7 @@ export class JoreDataSource extends SQLDataSource {
        route_segment.date_begin,
        route_segment.date_end,
        route_segment.date_modified,
+       route_segment.date_imported,
        route_segment.duration,
        route_segment.stop_index,
        route_segment.distance_from_previous,
@@ -416,6 +421,7 @@ stop.terminal_id,
 route_segment.date_begin,
 route_segment.date_end,
 route_segment.date_modified,
+route_segment.date_imported,
 route_segment.destination_fi,
 route_segment.distance_from_previous,
 route_segment.distance_from_start,
diff --git a/src/utils/filterByDateGroups.ts b/src/utils/filterByDateGroups.ts
index 126bfe2..21c8cb9 100644
--- a/src/utils/filterByDateGroups.ts
+++ b/src/utils/filterByDateGroups.ts
@@ -3,15 +3,21 @@ import { groupBy, orderBy } from 'lodash'
 import moment from 'moment-timezone'
 import { TZ } from '../constants'
 
-export function filterByDateGroups<T extends ValidityRange>(items: T[], date: string): T[] {
-  let groupedItems = groupBy<T>(items, (item: T) => `${item.date_begin}_${item.date_end}`)
-  let hasModifiedDate = !!items[0]?.date_modified
-  let validOnDate = moment.tz(date, TZ)
+type ValidityRangeWithImport = ValidityRange & {
+  date_imported?: string
+}
+
+export function filterByDateGroups<T extends ValidityRangeWithImport>(
+  items: T[],
+  date: string
+): T[] {
+  const groupedItems = groupBy(items, (item) => `${item.date_begin}_${item.date_end}`)
+  const validOnDate = moment.tz(date, TZ)
 
-  let validGroupEntries = Object.entries<T[]>(groupedItems).filter(([validityRange]) => {
-    let range = validityRange.split('_')
-    let rangeStart = moment.tz(range[0], TZ)
-    let rangeEnd = moment.tz(range[1], TZ)
+  const validGroupEntries = Object.entries(groupedItems).filter(([validityRange]) => {
+    const [start, end] = validityRange.split('_')
+    const rangeStart = moment.tz(start, TZ)
+    const rangeEnd = moment.tz(end, TZ)
 
     return validOnDate.isBetween(rangeStart, rangeEnd, 'day', '[]')
   })
@@ -27,16 +33,38 @@ export function filterByDateGroups<T extends ValidityRange>(items: T[], date: st
     return validGroupEntries[0][1]
   }
 
-  let orderedGroups = orderBy(
+  const getLatestAllowedImportUnix = (groupItems: T[]) => {
+    const allowedImports = groupItems
+      .map((item) => item.date_imported)
+      .filter((d): d is string => !!d)
+      .map((d) => moment.tz(d, TZ))
+      .filter((importDate) => importDate.isSameOrBefore(validOnDate, 'day'))
+
+    if (allowedImports.length === 0) {
+      return null
+    }
+
+    return Math.max(...allowedImports.map((d) => d.unix()))
+  }
+
+  const hasAnyAllowedImports = validGroupEntries.some(([, groupItems]) => {
+    return getLatestAllowedImportUnix(groupItems) !== null
+  })
+
+  const orderedGroups = orderBy(
     validGroupEntries,
-    ([, items]) => {
-      // if (hasModifiedDate) {
-      //   return moment(items[0].date_modified).unix()
-      // }
-
-      return moment(items[0].date_begin).unix()
-    },
-    'desc'
+    hasAnyAllowedImports
+      ? [
+          // First order by the latest allowed date_imported, so that groups with more recent imports that are still valid on the UI date come first.
+          ([, groupItems]) => getLatestAllowedImportUnix(groupItems) ?? 0,
+          // If there are multiple groups with the same latest allowed import date order those groups by date_begin.
+          ([, groupItems]) => moment.tz(groupItems[0].date_begin, TZ).unix(),
+        ]
+      : [
+          // If there are no allowed date_importeds just order by date_begin.
+          ([, groupItems]) => moment.tz(groupItems[0].date_begin, TZ).unix(),
+        ],
+    hasAnyAllowedImports ? ['desc', 'desc'] : ['desc']
   )
 
   return orderedGroups[0][1] // Select the items from the first, ie most valid, group.