feat: implement cancellation deadline for paid events

Refs: LINK-2469

Author: tjgofore

public/locales/en/signup.json

@@ -134,6 +134,7 @@
     "eventStarted": "The event has already started and registration cannot be cancelled.",
     "hasPaymentCancellation": "The payment is being cancelled and cannot be modified.",
     "hasPaymentRefund": "The payment is being refunded and cannot be modified.",
-    "insufficientPermissions": "You do not have the right to edit registration details."
+    "insufficientPermissions": "You do not have the right to edit registration details.",
+    "paidEventCancellationDeadlinePassed": "Registration for a paid event can be cancelled no later than {{days}} days before the event starts."
   }
 }

public/locales/fi/signup.json

@@ -133,6 +133,7 @@
     "eventStarted": "Tapahtuman on jo alkanut eikä ilmoittautumista voi perua.",
     "hasPaymentCancellation": "Ilmoittautumisen maksua perutaan eikä sitä voi muokata.",
     "hasPaymentRefund": "Ilmoittautumisen maksua hyvitetään eikä sitä voi muokata.",
-    "insufficientPermissions": "Sinulla ei ole oikeuksia muokata ilmoittautumisen tietoja."
+    "insufficientPermissions": "Sinulla ei ole oikeuksia muokata ilmoittautumisen tietoja.",
+    "paidEventCancellationDeadlinePassed": "Maksullisen tapahtuman ilmoittautumisen voi perua viimeistään {{days}} päivää ennen tapahtuman alkua."
   }
 }

public/locales/sv/signup.json

@@ -133,6 +133,7 @@
     "eventStarted": "Evenemanget har redan börjat och registreringen kan inte avbrytas.",
     "hasPaymentCancellation": "Anmälningsavgiften annulleras och kan inte ändras.",
     "hasPaymentRefund": "Anmälningsavgiften återbetalas och kan inte ändras.",
-    "insufficientPermissions": "Du har inte rätt att ändra dina registreringsuppgifter."
+    "insufficientPermissions": "Du har inte rätt att ändra dina registreringsuppgifter.",
+    "paidEventCancellationDeadlinePassed": "Anmälan till ett avgiftsbelagt evenemang kan avbokas senast {{days}} dagar före evenemangets start."
   }
 }

src/domain/event/__tests__/utils.test.ts

