Add logic to rebuild if the next upcoming event has ended

Author: kurisu-dotto-komu

.github/workflows/scheduler.yml

@@ -11,33 +11,53 @@ jobs:
     name: Check for content updates
     runs-on: ubuntu-latest
     outputs:
-      has-updates: ${{ steps.check-commit.outputs.has-updates }}
-      new-commit: ${{ steps.check-commit.outputs.new-commit }}
+      has-updates: ${{ steps.check-updates.outputs.has-updates }}
+      new-commit: ${{ steps.check-updates.outputs.new-commit }}
 
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Check for new upstream commit
-        id: check-commit
+      - name: Check for new upstream commit or event end
+        id: check-updates
         run: |
           UPSTREAM_REPO="owddm/public"
 
           # Read current commit from meta.json
           CURRENT_COMMIT=$(jq -r '.commitHash' content/meta.json)
           echo "Current commit: $CURRENT_COMMIT"
 
+          # Read nextEventEnds from meta.json
+          NEXT_EVENT_ENDS=$(jq -r '.nextEventEnds' content/meta.json)
+          echo "Next event ends: $NEXT_EVENT_ENDS"
 
           # Get latest commit from upstream main branch
           LATEST_COMMIT=$(curl -s "https://api.github.com/repos/$UPSTREAM_REPO/commits/main" | jq -r '.sha')
           echo "Latest upstream commit: $LATEST_COMMIT"
 
+          # Check if we need to trigger a build
+          NEEDS_BUILD=false
+
+          # Check for new commit
           if [ "$CURRENT_COMMIT" != "$LATEST_COMMIT" ]; then
             echo "New commit detected!"
-            echo "has-updates=true" >> $GITHUB_OUTPUT
+            NEEDS_BUILD=true
             echo "new-commit=$LATEST_COMMIT" >> $GITHUB_OUTPUT
+          fi
+
+          # Check if an event has ended and we need to rebuild
+          if [ "$NEXT_EVENT_ENDS" != "null" ] && [ "$NEXT_EVENT_ENDS" != "" ]; then
+            CURRENT_TIME=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
+            if [[ "$CURRENT_TIME" > "$NEXT_EVENT_ENDS" ]]; then
+              echo "Event has ended, triggering rebuild to update event status"
+              NEEDS_BUILD=true
+            fi
+          fi
+
+          if [ "$NEEDS_BUILD" = true ]; then
+            echo "has-updates=true" >> $GITHUB_OUTPUT
           else
-            echo "No new commits"
+            echo "No updates needed"
             echo "has-updates=false" >> $GITHUB_OUTPUT
           fi
 

scripts/import-data/lib/import.ts

@@ -1,6 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 
+import { filterUpcomingEvents, getEventEndTimeWithBuffer } from "@/utils/eventFilters";
+
 import { CONTENT_DIR, getGithubRawUrl } from "./constants";
 import { processEvent } from "./events";
 import { githubFetchJSON } from "./github-fetch";
@@ -197,10 +199,52 @@ export async function handleImport(args: string[]) {
 
   // Create meta.json
   logger.section("Creating Metadata");
+
+  // Calculate nextEventEnds - the end time of the next upcoming event
+  let nextEventEnds: string | null = null;
+
+  // Convert events to match the EventWithDateTime interface
+  const allEvents = [];
+  for (const [, groupData] of Object.entries(eventsWithVenuesJSON.groups)) {
+    for (const event of groupData.events) {
+      allEvents.push({
+        data: {
+          dateTime: new Date(event.time),
+          duration: event.duration ? Math.round(event.duration / 60000) : undefined,
+        },
+        // Keep additional properties for logging
+        title: event.title,
+        id: event.id,
+      });
+    }
+  }
+
+  // Get upcoming events using the existing filter
+  const upcomingEvents = filterUpcomingEvents(allEvents);
+
+  if (upcomingEvents.length > 0) {
+    // Sort by end time to get the event that will end soonest
+    upcomingEvents.sort((a, b) => {
+      const aEndTime = getEventEndTimeWithBuffer(a).getTime();
+      const bEndTime = getEventEndTimeWithBuffer(b).getTime();
+      return aEndTime - bEndTime;
+    });
+
+    // Get the event that will end soonest
+    const nextEventToEnd = upcomingEvents[0];
+    const endTime = getEventEndTimeWithBuffer(nextEventToEnd);
+    nextEventEnds = endTime.toISOString();
+
+    logger.info(`Next event ends: ${nextEventEnds} (Event: "${nextEventToEnd.title}")`);
+  } else {
+    logger.info("No upcoming events found");
+  }
+
   const metaData = {
     commitDate: commitInfo.date,
     commitHash: commitInfo.sha,
     repository: "https://github.com/owddm/public",
+    nextEventEnds,
   };
 
   const metaPath = path.join(CONTENT_DIR, "meta.json");

src/utils/eventFilters.ts

@@ -3,10 +3,18 @@ import type { EventEnriched } from "@/content";
 // an event is considered "ended" if it has ended + 30 min buffer
 const BUFFER_MINUTES = 30;
 
+// Minimal event data interface that can be satisfied by both EventEnriched and import data
+interface EventWithDateTime {
+  data: {
+    dateTime: Date;
+    duration?: number;
+  };
+}
+
 /**
  * Calculates the end time of an event including a buffer period
  */
-export function getEventEndTimeWithBuffer(event: EventEnriched): Date {
+export function getEventEndTimeWithBuffer(event: EventWithDateTime): Date {
   const startTime = new Date(event.data.dateTime);
   const durationMinutes = event.data.duration || 120; // Default 2 hours if not specified
   const totalMinutes = durationMinutes + BUFFER_MINUTES;
@@ -18,7 +26,7 @@ export function getEventEndTimeWithBuffer(event: EventEnriched): Date {
  * Checks if an event should be shown as upcoming
  * Events are considered upcoming if they haven't ended (including 30 min buffer)
  */
-export function isEventUpcoming(event: EventEnriched, currentTime: Date = new Date()): boolean {
+export function isEventUpcoming(event: EventWithDateTime, currentTime: Date = new Date()): boolean {
   const endTimeWithBuffer = getEventEndTimeWithBuffer(event);
   return endTimeWithBuffer > currentTime;
 }
@@ -27,35 +35,35 @@ export function isEventUpcoming(event: EventEnriched, currentTime: Date = new Da
  * Checks if an event should be shown as recent
  * Events are considered recent if they have ended (including 30 min buffer)
  */
-export function isEventRecent(event: EventEnriched, currentTime: Date = new Date()): boolean {
+export function isEventRecent(event: EventWithDateTime, currentTime: Date = new Date()): boolean {
   const endTimeWithBuffer = getEventEndTimeWithBuffer(event);
   return endTimeWithBuffer <= currentTime;
 }
 
 /**
  * Filters events to get upcoming ones (haven't ended + 30 min buffer)
  */
-export function filterUpcomingEvents(
-  events: EventEnriched[],
+export function filterUpcomingEvents<T extends EventWithDateTime>(
+  events: T[],
   currentTime: Date = new Date(),
-): EventEnriched[] {
+): T[] {
   return events.filter((event) => isEventUpcoming(event, currentTime));
 }
 
 /**
  * Filters events to get recent ones (have ended + 30 min buffer)
  */
-export function filterRecentEvents(
-  events: EventEnriched[],
+export function filterRecentEvents<T extends EventWithDateTime>(
+  events: T[],
   currentTime: Date = new Date(),
-): EventEnriched[] {
+): T[] {
   return events.filter((event) => isEventRecent(event, currentTime));
 }
 
 /**
  * Checks if an event is a legacy event (2025.10.10 or earlier)
  */
-export function isLegacyEvent(event: EventEnriched): boolean {
+export function isLegacyEvent(event: EventWithDateTime | EventEnriched): boolean {
   const eventDate = new Date(event.data.dateTime);
   const legacyCutoff = new Date("2025-10-10T23:59:59");
   return eventDate <= legacyCutoff;