@@ -27,6 +27,7 @@ import {
   getEventFields,
   getEventLocationText,
   isEventStarted,
+  isPaidEventCancellationDeadlinePassed,
 } from '../utils';
 
 afterEach(() => {
@@ -367,6 +368,64 @@ describe('isEventStarted', () => {
   );
 });
 
+describe('isPaidEventCancellationDeadlinePassed', () => {
+  it('should return false for free events', () => {
+    const result = isPaidEventCancellationDeadlinePassed({
+      event: fakeEvent({
+        offers: fakeOffers(1, [{ is_free: true }]),
+        start_time: '2026-02-02T12:00:00Z',
+      }),
+      now: new Date('2026-01-27T00:00:00Z'),
+    });
+
+    expect(result).toBe(false);
+  });
+
+  it('should allow cancellation until 23:59:59 on the cutoff day in Helsinki time', () => {
+    const paidEvent = fakeEvent({
+      offers: fakeOffers(1, [{ is_free: false }]),
+      // Event starts on 2.2.2026 at 14:00 in Helsinki time (UTC+2 => 12:00Z)
+      start_time: '2026-02-02T12:00:00Z',
+    });
+
+    const allowed = isPaidEventCancellationDeadlinePassed({
+      event: paidEvent,
+      // 26.1.2026 23:59:59 in Helsinki time (UTC+2 => 21:59:59Z)
+      now: new Date('2026-01-26T21:59:59Z'),
+    });
+    const blocked = isPaidEventCancellationDeadlinePassed({
+      event: paidEvent,
+      // 27.1.2026 00:00:00 in Helsinki time (UTC+2 => 22:00:00Z)
+      now: new Date('2026-01-26T22:00:00Z'),
+    });
+
+    expect(allowed).toBe(false);
+    expect(blocked).toBe(true);
+  });
+
+  it('should keep cutoff at Helsinki midnight across spring DST transition', () => {
+    const paidEvent = fakeEvent({
+      offers: fakeOffers(1, [{ is_free: false }]),
+      // Event starts on 1.4.2026 at 14:00 in Helsinki time (UTC+3 => 11:00Z)
+      start_time: '2026-04-01T11:00:00Z',
+    });
+
+    const allowed = isPaidEventCancellationDeadlinePassed({
+      event: paidEvent,
+      // 25.3.2026 23:59:59 in Helsinki time (UTC+2 => 21:59:59Z)
+      now: new Date('2026-03-25T21:59:59Z'),
+    });
+    const blocked = isPaidEventCancellationDeadlinePassed({
+      event: paidEvent,
+      // 26.3.2026 00:00:00 in Helsinki time (UTC+2 => 22:00:00Z)
+      now: new Date('2026-03-25T22:00:00Z'),
+    });
+
+    expect(allowed).toBe(false);
+    expect(blocked).toBe(true);
+  });
+});
+
 describe('userPathBuilder function', () => {
   const testCases: [Partial<EventQueryVariables>, string][] = [
     [{}, '/event/123/?nocache=true'],

src/domain/event/utils.ts

@@ -1,5 +1,7 @@
 import { AxiosError } from 'axios';
+import isAfter from 'date-fns/isAfter';
 import isPast from 'date-fns/isPast';
+import { formatInTimeZone, zonedTimeToUtc } from 'date-fns-tz';
 import { DateArray, DateTime, EventAttributes, createEvents } from 'ics';
 import { TFunction } from 'next-i18next';
 
@@ -13,6 +15,26 @@ import { getPlaceFields } from '../place/utils';
 import { EventStatus, PublicationStatus, SuperEventType } from './constants';
 import { Event, EventFields, EventQueryVariables } from './types';
 
+export const PAID_EVENT_CANCELLATION_DEADLINE_DAYS = 7;
+const HELSINKI_TIME_ZONE = 'Europe/Helsinki';
+
+const getHelsinkiStartOfDayFromDateString = (dateString: string): Date =>
+  zonedTimeToUtc(`${dateString}T00:00:00`, HELSINKI_TIME_ZONE);
+
+const getHelsinkiStartOfDay = (date: Date): Date =>
+  getHelsinkiStartOfDayFromDateString(
+    formatInTimeZone(date, HELSINKI_TIME_ZONE, 'yyyy-MM-dd')
+  );
+
+// Use UTC date arithmetic on yyyy-mm-dd to avoid runtime TZ and DST drift.
+const subtractDaysFromDateString = (dateString: string, days: number): string => {
+  const [year, month, day] = dateString.split('-').map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  date.setUTCDate(date.getUTCDate() - days);
+
+  return date.toISOString().slice(0, 10);
+};
+
 export const getEventFields = (event: Event, locale: Language): EventFields => {
   return {
     audienceMaxAge: event.audience_max_age || null,
@@ -193,3 +215,34 @@ export const isEventStarted = (event: Event): boolean => {
   const startTime = event.start_time ? new Date(event.start_time) : null;
   return startTime ? isPast(startTime) : false;
 };
+
+export const isPaidEvent = (event: Event): boolean =>
+  event.offers.some((offer) => !!offer && offer.is_free === false);
+
+export const isPaidEventCancellationDeadlinePassed = ({
+  event,
+  now = new Date(),
+}: {
+  event: Event;
+  now?: Date;
+}): boolean => {
+  if (!event.start_time || !isPaidEvent(event)) {
+    return false;
+  }
+
+  const eventStartDateInHelsinki = formatInTimeZone(
+    new Date(event.start_time),
+    HELSINKI_TIME_ZONE,
+    'yyyy-MM-dd'
+  );
+  const latestCancellationDateInHelsinki = subtractDaysFromDateString(
+    eventStartDateInHelsinki,
+    PAID_EVENT_CANCELLATION_DEADLINE_DAYS
+  );
+  const latestCancellationDay = getHelsinkiStartOfDayFromDateString(
+    latestCancellationDateInHelsinki
+  );
+
+  // Cancellation is allowed for the full cutoff day and disabled starting next day.
+  return isAfter(getHelsinkiStartOfDay(now), latestCancellationDay);
+};

src/domain/signup/__tests__/EditSignupPage.test.tsx

@@ -11,6 +11,7 @@ import mockRouter from 'next-router-mock';
 import React from 'react';
 
 import { ExtendedSession } from '../../../types';
+import { fakeOffers } from '../../../utils/mockDataUtils';
 import { fakeAuthenticatedSession } from '../../../utils/mockSession';
 import {
   actWait,
@@ -64,7 +65,17 @@ test.skip('page is accessible', async () => {
 
 const mockedRegistrationResponse = rest.get(
   `*/registration/${TEST_REGISTRATION_ID}/`,
-  (req, res, ctx) => res(ctx.status(200), ctx.json(registration))
+  (req, res, ctx) =>
+    res(
+      ctx.status(200),
+      ctx.json({
+        ...registration,
+        event: {
+          ...registration.event,
+          offers: fakeOffers(1, [{ is_free: true }]),
+        },
+      })
+    )
 );
 const mockedSignupResponse = rest.get(`*/signup/*`, (req, res, ctx) =>
   res(ctx.status(200), ctx.json(signup))