mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-10-19 21:46:49 +00:00
Maurice
146fe4a063
The guides of the map, bookings, costs, files, collab, lists, road trip and transports now describe the desktop as it is after the redesign: the bars with their icon buttons and filter popovers, the dialogs with the title in the head band and status and type as pills, the three booking views and the booking detail, the compact note cards, the Costs table. Two guides are new: the booking views (cards, list, timeline, the Trip and Day zoom and the detail) and the Costs table view. Every changed text is translated into every locale, and the Plan tab texts call the bookings tab by the label it shows, Book. Every picture of the thirteen trip screens is taken again against the new layout, on one picture day. Scripts follow the new markup; the Dawarich fixture uploads its recording again when the stored one belongs to another run, and the spare poll gets its vote from a member so its winner shows green. server-launch.mjs skips the server build with E2E_SERVER_PREBUILT, so several recordings on their own port pairs can share one dist.
2161 lines
111 KiB
TypeScript
2161 lines
111 KiB
TypeScript
import sharp from 'sharp'
|
||
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
|
||
import path from 'node:path'
|
||
import { gzipSync } from 'node:zlib'
|
||
import { request as apiRequest, type APIRequestContext, type Page } from '@playwright/test'
|
||
import { E2E_BASE_URL, E2E_SEED_FILE } from '../../playwright.config'
|
||
import { OUT_DIR, PICTURE_DAY } from './guide'
|
||
import { at, day, emlDate, mailHeaderDate, short } from '../dates'
|
||
|
||
/**
|
||
* What the dashboard guides act on beyond the seeded trip.
|
||
*
|
||
* The seed's "Autumn in Japan" is the running trip, so it sits in the boarding
|
||
* pass rather than in the grid. The card actions (edit, duplicate, archive,
|
||
* delete) need cards, so two more trips are created over the API once, before
|
||
* the first guide runs. Uploads use a drawn dusk-over-mountains cover rather
|
||
* than a photograph: nothing in the repo may carry someone's picture.
|
||
*/
|
||
|
||
export const EXTRA_TRIPS = [
|
||
{ title: 'Weekend in Lisbon', description: 'Pastéis, miradouros and a day trip to Sintra.', start_date: day(25), end_date: day(27), currency: 'EUR' },
|
||
{ title: 'Norway Road Trip', description: 'Bergen to the Lofoten, fjord by fjord.', start_date: day(257), end_date: day(271), currency: 'NOK' },
|
||
]
|
||
|
||
export async function ensureExtraTrips(api: APIRequestContext): Promise<void> {
|
||
const res = await api.get('/api/trips')
|
||
const body = (await res.json()) as { trips?: { title: string }[] } | { title: string }[]
|
||
const trips = Array.isArray(body) ? body : (body.trips ?? [])
|
||
for (const trip of EXTRA_TRIPS) {
|
||
if (trips.some(t => t.title === trip.title)) continue
|
||
const created = await api.post('/api/trips', { data: trip })
|
||
if (!created.ok()) throw new Error(`could not create "${trip.title}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
}
|
||
|
||
/** Path of a 1600×900 JPEG the cover guide uploads; drawn on first use. */
|
||
export async function coverFixture(): Promise<string> {
|
||
mkdirSync(OUT_DIR, { recursive: true })
|
||
const file = path.join(OUT_DIR, 'cover-fixture.jpg')
|
||
if (existsSync(file)) return file
|
||
const svg = `
|
||
<svg xmlns="http://www.w3.org/2000/svg" width="1600" height="900" viewBox="0 0 1600 900">
|
||
<defs>
|
||
<linearGradient id="sky" x1="0" y1="0" x2="0" y2="1">
|
||
<stop offset="0" stop-color="#1b1f3b"/>
|
||
<stop offset="0.45" stop-color="#6b3d7a"/>
|
||
<stop offset="0.75" stop-color="#e8865a"/>
|
||
<stop offset="1" stop-color="#f7c36b"/>
|
||
</linearGradient>
|
||
<radialGradient id="sun" cx="0.5" cy="0.5" r="0.5">
|
||
<stop offset="0" stop-color="#fff2c2"/>
|
||
<stop offset="0.6" stop-color="#ffb35c"/>
|
||
<stop offset="1" stop-color="#ffb35c" stop-opacity="0"/>
|
||
</radialGradient>
|
||
</defs>
|
||
<rect width="1600" height="900" fill="url(#sky)"/>
|
||
<circle cx="1090" cy="560" r="150" fill="url(#sun)"/>
|
||
<path d="M0 640 L180 520 L330 600 L480 470 L640 590 L800 500 L960 610 L1120 540 L1280 620 L1440 560 L1600 640 L1600 900 L0 900 Z" fill="#2a2140" opacity="0.85"/>
|
||
<path d="M0 720 L200 640 L360 700 L560 600 L720 690 L900 640 L1080 720 L1260 660 L1440 730 L1600 700 L1600 900 L0 900 Z" fill="#1a1530"/>
|
||
<path d="M0 820 Q400 760 800 800 T1600 790 L1600 900 L0 900 Z" fill="#100c1f"/>
|
||
</svg>`
|
||
await sharp(Buffer.from(svg)).jpeg({ quality: 88 }).toFile(file)
|
||
return file
|
||
}
|
||
|
||
/** Trip card in the grid by its title. */
|
||
export function card(page: Page, title: string) {
|
||
return page.locator('.trip-card').filter({ hasText: title }).first()
|
||
}
|
||
|
||
// ── Atlas ─────────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* What the Atlas guides act on. The seed's Japan trip colours one country;
|
||
* a map with a single country on it says nothing about what the screen does,
|
||
* so a handful of countries are marked by hand (the way someone catching up
|
||
* on their pre-TREK travels would), one wish goes on the bucket list, and the
|
||
* Lisbon trip gets a place so Portugal shows up as planned and the "Show
|
||
* planned countries" switch exists at all.
|
||
*/
|
||
export const ATLAS_MARKED = ['IT', 'ES', 'FR', 'TH', 'MA']
|
||
export const ATLAS_WISH = { name: 'New Zealand', country_code: 'NZ' }
|
||
export const PLANNED_PLACE = {
|
||
trip: 'Weekend in Lisbon',
|
||
place: { name: 'Belém Tower', lat: 38.6916, lng: -9.216, address: 'Av. Brasília, 1400-038 Lisboa, Portugal' },
|
||
}
|
||
|
||
export async function ensureAtlasFixtures(api: APIRequestContext): Promise<void> {
|
||
await ensureExtraTrips(api)
|
||
|
||
const res = await api.get('/api/trips')
|
||
const body = (await res.json()) as { trips?: { id: number; title: string }[] } | { id: number; title: string }[]
|
||
const trips = Array.isArray(body) ? body : (body.trips ?? [])
|
||
const lisbon = trips.find(t => t.title === PLANNED_PLACE.trip)
|
||
if (!lisbon) throw new Error(`fixture trip "${PLANNED_PLACE.trip}" is missing`)
|
||
const placesRes = await api.get(`/api/trips/${lisbon.id}/places`)
|
||
const placesBody = (await placesRes.json()) as { places?: { name: string }[] } | { name: string }[]
|
||
const places = Array.isArray(placesBody) ? placesBody : (placesBody.places ?? [])
|
||
if (!places.some(p => p.name === PLANNED_PLACE.place.name)) {
|
||
const created = await api.post(`/api/trips/${lisbon.id}/places`, { data: PLANNED_PLACE.place })
|
||
if (!created.ok()) throw new Error(`could not create "${PLANNED_PLACE.place.name}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
// Idempotent on the server (INSERT OR IGNORE), so no lookup first.
|
||
for (const code of ATLAS_MARKED) {
|
||
const marked = await api.post(`/api/addons/atlas/country/${code}/mark`)
|
||
if (!marked.ok()) throw new Error(`could not mark ${code}: ${marked.status()}`)
|
||
}
|
||
|
||
const listRes = await api.get('/api/addons/atlas/bucket-list')
|
||
const { items } = (await listRes.json()) as { items: { country_code: string | null; target_date: string | null }[] }
|
||
if (!items.some(i => i.country_code === ATLAS_WISH.country_code && !i.target_date)) {
|
||
const wish = await api.post('/api/addons/atlas/bucket-list', { data: ATLAS_WISH })
|
||
if (!wish.ok()) throw new Error(`could not add the ${ATLAS_WISH.name} wish: ${wish.status()} ${await wish.text()}`)
|
||
}
|
||
}
|
||
|
||
// ── Journey ───────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* What the Journey guides act on. The seed creates "Autumn in Japan" from the
|
||
* trip, which leaves a timeline of suggestions and nothing written. Three of
|
||
* them get a story, a mood and the weather, and the first one a photo, so the
|
||
* journal looks lived-in; the rest stay suggestions for the guide about them.
|
||
*/
|
||
export const JOURNEY_TITLE = 'Autumn in Japan'
|
||
const ENTRIES = [
|
||
{
|
||
title: 'First morning in Asakusa',
|
||
story: 'Up before the shops. The Kaminarimon lantern with nobody under it, incense smoke drifting across the courtyard, and a bowl of soba from a counter that opened just as we arrived.',
|
||
mood: 'amazing', weather: 'sunny', tags: ['hidden gem', 'early start'],
|
||
},
|
||
{
|
||
title: 'Barefoot through the light',
|
||
story: 'teamLab Planets is best without expectations. You wade through warm water while koi drawn from light swim around your ankles, then lie under a ceiling of orchids that moves out of your way.',
|
||
mood: 'good', weather: 'partly', tags: ['best moment'],
|
||
},
|
||
{
|
||
title: 'The crossing, from above',
|
||
story: 'Shibuya from the Sky deck at dusk: the scramble fills and empties every ninety seconds like a tide. Rough evening otherwise, the rain came in sideways and the umbrella did not make it home.',
|
||
mood: 'rough', weather: 'rainy', tags: ['viewpoint'],
|
||
pros_cons: { pros: ['The view at blue hour', 'Timed entry, no queue'], cons: ['Rain, then more rain', 'Crowded lift'] },
|
||
},
|
||
]
|
||
|
||
/** A second, future journey, so the list has a card below the banner. */
|
||
export const SECOND_JOURNEY = { title: 'Fjords and ferries', subtitle: 'Norway, next summer', trip: 'Norway Road Trip' }
|
||
/** A trip no journey has claimed, for the guide that links one. */
|
||
export const SPARE_TRIP = { title: 'Alps by rail', description: 'Zurich to Venice over the Bernina.', start_date: day(144), end_date: day(151), currency: 'CHF' }
|
||
|
||
export async function ensureJourneyFixtures(api: APIRequestContext): Promise<number> {
|
||
const listRes = await api.get('/api/journeys')
|
||
const { journeys } = (await listRes.json()) as { journeys: { id: number; title: string }[] }
|
||
const journey = journeys.find(j => j.title === JOURNEY_TITLE)
|
||
if (!journey) throw new Error(`fixture journey "${JOURNEY_TITLE}" is missing`)
|
||
|
||
if (!journeys.some(j => j.title === SECOND_JOURNEY.title)) {
|
||
const tripsRes = await api.get('/api/trips')
|
||
const tripsBody = (await tripsRes.json()) as { trips?: { id: number; title: string }[] } | { id: number; title: string }[]
|
||
const trips = Array.isArray(tripsBody) ? tripsBody : (tripsBody.trips ?? [])
|
||
const norway = trips.find(t => t.title === SECOND_JOURNEY.trip)
|
||
if (!norway) throw new Error(`fixture trip "${SECOND_JOURNEY.trip}" is missing`)
|
||
const created = await api.post('/api/journeys', { data: { title: SECOND_JOURNEY.title, subtitle: SECOND_JOURNEY.subtitle, trip_ids: [norway.id] } })
|
||
if (!created.ok()) throw new Error(`could not create "${SECOND_JOURNEY.title}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
const spareRes = await api.get('/api/trips')
|
||
const spareBody = (await spareRes.json()) as { trips?: { title: string }[] } | { title: string }[]
|
||
const allTrips = Array.isArray(spareBody) ? spareBody : (spareBody.trips ?? [])
|
||
if (!allTrips.some(t => t.title === SPARE_TRIP.title)) {
|
||
const created = await api.post('/api/trips', { data: SPARE_TRIP })
|
||
if (!created.ok()) throw new Error(`could not create "${SPARE_TRIP.title}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
const entriesRes = await api.get(`/api/journeys/${journey.id}/entries`)
|
||
const { entries } = (await entriesRes.json()) as { entries: { id: number; type: string; title: string | null }[] }
|
||
if (entries.some(e => e.title === ENTRIES[0].title)) return journey.id
|
||
|
||
const skeletons = entries.filter(e => e.type === 'skeleton')
|
||
for (let i = 0; i < ENTRIES.length && i < skeletons.length; i++) {
|
||
const res = await api.patch(`/api/journeys/entries/${skeletons[i].id}`, { data: { type: 'entry', ...ENTRIES[i] } })
|
||
if (!res.ok()) throw new Error(`could not write entry "${ENTRIES[i].title}": ${res.status()} ${await res.text()}`)
|
||
}
|
||
const photo = await coverFixture()
|
||
const upload = await api.post(`/api/journeys/entries/${skeletons[0].id}/photos`, {
|
||
multipart: { photos: { name: 'asakusa.jpg', mimeType: 'image/jpeg', buffer: readFileSync(photo) } },
|
||
})
|
||
if (!upload.ok()) throw new Error(`could not upload the entry photo: ${upload.status()} ${await upload.text()}`)
|
||
return journey.id
|
||
}
|
||
|
||
// ── Admin ─────────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* What the admin guides act on. Two more accounts so the user table has rows
|
||
* to edit and delete, one invite link, a packing template with categories and
|
||
* items, a school-holiday country with one region, the MCP addon (the tab only
|
||
* exists while it is on) with a token, and the ntfy and webhook channels.
|
||
*/
|
||
export const ADMIN_USERS = [
|
||
{ username: 'mara', email: 'mara.lind@example.com', password: 'Mara12345!', role: 'user' },
|
||
{ username: 'jonas', email: 'jonas.b@example.com', password: 'Jonas12345!', role: 'user' },
|
||
]
|
||
const PACKING_TEMPLATE = {
|
||
name: 'Beach Holiday',
|
||
categories: [
|
||
{ name: 'Clothing', items: ['Swimsuit', 'Sandals', 'Sun hat', 'Light jacket'] },
|
||
{ name: 'Toiletries', items: ['Sunscreen', 'After sun', 'Toothbrush'] },
|
||
],
|
||
}
|
||
const SCHOOL_COUNTRY = { code: 'DE', name: 'Germany' }
|
||
const SCHOOL_REGION = {
|
||
name: 'Bavaria',
|
||
revision: 0,
|
||
holidays: [
|
||
{ name: 'Autumn break', startDate: day(42), endDate: day(46) },
|
||
{ name: 'Christmas break', startDate: day(94), endDate: day(107) },
|
||
{ name: 'Easter break', startDate: day(189), endDate: day(200) },
|
||
],
|
||
}
|
||
|
||
async function listOf<T>(api: APIRequestContext, url: string, key: string): Promise<T[]> {
|
||
const res = await api.get(url)
|
||
if (!res.ok()) throw new Error(`${url}: ${res.status()} ${await res.text()}`)
|
||
const body = (await res.json()) as Record<string, T[]> | T[]
|
||
return Array.isArray(body) ? body : (body[key] ?? [])
|
||
}
|
||
|
||
/** Accounts by username; existing ones are left alone. */
|
||
export async function ensureUsers(api: APIRequestContext, wanted: { username: string; email: string; password: string; role: string }[]): Promise<void> {
|
||
const users = await listOf<{ username: string }>(api, '/api/admin/users', 'users')
|
||
for (const user of wanted) {
|
||
if (users.some(u => u.username === user.username)) continue
|
||
const created = await api.post('/api/admin/users', { data: user })
|
||
if (!created.ok()) throw new Error(`could not create user "${user.username}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
}
|
||
|
||
/** The demo trip the screenshot seed creates; its ids are on disk because Playwright projects share no memory. */
|
||
export function seededTrip(): { tripId: number; dayIds: number[]; placeIds: number[]; memberIds: number[] } {
|
||
return JSON.parse(readFileSync(path.join(process.cwd(), E2E_SEED_FILE), 'utf8'))
|
||
}
|
||
|
||
export async function ensureAdminFixtures(api: APIRequestContext): Promise<void> {
|
||
await ensureUsers(api, ADMIN_USERS)
|
||
|
||
const invites = await listOf<{ id: number }>(api, '/api/admin/invites', 'invites')
|
||
if (invites.length === 0) {
|
||
const created = await api.post('/api/admin/invites', { data: { max_uses: 3, expires_in_days: 14 } })
|
||
if (!created.ok()) throw new Error(`could not create the invite link: ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
const templates = await listOf<{ id: number; name: string }>(api, '/api/admin/packing-templates', 'templates')
|
||
if (!templates.some(t => t.name === PACKING_TEMPLATE.name)) {
|
||
const created = await api.post('/api/admin/packing-templates', { data: { name: PACKING_TEMPLATE.name } })
|
||
if (!created.ok()) throw new Error(`could not create the packing template: ${created.status()} ${await created.text()}`)
|
||
const template = (await created.json()) as { id?: number; template?: { id: number } }
|
||
const templateId = template.id ?? template.template?.id
|
||
if (!templateId) throw new Error('packing template came back without an id')
|
||
for (const cat of PACKING_TEMPLATE.categories) {
|
||
const catRes = await api.post(`/api/admin/packing-templates/${templateId}/categories`, { data: { name: cat.name } })
|
||
if (!catRes.ok()) throw new Error(`could not add category "${cat.name}": ${catRes.status()} ${await catRes.text()}`)
|
||
const category = (await catRes.json()) as { id?: number; category?: { id: number } }
|
||
const catId = category.id ?? category.category?.id
|
||
for (const item of cat.items) {
|
||
const itemRes = await api.post(`/api/admin/packing-templates/${templateId}/categories/${catId}/items`, { data: { name: item } })
|
||
if (!itemRes.ok()) throw new Error(`could not add item "${item}": ${itemRes.status()} ${await itemRes.text()}`)
|
||
}
|
||
}
|
||
}
|
||
|
||
const catalogRes = await api.get('/api/school-holiday-catalog')
|
||
if (!catalogRes.ok()) throw new Error(`school holiday catalog: ${catalogRes.status()} ${await catalogRes.text()}`)
|
||
const catalog = (await catalogRes.json()) as { countries: { code: string; regions?: { name: string }[] }[]; regions?: { country: string; name: string }[] }
|
||
if (!catalog.countries.some(c => c.code === SCHOOL_COUNTRY.code)) {
|
||
const created = await api.post('/api/school-holiday-catalog/countries', { data: SCHOOL_COUNTRY })
|
||
if (!created.ok()) throw new Error(`could not create the holiday country: ${created.status()} ${await created.text()}`)
|
||
}
|
||
const regions = catalog.regions ?? catalog.countries.find(c => c.code === SCHOOL_COUNTRY.code)?.regions ?? []
|
||
if (!regions.some(r => r.name === SCHOOL_REGION.name)) {
|
||
const created = await api.post(`/api/school-holiday-catalog/countries/${SCHOOL_COUNTRY.code}/regions`, { data: SCHOOL_REGION })
|
||
if (!created.ok()) throw new Error(`could not create the holiday region: ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
const mcp = await api.put('/api/admin/addons/mcp', { data: { enabled: true } })
|
||
if (!mcp.ok()) throw new Error(`could not enable the MCP addon: ${mcp.status()} ${await mcp.text()}`)
|
||
const tokens = await listOf<{ id: number }>(api, '/api/auth/mcp-tokens', 'tokens')
|
||
if (tokens.length === 0) {
|
||
const created = await api.post('/api/auth/mcp-tokens', { data: { name: 'Claude Desktop' } })
|
||
if (!created.ok()) throw new Error(`could not create the MCP token: ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
const channels = await api.put('/api/auth/app-settings', { data: { notification_channels: 'ntfy,webhook' } })
|
||
if (!channels.ok()) throw new Error(`could not enable the notification channels: ${channels.status()} ${await channels.text()}`)
|
||
}
|
||
|
||
/** A minimal ustar tar.gz, enough for the plugin upload route. */
|
||
function tarGz(files: { name: string; data: Buffer }[]): Buffer {
|
||
const blocks: Buffer[] = []
|
||
for (const f of files) {
|
||
const h = Buffer.alloc(512)
|
||
h.write(f.name, 0, 100, 'utf8')
|
||
h.write('0000644\0', 100, 8, 'utf8')
|
||
h.write('0000000\0', 108, 8, 'utf8')
|
||
h.write('0000000\0', 116, 8, 'utf8')
|
||
h.write(f.data.length.toString(8).padStart(11, '0') + '\0', 124, 12, 'utf8')
|
||
h.write(Math.floor(Date.now() / 1000).toString(8).padStart(11, '0') + '\0', 136, 12, 'utf8')
|
||
h.write(' ', 148, 8, 'utf8')
|
||
h.write('0', 156, 1, 'utf8')
|
||
h.write('ustar\0', 257, 6, 'utf8')
|
||
h.write('00', 263, 2, 'utf8')
|
||
let sum = 0
|
||
for (const b of h) sum += b
|
||
h.write(sum.toString(8).padStart(6, '0') + '\0 ', 148, 8, 'utf8')
|
||
blocks.push(h, f.data, Buffer.alloc((512 - (f.data.length % 512)) % 512))
|
||
}
|
||
blocks.push(Buffer.alloc(1024))
|
||
return gzipSync(Buffer.concat(blocks))
|
||
}
|
||
|
||
/**
|
||
* The SDK's Trip Doctor example packed for upload. Its manifest pins TREK 3.x,
|
||
* so the range is widened to the running major; nothing else changes.
|
||
*/
|
||
export function pluginPackage(): Buffer {
|
||
const dir = path.join(process.cwd(), '..', 'plugin-sdk', 'examples', 'trip-doctor')
|
||
const manifest = JSON.parse(readFileSync(path.join(dir, 'trek-plugin.json'), 'utf8')) as Record<string, unknown>
|
||
manifest.trek = '>=4.0.0'
|
||
return tarGz([
|
||
{ name: 'trip-doctor/trek-plugin.json', data: Buffer.from(JSON.stringify(manifest, null, 2)) },
|
||
{ name: 'trip-doctor/server/index.js', data: readFileSync(path.join(dir, 'server', 'index.js')) },
|
||
])
|
||
}
|
||
|
||
// ── Trip ──────────────────────────────────────────────────────────────────────
|
||
|
||
/** Two short Kyoto walks as GPX, each a track with two waypoints; drawn once, on first use. */
|
||
const WALKS: Record<string, { name: string; waypoints: [string, number, number][]; track: [number, number][] }> = {
|
||
'kyoto-walk': {
|
||
name: "Philosopher's Path",
|
||
waypoints: [['Ginkaku-ji', 35.0270, 135.7982], ['Nanzen-ji', 35.0113, 135.7943]],
|
||
track: [[35.0270, 135.7982], [35.0248, 135.7969], [35.0221, 135.7957], [35.0194, 135.7951], [35.0166, 135.7948], [35.0140, 135.7945], [35.0113, 135.7943]],
|
||
},
|
||
'arashiyama-loop': {
|
||
name: 'Arashiyama loop',
|
||
waypoints: [['Togetsukyo Bridge', 35.0128, 135.6777], ['Okochi Sanso Villa', 35.0177, 135.6700]],
|
||
track: [[35.0128, 135.6777], [35.0141, 135.6752], [35.0158, 135.6728], [35.0170, 135.6716], [35.0177, 135.6700], [35.0165, 135.6740], [35.0140, 135.6765]],
|
||
},
|
||
}
|
||
|
||
export function gpxFixture(id: keyof typeof WALKS): string {
|
||
const dir = path.join(process.cwd(), 'e2e', '.tmp')
|
||
mkdirSync(dir, { recursive: true })
|
||
const file = path.join(dir, `${id}.gpx`)
|
||
if (existsSync(file)) return file
|
||
const walk = WALKS[id]
|
||
const wpts = walk.waypoints.map(([name, lat, lon]) => ` <wpt lat="${lat}" lon="${lon}"><name>${name}</name></wpt>`).join('\n')
|
||
const pts = walk.track.map(([lat, lon]) => ` <trkpt lat="${lat}" lon="${lon}"></trkpt>`).join('\n')
|
||
writeFileSync(file, `<?xml version="1.0" encoding="UTF-8"?>
|
||
<gpx version="1.1" creator="TREK help" xmlns="http://www.topografix.com/GPX/1/1">
|
||
${wpts}
|
||
<trk><name>${walk.name}</name><trkseg>
|
||
${pts}
|
||
</trkseg></trk>
|
||
</gpx>
|
||
`)
|
||
return file
|
||
}
|
||
|
||
/** Import a walk over the API, so the trip has a track before the pictures start. */
|
||
export async function ensureTrack(api: APIRequestContext, tripId: number, id: keyof typeof WALKS): Promise<void> {
|
||
const res = await api.get(`/api/trips/${tripId}/places`)
|
||
const body = (await res.json()) as { places?: { name: string }[] } | { name: string }[]
|
||
const places = Array.isArray(body) ? body : (body.places ?? [])
|
||
if (places.some(p => p.name === WALKS[id].name)) return
|
||
const imported = await api.post(`/api/trips/${tripId}/places/import/gpx`, {
|
||
multipart: {
|
||
file: { name: `${id}.gpx`, mimeType: 'application/gpx+xml', buffer: readFileSync(gpxFixture(id)) },
|
||
importWaypoints: 'true', importRoutes: 'true', importTracks: 'true',
|
||
},
|
||
})
|
||
if (!imported.ok()) throw new Error(`could not import ${id}: ${imported.status()} ${await imported.text()}`)
|
||
}
|
||
|
||
/**
|
||
* What the day guides need on the seeded trip beyond its places: a stop with a
|
||
* time, a reservation tied to a stop, a train between two cities and a hotel
|
||
* over the first nights, so the day cards show every kind of row.
|
||
*/
|
||
export async function ensureDaysFixtures(api: APIRequestContext): Promise<void> {
|
||
const { tripId, dayIds } = seededTrip()
|
||
const assignmentsOf = async (dayId: number) => {
|
||
const res = await api.get(`/api/trips/${tripId}/days/${dayId}/assignments`)
|
||
const body = (await res.json()) as { assignments?: { id: number; place_id: number; place?: { name: string } }[] }
|
||
return body.assignments ?? []
|
||
}
|
||
const placesRes = await api.get(`/api/trips/${tripId}/places`)
|
||
const placesBody = (await placesRes.json()) as { places?: { id: number; name: string }[] } | { id: number; name: string }[]
|
||
const places = Array.isArray(placesBody) ? placesBody : (placesBody.places ?? [])
|
||
const byName = (name: string) => places.find(p => p.name === name)
|
||
|
||
// A time on the first stop of day 1.
|
||
const day1 = await assignmentsOf(dayIds[0])
|
||
const senso = day1.find(a => a.place_id === byName('Senso-ji Temple')?.id)
|
||
if (senso) await api.put(`/api/trips/${tripId}/assignments/${senso.id}/time`, { data: { place_time: '09:30', end_time: '11:00' } })
|
||
|
||
const resRes = await api.get(`/api/trips/${tripId}/reservations`)
|
||
const resBody = (await resRes.json()) as { reservations?: { title: string }[] } | { title: string }[]
|
||
const reservations = Array.isArray(resBody) ? resBody : (resBody.reservations ?? [])
|
||
const has = (title: string) => reservations.some(r => r.title === title)
|
||
|
||
// A reservation at the market stop on day 6.
|
||
const day6 = await assignmentsOf(dayIds[5])
|
||
const market = day6.find(a => a.place_id === byName('Nishiki Market')?.id)
|
||
if (market && !has('Lunch at Nishiki')) {
|
||
await api.post(`/api/trips/${tripId}/reservations`, {
|
||
data: {
|
||
title: 'Lunch at Nishiki', type: 'restaurant', status: 'confirmed', day_id: dayIds[5],
|
||
place_id: market.place_id, assignment_id: market.id, reservation_time: at(-4, '12:30'), confirmation_number: 'NK-2211',
|
||
},
|
||
})
|
||
}
|
||
|
||
// The train from Tokyo to Kyoto on day 5.
|
||
if (!has('Nozomi 21 Tokyo → Kyoto')) {
|
||
await api.post(`/api/trips/${tripId}/reservations`, {
|
||
data: {
|
||
title: 'Nozomi 21 Tokyo → Kyoto', type: 'train', status: 'confirmed', location: 'Tokyo Station',
|
||
reservation_time: at(-5, '08:30'), reservation_end_time: at(-5, '10:45'), confirmation_number: 'JR-58204',
|
||
metadata: { train_number: 'Nozomi 21', platform: '17', seat: '8A' },
|
||
endpoints: [
|
||
{ role: 'from', sequence: 0, name: 'Tokyo Station', lat: 35.6812, lng: 139.7671, timezone: 'Asia/Tokyo', local_date: day(-5), local_time: '08:30' },
|
||
{ role: 'to', sequence: 1, name: 'Kyoto Station', lat: 34.9858, lng: 135.7588, timezone: 'Asia/Tokyo', local_date: day(-5), local_time: '10:45' },
|
||
],
|
||
},
|
||
})
|
||
}
|
||
|
||
// A hotel over the Tokyo nights.
|
||
//
|
||
// Idempotent on the booked night, not on the place, and loud on every step. A
|
||
// run once created the place and then lost the night without saying so, which
|
||
// left the day cards without their booked night and the first day without the
|
||
// only leg it has: the flight sits between its two stops, so they have none of
|
||
// their own. The picture that came out of that was of a feature that was not
|
||
// there, which is worse than a failed run.
|
||
const HOTEL = 'Hotel Gracery Shinjuku'
|
||
let hotelId = byName(HOTEL)?.id
|
||
if (!hotelId) {
|
||
const created = await api.post(`/api/trips/${tripId}/places`, {
|
||
data: { name: HOTEL, lat: 35.6946, lng: 139.7012, address: '1-19-1 Kabukicho, Shinjuku City, Tokyo' },
|
||
})
|
||
if (!created.ok()) throw new Error(`could not create the hotel: ${created.status()} ${await created.text()}`)
|
||
const place = (await created.json()) as { place?: { id: number }; id?: number }
|
||
hotelId = place.place?.id ?? place.id
|
||
if (!hotelId) throw new Error('the hotel came back without an id')
|
||
}
|
||
const nights = async (): Promise<{ place_id: number | null }[]> => {
|
||
const res = await api.get(`/api/trips/${tripId}/accommodations`)
|
||
if (!res.ok()) throw new Error(`could not read the booked nights: ${res.status()} ${await res.text()}`)
|
||
const body = (await res.json()) as { accommodations?: { place_id: number | null }[] }
|
||
return body.accommodations ?? []
|
||
}
|
||
// Booked, then read back, then booked again if it is not there.
|
||
//
|
||
// The call answered 2xx and wrote nothing twice in a row, and the only symptom
|
||
// was a day card quietly missing the night the pictures are about, which cost
|
||
// two runs to notice. One retry covers it; a second silence is a real fault
|
||
// and stops the run rather than producing a picture of a feature that is not
|
||
// on screen.
|
||
for (let attempt = 1; ; attempt++) {
|
||
if ((await nights()).some(stay => stay.place_id === hotelId)) break
|
||
const booked = await api.post(`/api/trips/${tripId}/accommodations`, {
|
||
data: { place_id: hotelId, start_day_id: dayIds[0], end_day_id: dayIds[3], check_in: '15:00', check_out: '11:00', confirmation: 'GRC-7731' },
|
||
})
|
||
if (!booked.ok()) throw new Error(`could not book the hotel: ${booked.status()} ${await booked.text()}`)
|
||
if (attempt === 2 && !(await nights()).some(stay => stay.place_id === hotelId)) {
|
||
throw new Error('the hotel night is not there after booking it twice')
|
||
}
|
||
}
|
||
}
|
||
|
||
// ── Trip: place details ───────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* What the place card needs beyond the seed: a website on one place so the
|
||
* footer offers Open Website at all, a note on the first stop so the card can
|
||
* show Notes for this day, and two other travellers' star votes so the rating
|
||
* row has an average and a voter list rather than one lonely face. An
|
||
* OpenStreetMap id on three places, so the card shows real hours, a ring and a
|
||
* phone number; see OSM_PLACES.
|
||
*
|
||
* The votes are cast as the members themselves. A login on the shared context
|
||
* would set the trek_session cookie on it, and the server reads that cookie
|
||
* before the Authorization header, so every later write would silently be the
|
||
* admin's again, the same trap seed.ts documents at its collab block. A login
|
||
* that fails is skipped rather than thrown: a thinner rating row is worth less
|
||
* than losing every picture of this screen.
|
||
*/
|
||
export const PLACE_WEBSITE = { place: 'teamLab Planets', url: 'https://planets.teamlab.art/tokyo/' }
|
||
const STOP_NOTE = {
|
||
place: 'Senso-ji Temple',
|
||
notes: 'Enter through the Kaminarimon gate, not the side one. The Nakamise street is half the point.',
|
||
}
|
||
export const RATED_PLACE = 'Meiji Jingu'
|
||
const MEMBER_VOTES = [
|
||
{ username: 'mira', email: 'mira@example.com', password: 'DemoSeed12345!', rating: 5 },
|
||
{ username: 'jonas', email: 'jonas@example.com', password: 'DemoSeed12345!', rating: 4 },
|
||
]
|
||
|
||
/**
|
||
* The OpenStreetMap element behind three of the seeded places, so their cards
|
||
* show what a place picked from the search shows: the hours, the Open or
|
||
* Closed ring, the phone number and the website. The seed posts bare rows, and
|
||
* a place with neither a Google nor an OpenStreetMap id asks no provider at
|
||
* all (PlaceInspector's usePlaceDetails), which is why every picture of the
|
||
* card had been without them.
|
||
*
|
||
* The id is looked up at run time through TREK's own autocomplete, which
|
||
* answers from the OpenStreetMap layer of the TREK index, so a re-mapped
|
||
* element does not quietly blank the picture; the id written here is the
|
||
* fallback for when the index is unreachable or names something else. Every
|
||
* candidate is then asked from the details route, the call the card makes,
|
||
* and only one that answers with a week of hours is written. Senso-ji is the
|
||
* place the read-place guide pictures, so a run that cannot get its hours and
|
||
* phone number fails here rather than promoting a picture of a card without
|
||
* the feature the text describes; the other two only make their own guides'
|
||
* cards look like a real place's, so a thin answer is warned about and the
|
||
* id kept.
|
||
*
|
||
* Nishiki Market is left out on purpose: its OpenStreetMap hours ("Mo-Su,PH
|
||
* 10:00-18:00+") are a shape the server's parser rejects, and Fushimi Inari
|
||
* and Meiji Jingu carry no hours tag at all.
|
||
*/
|
||
interface OsmPlace {
|
||
/** The seeded place's name. */
|
||
place: string
|
||
/** What the resolver types into the autocomplete. */
|
||
query: string
|
||
/** What the suggestion's name has to contain, letters and digits only. */
|
||
key: string
|
||
/** The element the last probe found, used when the index cannot say. */
|
||
osmId: string
|
||
/** Whether the answer has to carry a phone number as well as the hours. */
|
||
phone: boolean
|
||
/** Fail the run when the details do not come; otherwise warn and keep the id. */
|
||
strict: boolean
|
||
}
|
||
|
||
export const OSM_PLACES: OsmPlace[] = [
|
||
{ place: 'Senso-ji Temple', query: 'Senso-ji', key: 'sensoji', osmId: 'way:173154847', phone: true, strict: true },
|
||
{ place: 'teamLab Planets', query: 'teamLab Planets', key: 'teamlab', osmId: 'node:6291685287', phone: false, strict: false },
|
||
{ place: 'Arashiyama Bamboo Grove', query: 'Arashiyama Bamboo Grove', key: 'bamboo', osmId: 'relation:17656638', phone: false, strict: false },
|
||
]
|
||
|
||
/** The id form the details route resolves (maps.helpers.ts OSM_PLACE_ID). */
|
||
const OSM_PLACE_ID = /^(node|way|relation):\d+$/
|
||
|
||
/** Letters and digits, diacritics dropped: "Sensō-ji" and "Senso-ji Temple" both open with "sensoji". */
|
||
const plain = (value: string): string =>
|
||
value.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '')
|
||
|
||
/** Metres between two pins; flat arithmetic is exact enough for a few hundred of them. */
|
||
function metresApart(a: { lat: number; lng: number }, b: { lat: number; lng: number }): number {
|
||
const dLat = (b.lat - a.lat) * 111_320
|
||
const dLng = (b.lng - a.lng) * 111_320 * Math.cos(((a.lat + b.lat) / 2) * (Math.PI / 180))
|
||
return Math.hypot(dLat, dLng)
|
||
}
|
||
|
||
interface Suggestion {
|
||
placeId: string
|
||
mainText: string
|
||
source?: string
|
||
lat?: number
|
||
lng?: number
|
||
}
|
||
|
||
/**
|
||
* The element the index knows the place by: an OpenStreetMap row of TREK's own
|
||
* autocomplete, biased to the seed's pin, called like the place and within a
|
||
* few hundred metres of it. Undefined when the index is unreachable or names
|
||
* nothing that is this place; the caller then falls back to the written id.
|
||
*/
|
||
async function resolveOsmId(api: APIRequestContext, wanted: OsmPlace, pin: { lat: number; lng: number }): Promise<string | undefined> {
|
||
const res = await api.post('/api/maps/autocomplete', {
|
||
data: {
|
||
input: wanted.query,
|
||
locationBias: { low: { lat: pin.lat - 0.02, lng: pin.lng - 0.02 }, high: { lat: pin.lat + 0.02, lng: pin.lng + 0.02 } },
|
||
},
|
||
})
|
||
if (!res.ok()) return undefined
|
||
const body = (await res.json()) as { suggestions?: Suggestion[] }
|
||
return (body.suggestions ?? []).find(
|
||
s =>
|
||
s.source === 'openstreetmap'
|
||
&& OSM_PLACE_ID.test(s.placeId)
|
||
&& plain(s.mainText).includes(wanted.key)
|
||
&& typeof s.lat === 'number'
|
||
&& typeof s.lng === 'number'
|
||
&& metresApart(pin, { lat: s.lat, lng: s.lng }) < 600,
|
||
)?.placeId
|
||
}
|
||
|
||
interface ProviderDetails {
|
||
opening_hours?: string[] | null
|
||
phone?: string | null
|
||
}
|
||
|
||
/** Whether a details answer carries what the card is to show for this place. */
|
||
const complete = (details: ProviderDetails | null, wanted: OsmPlace): boolean =>
|
||
!!details
|
||
&& Array.isArray(details.opening_hours)
|
||
&& details.opening_hours.length === 7
|
||
&& (!wanted.phone || (typeof details.phone === 'string' && details.phone.length > 0))
|
||
|
||
/**
|
||
* What the card would get for this id, asked the way the card asks it. The
|
||
* OpenStreetMap path has no server-side cache and Overpass is regularly
|
||
* overloaded, so a thin answer is asked again twice before it counts.
|
||
*/
|
||
async function providerDetails(api: APIRequestContext, osmId: string, wanted: OsmPlace): Promise<ProviderDetails | null> {
|
||
for (let attempt = 1; ; attempt++) {
|
||
const res = await api.get(`/api/maps/details/${encodeURIComponent(osmId)}?lang=en`)
|
||
const body = res.ok() ? ((await res.json()) as { place: ProviderDetails | null; disabled?: boolean }) : null
|
||
if (body?.disabled) throw new Error('Place Details is switched off in the admin settings, so no card gets hours')
|
||
if (complete(body?.place ?? null, wanted) || attempt === 3) return body?.place ?? null
|
||
await new Promise(resolve => setTimeout(resolve, 2_000))
|
||
}
|
||
}
|
||
|
||
type FixturePlace = {
|
||
id: number
|
||
name: string
|
||
lat?: number | null
|
||
lng?: number | null
|
||
osm_id?: string | null
|
||
website?: string | null
|
||
ratings?: { username?: string | null }[] | null
|
||
}
|
||
|
||
export async function ensurePlaceFixtures(api: APIRequestContext): Promise<void> {
|
||
const { tripId, dayIds } = seededTrip()
|
||
const placesRes = await api.get(`/api/trips/${tripId}/places`)
|
||
const placesBody = (await placesRes.json()) as { places?: FixturePlace[] } | FixturePlace[]
|
||
const places = Array.isArray(placesBody) ? placesBody : (placesBody.places ?? [])
|
||
const byName = (name: string) => places.find(p => p.name === name)
|
||
|
||
// A website, so the footer has an Open Website button to point at.
|
||
const site = byName(PLACE_WEBSITE.place)
|
||
if (site && site.website !== PLACE_WEBSITE.url) {
|
||
const res = await api.put(`/api/trips/${tripId}/places/${site.id}`, { data: { website: PLACE_WEBSITE.url } })
|
||
if (!res.ok()) throw new Error(`could not set the website on ${PLACE_WEBSITE.place}: ${res.status()} ${await res.text()}`)
|
||
}
|
||
|
||
// An OpenStreetMap identity on three places, the same PUT: the card then asks
|
||
// the details route for the hours, the ring and the phone number.
|
||
for (const wanted of OSM_PLACES) {
|
||
const place = byName(wanted.place)
|
||
if (!place || typeof place.lat !== 'number' || typeof place.lng !== 'number') continue
|
||
const pin = { lat: place.lat, lng: place.lng }
|
||
const resolved = await resolveOsmId(api, wanted, pin)
|
||
const candidates = [...new Set([resolved, wanted.osmId].filter((id): id is string => !!id))]
|
||
let chosen: string | undefined
|
||
for (const id of candidates) {
|
||
if (complete(await providerDetails(api, id, wanted), wanted)) {
|
||
chosen = id
|
||
break
|
||
}
|
||
}
|
||
if (!chosen) {
|
||
const what = `${wanted.place}: the details route gives no week of opening hours${wanted.phone ? ' and no phone number' : ''} for ${candidates.join(' or ')}`
|
||
if (wanted.strict) throw new Error(what)
|
||
console.warn(`${what}; keeping the id, the card shows what there is`)
|
||
chosen = candidates[0]
|
||
}
|
||
if (place.osm_id !== chosen) {
|
||
const res = await api.put(`/api/trips/${tripId}/places/${place.id}`, { data: { osm_id: chosen } })
|
||
if (!res.ok()) throw new Error(`could not set the OpenStreetMap id on ${wanted.place}: ${res.status()} ${await res.text()}`)
|
||
}
|
||
}
|
||
|
||
// A note that belongs to the stop rather than to the place, which is the one
|
||
// box of the card no other guide reaches.
|
||
const noted = byName(STOP_NOTE.place)
|
||
if (noted) {
|
||
const dayRes = await api.get(`/api/trips/${tripId}/days/${dayIds[0]}/assignments`)
|
||
const dayBody = (await dayRes.json()) as { assignments?: { id: number; place_id: number; notes: string | null }[] }
|
||
const stop = (dayBody.assignments ?? []).find(a => a.place_id === noted.id)
|
||
if (stop && !stop.notes) {
|
||
const res = await api.put(`/api/trips/${tripId}/assignments/${stop.id}/notes`, { data: { notes: STOP_NOTE.notes } })
|
||
if (!res.ok()) throw new Error(`could not note the ${STOP_NOTE.place} stop: ${res.status()} ${await res.text()}`)
|
||
}
|
||
}
|
||
|
||
// Two members' votes, each cast from its own throwaway context.
|
||
const rated = byName(RATED_PLACE)
|
||
if (!rated) return
|
||
const voted = new Set((rated.ratings ?? []).map(r => r.username ?? ''))
|
||
for (const member of MEMBER_VOTES) {
|
||
if (voted.has(member.username)) continue
|
||
const anon = await apiRequest.newContext({ baseURL: E2E_BASE_URL, storageState: undefined })
|
||
const login = await anon.post('/api/auth/login', { data: { email: member.email, password: member.password } })
|
||
const token = login.ok() ? ((await login.json()) as { token?: string }).token : undefined
|
||
await anon.dispose()
|
||
if (!token) continue
|
||
const asMember = await apiRequest.newContext({
|
||
baseURL: E2E_BASE_URL,
|
||
storageState: undefined,
|
||
extraHTTPHeaders: { Authorization: `Bearer ${token}` },
|
||
})
|
||
await asMember.put(`/api/trips/${tripId}/places/${rated.id}/rating`, { data: { rating: member.rating } })
|
||
await asMember.dispose()
|
||
}
|
||
}
|
||
|
||
// ── Trip: day details ─────────────────────────────────────────────────────────────
|
||
|
||
/** The Tokyo hotel `ensureDaysFixtures` books over the first nights. */
|
||
export const TOKYO_HOTEL = 'Hotel Gracery Shinjuku'
|
||
|
||
/**
|
||
* The Kyoto hotel the booking guide puts on the Kyoto nights. It carries the
|
||
* Hotel category on purpose: the seeded places carry none, so the picker's
|
||
* category chips narrow its list to exactly this one.
|
||
*/
|
||
export const KYOTO_HOTEL = {
|
||
name: 'Hotel Kanra Kyoto',
|
||
lat: 34.9942,
|
||
lng: 135.7592,
|
||
address: '190 Kitamachi, Shimogyo Ward, Kyoto',
|
||
description: 'Machiya-style rooms a few minutes from Karasuma station.',
|
||
}
|
||
|
||
/** The second booking of day 5: still pending, and tied to that day's stop. */
|
||
export const EVENING_WALK = 'Fushimi Inari evening walk'
|
||
|
||
/**
|
||
* What the day-detail guides need beyond the day fixtures: the Kyoto hotel as a
|
||
* place in the Hotel category, and a second booking on day 5 that hangs off the
|
||
* day's stop and is still pending, so the panel's Reservations block shows both
|
||
* a green and an amber row and one of them with its stop.
|
||
*/
|
||
export async function ensureDayDetailFixtures(api: APIRequestContext): Promise<void> {
|
||
await ensureDaysFixtures(api)
|
||
const { tripId, dayIds } = seededTrip()
|
||
|
||
const placesRes = await api.get(`/api/trips/${tripId}/places`)
|
||
const placesBody = (await placesRes.json()) as { places?: { id: number; name: string }[] } | { id: number; name: string }[]
|
||
const places = Array.isArray(placesBody) ? placesBody : (placesBody.places ?? [])
|
||
const byName = (name: string) => places.find(p => p.name === name)
|
||
|
||
if (!byName(KYOTO_HOTEL.name)) {
|
||
const catRes = await api.get('/api/categories')
|
||
const { categories } = (await catRes.json()) as { categories: { id: number; name: string }[] }
|
||
const hotel = categories.find(c => c.name === 'Hotel')
|
||
if (!hotel) throw new Error('the seeded Hotel category is missing')
|
||
const created = await api.post(`/api/trips/${tripId}/places`, { data: { ...KYOTO_HOTEL, category_id: hotel.id } })
|
||
if (!created.ok()) throw new Error(`could not create "${KYOTO_HOTEL.name}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
const resRes = await api.get(`/api/trips/${tripId}/reservations`)
|
||
const resBody = (await resRes.json()) as { reservations?: { title: string }[] } | { title: string }[]
|
||
const reservations = Array.isArray(resBody) ? resBody : (resBody.reservations ?? [])
|
||
if (!reservations.some(r => r.title === EVENING_WALK)) {
|
||
const asgRes = await api.get(`/api/trips/${tripId}/days/${dayIds[4]}/assignments`)
|
||
const { assignments } = (await asgRes.json()) as { assignments: { id: number; place_id: number }[] }
|
||
const inari = assignments.find(a => a.place_id === byName('Fushimi Inari Taisha')?.id)
|
||
if (!inari) throw new Error('the Fushimi Inari stop of day 5 is missing')
|
||
const created = await api.post(`/api/trips/${tripId}/reservations`, {
|
||
data: {
|
||
title: EVENING_WALK, type: 'tour', status: 'pending', day_id: dayIds[4],
|
||
place_id: inari.place_id, assignment_id: inari.id,
|
||
reservation_time: at(-5, '17:00'), reservation_end_time: at(-5, '19:30'),
|
||
confirmation_number: 'FIT-3390',
|
||
},
|
||
})
|
||
if (!created.ok()) throw new Error(`could not create "${EVENING_WALK}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
}
|
||
|
||
// ── Trip: the map ─────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* What the map guides need on the seeded trip beyond its places: a booking whose
|
||
* two ends both sit inside Japan, so the toolbar's "show all" has a route to
|
||
* draw next to the flight's arc.
|
||
*/
|
||
export async function ensureMapFixtures(api: APIRequestContext): Promise<void> {
|
||
const { tripId } = seededTrip()
|
||
const res = await api.get(`/api/trips/${tripId}/reservations`)
|
||
const body = (await res.json()) as { reservations?: { title: string }[] } | { title: string }[]
|
||
const reservations = Array.isArray(body) ? body : (body.reservations ?? [])
|
||
if (reservations.some(r => r.title === 'Nozomi 21 Tokyo → Kyoto')) return
|
||
|
||
const created = await api.post(`/api/trips/${tripId}/reservations`, {
|
||
data: {
|
||
title: 'Nozomi 21 Tokyo → Kyoto', type: 'train', status: 'confirmed', location: 'Tokyo Station',
|
||
reservation_time: at(-5, '08:30'), reservation_end_time: at(-5, '10:45'), confirmation_number: 'JR-58204',
|
||
metadata: { train_number: 'Nozomi 21', platform: '17', seat: '8A' },
|
||
// Both ends need coordinates or the endpoints are dropped and the booking
|
||
// draws nothing at all.
|
||
endpoints: [
|
||
{ role: 'from', sequence: 0, name: 'Tokyo Station', lat: 35.6812, lng: 139.7671, timezone: 'Asia/Tokyo', local_date: day(-5), local_time: '08:30' },
|
||
{ role: 'to', sequence: 1, name: 'Kyoto Station', lat: 34.9858, lng: 135.7588, timezone: 'Asia/Tokyo', local_date: day(-5), local_time: '10:45' },
|
||
],
|
||
},
|
||
})
|
||
if (!created.ok()) throw new Error(`could not create the train: ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
// ── Trip: transports ──────────────────────────────────────────────────────────────
|
||
|
||
/** The title TransitSearchPanel builds from the two ends, so a guide can find the journey again. */
|
||
export const TRANSIT_JOURNEY = 'Arashiyama Bamboo Grove → Nishiki Market'
|
||
|
||
/**
|
||
* What the transport guides need on the seeded trip beyond the day fixtures:
|
||
* a time on the second stop of day 1 so a new transport slots between the two,
|
||
* a booking that is still pending so the Pending group exists at all, and one
|
||
* stored public-transit connection so the tab has an Automated public transit
|
||
* group and a journey to open without asking Transitous first.
|
||
*
|
||
* The connection sits on day 6, the only day that carries two located stops of
|
||
* its own: the day's route tools, which is what draws a transit journey on the
|
||
* map, render for a day with two routable points.
|
||
*/
|
||
export async function ensureTransportFixtures(api: APIRequestContext): Promise<void> {
|
||
await ensureDaysFixtures(api)
|
||
const { tripId, dayIds } = seededTrip()
|
||
|
||
// A time on day 1's second stop. The first one already has 09:30, so a
|
||
// transport at midday lands between them instead of at the end of the day.
|
||
const placesRes = await api.get(`/api/trips/${tripId}/places`)
|
||
const placesBody = (await placesRes.json()) as { places?: { id: number; name: string }[] } | { id: number; name: string }[]
|
||
const places = Array.isArray(placesBody) ? placesBody : (placesBody.places ?? [])
|
||
const teamLabId = places.find(p => p.name === 'teamLab Planets')?.id
|
||
const dayRes = await api.get(`/api/trips/${tripId}/days/${dayIds[0]}/assignments`)
|
||
const dayBody = (await dayRes.json()) as { assignments?: { id: number; place_id: number }[] }
|
||
const teamLab = (dayBody.assignments ?? []).find(a => a.place_id === teamLabId)
|
||
if (teamLab) {
|
||
await api.put(`/api/trips/${tripId}/assignments/${teamLab.id}/time`, { data: { place_time: '13:00', end_time: '15:00' } })
|
||
}
|
||
|
||
const resRes = await api.get(`/api/trips/${tripId}/reservations`)
|
||
const resBody = (await resRes.json()) as { reservations?: { title: string }[] } | { title: string }[]
|
||
const reservations = Array.isArray(resBody) ? resBody : (resBody.reservations ?? [])
|
||
const has = (title: string) => reservations.some(r => r.title === title)
|
||
|
||
// A car that is not confirmed yet, so the Pending group has a card in it.
|
||
if (!has('Rental car in Kyoto')) {
|
||
const created = await api.post(`/api/trips/${tripId}/reservations`, {
|
||
data: {
|
||
title: 'Rental car in Kyoto', type: 'car', status: 'pending',
|
||
day_id: dayIds[5], end_day_id: dayIds[7],
|
||
reservation_time: at(-4, '09:00'), reservation_end_time: at(-2, '18:00'),
|
||
confirmation_number: 'TYT-4417',
|
||
endpoints: [
|
||
{ role: 'from', sequence: 0, name: 'Kyoto Station Hachijo Exit', lat: 34.9835, lng: 135.759, timezone: 'Asia/Tokyo', local_date: day(-4), local_time: '09:00' },
|
||
{ role: 'to', sequence: 1, name: 'Kyoto Station Hachijo Exit', lat: 34.9835, lng: 135.759, timezone: 'Asia/Tokyo', local_date: day(-2), local_time: '18:00' },
|
||
],
|
||
},
|
||
})
|
||
if (!created.ok()) throw new Error(`could not create the rental car: ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
// One planned connection, in exactly the shape TransitSearchPanel saves: the
|
||
// list, the journey view and the map overlay all read metadata.transit. Its
|
||
// legs carry no geometry, which the overlay is happy with — a provider that
|
||
// sends no shape draws the journey through its stations.
|
||
if (!has(TRANSIT_JOURNEY)) {
|
||
const leg = (
|
||
mode: string, line: string | null, duration: number, stops: number,
|
||
from: [string, string, string | null], to: [string, string, string | null],
|
||
extra: Record<string, unknown> = {},
|
||
) => ({
|
||
mode, line, duration, stops,
|
||
from: { name: from[0], time: from[1], track: from[2] },
|
||
to: { name: to[0], time: to[1], track: to[2] },
|
||
geometry: null, geometry_precision: 6, ...extra,
|
||
})
|
||
const created = await api.post(`/api/trips/${tripId}/reservations`, {
|
||
data: {
|
||
title: TRANSIT_JOURNEY, type: 'transit', status: 'confirmed',
|
||
day_id: dayIds[5], end_day_id: dayIds[5],
|
||
reservation_time: at(-4, '09:48'), reservation_end_time: at(-4, '10:25'),
|
||
location: null, confirmation_number: null, notes: null,
|
||
metadata: {
|
||
transit: {
|
||
provider: 'transitous', duration: 2220, transfers: 1, walk_seconds: 1080,
|
||
legs: [
|
||
leg('WALK', null, 540, 0, ['Arashiyama Bamboo Grove', '09:48', null], ['Saga-Arashiyama', '09:57', null]),
|
||
leg('REGIONAL_RAIL', 'JR Sagano Line', 660, 2, ['Saga-Arashiyama', '09:57', '2'], ['Nijō', '10:08', '1'],
|
||
{ line_color: '#0072bc', line_text_color: '#ffffff', headsign: 'Kyoto', agency: 'JR West' }),
|
||
leg('SUBWAY', 'Tozai Line', 240, 1, ['Nijō', '10:12', '1'], ['Karasuma Oike', '10:16', '2'],
|
||
{ line_color: '#d7003a', line_text_color: '#ffffff', headsign: 'Rokujizo', agency: 'Kyoto Municipal Subway' }),
|
||
leg('WALK', null, 540, 0, ['Karasuma Oike', '10:16', null], ['Nishiki Market', '10:25', null]),
|
||
],
|
||
},
|
||
},
|
||
endpoints: [
|
||
{ role: 'from', sequence: 0, name: 'Arashiyama Bamboo Grove', lat: 35.017, lng: 135.6716, timezone: 'Asia/Tokyo', local_date: day(-4), local_time: '09:48' },
|
||
{ role: 'stop', sequence: 1, name: 'Nijō', lat: 35.0109, lng: 135.7386, timezone: 'Asia/Tokyo', local_date: day(-4), local_time: '10:08' },
|
||
{ role: 'to', sequence: 2, name: 'Nishiki Market', lat: 35.005, lng: 135.7649, timezone: 'Asia/Tokyo', local_date: day(-4), local_time: '10:25' },
|
||
],
|
||
needs_review: false,
|
||
},
|
||
})
|
||
if (!created.ok()) throw new Error(`could not create the transit journey: ${created.status()} ${await created.text()}`)
|
||
}
|
||
}
|
||
|
||
// ── Trip: bookings ────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* A one-page PDF the booking guides attach and link, written on first use.
|
||
*
|
||
* Hand-built rather than drawn with sharp: what the pictures show is the file
|
||
* NAME in the booking's Files list, never the page, and a booking confirmation
|
||
* is a document, not an image. Offsets are computed while the body is built, so
|
||
* the file is a valid PDF and not a blob with a `.pdf` on the end.
|
||
*/
|
||
export function bookingPdfFixture(id: 'teamlab-tickets' | 'kyoto-vouchers'): string {
|
||
const dir = path.join(process.cwd(), 'e2e', '.tmp')
|
||
mkdirSync(dir, { recursive: true })
|
||
const file = path.join(dir, `${id}.pdf`)
|
||
if (existsSync(file)) return file
|
||
const title = id === 'teamlab-tickets' ? 'teamLab Planets - 2 tickets - TL-88213' : 'Kyoto vouchers - Autumn in Japan'
|
||
const stream = `BT /F1 16 Tf 64 760 Td (${title}) Tj ET`
|
||
const objects = [
|
||
'<< /Type /Catalog /Pages 2 0 R >>',
|
||
'<< /Type /Pages /Kids [3 0 R] /Count 1 >>',
|
||
'<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>',
|
||
'<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>',
|
||
`<< /Length ${stream.length} >>\nstream\n${stream}\nendstream`,
|
||
]
|
||
let body = '%PDF-1.4\n'
|
||
const offsets: number[] = []
|
||
objects.forEach((object, i) => {
|
||
offsets.push(body.length)
|
||
body += `${i + 1} 0 obj\n${object}\nendobj\n`
|
||
})
|
||
const startxref = body.length
|
||
body += `xref\n0 ${objects.length + 1}\n0000000000 65535 f \n`
|
||
for (const offset of offsets) body += `${String(offset).padStart(10, '0')} 00000 n \n`
|
||
body += `trailer\n<< /Size ${objects.length + 1} /Root 1 0 R >>\nstartxref\n${startxref}\n%%EOF\n`
|
||
writeFileSync(file, Buffer.from(body, 'latin1'))
|
||
return file
|
||
}
|
||
|
||
/** The hotel confirmation the import guide hands to the parser; written on first use. */
|
||
/**
|
||
* The files the import guides hand to the extractor, by name. The widget's
|
||
* card, the drop box and the review's Files row are all found by the name.
|
||
*/
|
||
export const BOOKING_EML = 'gracery-confirmation.eml'
|
||
export const FLIGHT_EML = 'nh203-eticket.eml'
|
||
|
||
/**
|
||
* A confirmation mail the way a provider's system sends one: an HTML body
|
||
* that carries the reservation as schema.org JSON-LD beside the text a person
|
||
* reads. The structured block is what the extractor reads; the plain-text
|
||
* mail this used to be parsed to nothing, because KDE Itinerary only knows
|
||
* structured tickets and the vendors it has templates for.
|
||
*
|
||
* Written on every call rather than on first use: the dates are offsets from
|
||
* the picture day (`e2e/dates.ts`), so a file left over from an earlier run
|
||
* would carry that run's dates into this one's pictures.
|
||
*/
|
||
function emlFixture(
|
||
name: string,
|
||
headers: { from: string; subject: string; date: string },
|
||
jsonLd: Record<string, unknown>,
|
||
html: string[],
|
||
): string {
|
||
const dir = path.join(process.cwd(), 'e2e', '.tmp')
|
||
mkdirSync(dir, { recursive: true })
|
||
const file = path.join(dir, name)
|
||
const mail = [
|
||
`From: ${headers.from}`,
|
||
'To: admin@trek.local',
|
||
`Subject: ${headers.subject}`,
|
||
`Date: ${headers.date}`,
|
||
'MIME-Version: 1.0',
|
||
'Content-Type: text/html; charset=utf-8',
|
||
'Content-Transfer-Encoding: 7bit',
|
||
'',
|
||
'<!DOCTYPE html>',
|
||
'<html><head><meta charset="utf-8">',
|
||
`<title>${headers.subject}</title>`,
|
||
'<script type="application/ld+json">',
|
||
JSON.stringify(jsonLd, null, 2),
|
||
'</script>',
|
||
'</head><body>',
|
||
...html,
|
||
'</body></html>',
|
||
'',
|
||
].join('\n')
|
||
// One line ending for the whole mail, headers and body alike.
|
||
writeFileSync(file, mail.replace(/\r?\n/g, '\r\n'), 'utf8')
|
||
return file
|
||
}
|
||
|
||
/**
|
||
* The hotel confirmation the Bookings import guide hands to the extractor:
|
||
* the Granvia stay `booking-hotel` books by hand, nights 5 to 8 of the trip,
|
||
* as a LodgingReservation with the address, the coordinates, the phone, the
|
||
* website and the price, everything `mapLodging` and the review form read.
|
||
* The venue name is the trip place `ensureBookingsFixtures` creates, so the
|
||
* form pre-selects it under Accommodation.
|
||
*/
|
||
export function bookingEmlFixture(): string {
|
||
return emlFixture(
|
||
BOOKING_EML,
|
||
{
|
||
from: 'reservations@example-hotels.test',
|
||
subject: `Your reservation is confirmed - ${HOTEL_TO_BOOK.name}`,
|
||
date: mailHeaderDate(-20, '09:12', '+0900'),
|
||
},
|
||
{
|
||
'@context': 'http://schema.org',
|
||
'@type': 'LodgingReservation',
|
||
reservationNumber: 'GRK-40218',
|
||
reservationStatus: 'http://schema.org/ReservationConfirmed',
|
||
underName: { '@type': 'Person', name: 'Mira Lindberg' },
|
||
reservationFor: {
|
||
'@type': 'LodgingBusiness',
|
||
name: HOTEL_TO_BOOK.name,
|
||
address: {
|
||
'@type': 'PostalAddress',
|
||
streetAddress: 'Shiokoji-sagaru, Karasuma-dori',
|
||
addressLocality: 'Kyoto',
|
||
postalCode: '600-8216',
|
||
addressCountry: 'JP',
|
||
},
|
||
geo: { '@type': 'GeoCoordinates', latitude: HOTEL_TO_BOOK.lat, longitude: HOTEL_TO_BOOK.lng },
|
||
telephone: '+81 75 344 8888',
|
||
url: 'https://www.granviakyoto.example/',
|
||
},
|
||
checkinTime: `${at(-5, '15:00')}+09:00`,
|
||
checkoutTime: `${at(-2, '11:00')}+09:00`,
|
||
totalPrice: '84000',
|
||
priceCurrency: 'JPY',
|
||
},
|
||
[
|
||
'<p>Dear Ms Lindberg,</p>',
|
||
`<p>Thank you for choosing ${HOTEL_TO_BOOK.name}. Your reservation is confirmed.</p>`,
|
||
'<table>',
|
||
'<tr><td>Booking reference</td><td>GRK-40218</td></tr>',
|
||
`<tr><td>Check-in</td><td>${emlDate(-5)}, from 15:00</td></tr>`,
|
||
`<tr><td>Check-out</td><td>${emlDate(-2)}, until 11:00</td></tr>`,
|
||
'<tr><td>Guests</td><td>2</td></tr>',
|
||
'<tr><td>Room</td><td>Twin, non-smoking</td></tr>',
|
||
'<tr><td>Total</td><td>JPY 84,000</td></tr>',
|
||
'</table>',
|
||
`<p>${HOTEL_TO_BOOK.name}, ${HOTEL_TO_BOOK.address} 600-8216<br>Tel. +81 75 344 8888</p>`,
|
||
],
|
||
)
|
||
}
|
||
|
||
/**
|
||
* The flight the Transports import guide reads: the way home on the trip's
|
||
* last day, Haneda to Frankfurt. The seed's own flight is LH716 out, and the
|
||
* AirTrail fixture brings LH717 and NH16 back, so this one is none of those.
|
||
* The mapper builds the title from airline and number, so a guide finds the
|
||
* card by the booking code, which is the fixture's own.
|
||
*/
|
||
export const FLIGHT_TO_IMPORT = {
|
||
airline: 'All Nippon Airways',
|
||
iata: 'NH',
|
||
number: '203',
|
||
code: 'NH9M4LT',
|
||
from: { iata: 'HND', name: 'Tokyo Haneda International Airport', city: 'Tokyo Haneda' },
|
||
to: { iata: 'FRA', name: 'Frankfurt Main Airport', city: 'Frankfurt' },
|
||
}
|
||
|
||
/**
|
||
* The e-ticket as a FlightReservation: both airports by IATA code, which
|
||
* `mapFlight` resolves through the built-in airport table, so the review opens
|
||
* Add transport with both ends placed; departure in Tokyo's offset, arrival
|
||
* in Frankfurt's, both on the last day of the trip.
|
||
*/
|
||
export function flightEmlFixture(): string {
|
||
const f = FLIGHT_TO_IMPORT
|
||
return emlFixture(
|
||
FLIGHT_EML,
|
||
{
|
||
from: 'eticket@example-airlines.test',
|
||
subject: `Your e-ticket itinerary - ${f.iata} ${f.number} ${f.from.city} to ${f.to.city}`,
|
||
date: mailHeaderDate(-30, '14:40', '+0900'),
|
||
},
|
||
{
|
||
'@context': 'http://schema.org',
|
||
'@type': 'FlightReservation',
|
||
reservationNumber: f.code,
|
||
reservationStatus: 'http://schema.org/ReservationConfirmed',
|
||
underName: { '@type': 'Person', name: 'Mira Lindberg' },
|
||
reservationFor: {
|
||
'@type': 'Flight',
|
||
flightNumber: f.number,
|
||
airline: { '@type': 'Airline', name: f.airline, iataCode: f.iata },
|
||
departureAirport: { '@type': 'Airport', name: f.from.name, iataCode: f.from.iata },
|
||
departureTime: `${at(0, '11:20')}+09:00`,
|
||
arrivalAirport: { '@type': 'Airport', name: f.to.name, iataCode: f.to.iata },
|
||
arrivalTime: `${at(0, '17:05')}+02:00`,
|
||
},
|
||
},
|
||
[
|
||
'<p>Dear Ms Lindberg,</p>',
|
||
`<p>Your booking ${f.code} is confirmed. This is your e-ticket itinerary.</p>`,
|
||
'<table>',
|
||
`<tr><td>Flight</td><td>${f.iata} ${f.number}, operated by ${f.airline}</td></tr>`,
|
||
`<tr><td>From</td><td>${f.from.city} (${f.from.iata}), ${emlDate(0)}, 11:20</td></tr>`,
|
||
`<tr><td>To</td><td>${f.to.city} (${f.to.iata}), ${emlDate(0)}, 17:05</td></tr>`,
|
||
'<tr><td>Passenger</td><td>Mira Lindberg</td></tr>',
|
||
'<tr><td>Class</td><td>Economy</td></tr>',
|
||
'</table>',
|
||
],
|
||
)
|
||
}
|
||
|
||
/** One card of every type the Bookings tab can hold, by title. */
|
||
interface BookingFixture {
|
||
title: string
|
||
type: string
|
||
status: string
|
||
/** A trip place to hang the booking on, looked up by name; null for a standalone one. */
|
||
place: string | null
|
||
reservation_time: string
|
||
reservation_end_time: string | null
|
||
confirmation_number: string
|
||
location: string
|
||
url: string | null
|
||
notes: string | null
|
||
}
|
||
|
||
const BOOKING_FIXTURES: BookingFixture[] = [
|
||
{
|
||
// No place on purpose: picking one is what `link-booking` does.
|
||
title: 'teamLab Planets timed entry', type: 'event', status: 'pending', place: null,
|
||
reservation_time: at(-9, '14:00'), reservation_end_time: at(-9, '16:00'),
|
||
confirmation_number: 'TL-88213', location: '6-1-16 Toyosu, Koto City, Tokyo',
|
||
url: 'https://www.teamlab.art/e/planets/',
|
||
notes: 'Barefoot from the entrance. Bring shorts, the water room is knee-deep.',
|
||
},
|
||
{
|
||
title: 'Fushimi Inari night walk', type: 'tour', status: 'confirmed', place: 'Fushimi Inari Taisha',
|
||
reservation_time: at(-5, '18:30'), reservation_end_time: at(-5, '21:00'),
|
||
confirmation_number: 'KY-4471', location: '68 Fukakusa Yabunouchicho, Fushimi Ward, Kyoto',
|
||
url: null, notes: null,
|
||
},
|
||
{
|
||
title: 'Kyoto Cycling Tour', type: 'tour', status: 'pending', place: null,
|
||
reservation_time: at(-3, '09:30'), reservation_end_time: at(-3, '13:00'),
|
||
confirmation_number: 'KCT-1177', location: 'Kyoto Station, Karasuma exit',
|
||
url: null, notes: null,
|
||
},
|
||
{
|
||
title: 'Haneda Airport P4', type: 'parking', status: 'pending', place: null,
|
||
reservation_time: at(-9, '10:00'), reservation_end_time: at(0, '22:00'),
|
||
confirmation_number: 'HP4-2209', location: 'Haneda Airport Terminal 3, Ota City, Tokyo',
|
||
url: null, notes: null,
|
||
},
|
||
{
|
||
title: 'Luggage forwarding to Kyoto', type: 'other', status: 'pending', place: null,
|
||
reservation_time: at(-5, '09:00'), reservation_end_time: null,
|
||
confirmation_number: 'YMT-30915', location: 'Takkyubin counter, Shinjuku',
|
||
url: null, notes: 'Two suitcases, delivered by 17:00 the next day.',
|
||
},
|
||
]
|
||
|
||
/** The hotel `booking-hotel` books; a trip place with no stay of its own yet. */
|
||
export const HOTEL_TO_BOOK = {
|
||
name: 'Hotel Granvia Kyoto',
|
||
lat: 34.9855,
|
||
lng: 135.7587,
|
||
address: 'Shiokoji-sagaru, Karasuma-dori, Shimogyo-ku, Kyoto',
|
||
}
|
||
|
||
/** The trip file `booking-files` links; it must stay attached to nothing. */
|
||
export const UNATTACHED_FILE = 'kyoto-vouchers.pdf'
|
||
|
||
/**
|
||
* What the Bookings tab needs beyond the seed.
|
||
*
|
||
* The seed's one reservation is the LH716 flight, and a flight is a transport:
|
||
* on the bare seed this tab is its empty state, so every picture on it needs a
|
||
* fixture. `ensureDaysFixtures` already makes the two that the day cards want
|
||
* as well, the Gracery stay and the Nishiki lunch, and they are exactly the
|
||
* accommodation and the restaurant this tab wants, so it is called rather than
|
||
* copied. On top of it: an event, two tours (one with travellers), a parking
|
||
* and an "other", which is one card of every type the tab can hold, four
|
||
* pending and three confirmed; a second hotel as a trip place with no stay,
|
||
* for `booking-hotel` to book without disturbing the Gracery one; and an
|
||
* unattached document, without which Link existing file is not rendered.
|
||
*/
|
||
export async function ensureBookingsFixtures(api: APIRequestContext): Promise<void> {
|
||
await ensureDaysFixtures(api)
|
||
const { tripId, memberIds } = seededTrip()
|
||
|
||
const placesRes = await api.get(`/api/trips/${tripId}/places`)
|
||
const placesBody = (await placesRes.json()) as { places?: { id: number; name: string }[] } | { id: number; name: string }[]
|
||
const places = Array.isArray(placesBody) ? placesBody : (placesBody.places ?? [])
|
||
const placeId = (name: string) => places.find(p => p.name === name)?.id ?? null
|
||
if (!placeId(HOTEL_TO_BOOK.name)) {
|
||
const created = await api.post(`/api/trips/${tripId}/places`, { data: HOTEL_TO_BOOK })
|
||
if (!created.ok()) throw new Error(`could not create "${HOTEL_TO_BOOK.name}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
const listRes = await api.get(`/api/trips/${tripId}/reservations`)
|
||
const listBody = (await listRes.json()) as { reservations?: { id: number; title: string }[] } | { id: number; title: string }[]
|
||
const existing = Array.isArray(listBody) ? listBody : (listBody.reservations ?? [])
|
||
for (const booking of BOOKING_FIXTURES) {
|
||
if (existing.some(r => r.title === booking.title)) continue
|
||
const { place, ...rest } = booking
|
||
const created = await api.post(`/api/trips/${tripId}/reservations`, {
|
||
data: { ...rest, place_id: place ? placeId(place) : null },
|
||
})
|
||
if (!created.ok()) throw new Error(`could not create "${booking.title}": ${created.status()} ${await created.text()}`)
|
||
// The avatar filter in the toolbar only exists once a booking names someone.
|
||
if (booking.title === 'Fushimi Inari night walk') {
|
||
const { reservation } = (await created.json()) as { reservation: { id: number } }
|
||
const assigned = await api.put(`/api/trips/${tripId}/reservations/${reservation.id}/travelers`, {
|
||
data: { user_ids: [1, memberIds[0]] },
|
||
})
|
||
if (!assigned.ok()) throw new Error(`could not assign travellers: ${assigned.status()} ${await assigned.text()}`)
|
||
}
|
||
}
|
||
|
||
const filesRes = await api.get(`/api/trips/${tripId}/files`)
|
||
const { files = [] } = (await filesRes.json()) as { files?: { original_name: string }[] }
|
||
if (!files.some(f => f.original_name === UNATTACHED_FILE)) {
|
||
const uploaded = await api.post(`/api/trips/${tripId}/files`, {
|
||
multipart: {
|
||
file: { name: UNATTACHED_FILE, mimeType: 'application/pdf', buffer: readFileSync(bookingPdfFixture('kyoto-vouchers')) },
|
||
description: 'Kyoto vouchers',
|
||
},
|
||
})
|
||
if (!uploaded.ok()) throw new Error(`could not upload ${UNATTACHED_FILE}: ${uploaded.status()} ${await uploaded.text()}`)
|
||
}
|
||
}
|
||
|
||
// ── Trip: lists ───────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* What the Lists guides need beyond the seed.
|
||
*
|
||
* Two things are missing from the seeded trip. ApplyTemplateButton renders
|
||
* nothing at all while no template exists, so `Apply template` would have no
|
||
* target to ring; and all three seeded tasks are unchecked, unassigned and
|
||
* (today being after their due dates) overdue, which leaves My Tasks, Done and
|
||
* the progress card at zero in every picture of the to-do sidebar. One
|
||
* template and two more tasks fix both. Idempotent: each thing is looked up by
|
||
* name first, so a re-run against a warm database changes nothing.
|
||
*/
|
||
export const LISTS_TEMPLATE = {
|
||
name: 'Japan autumn basics',
|
||
categories: [
|
||
{ name: 'Rain kit', items: ['Umbrella', 'Quick-dry towel', 'Dry bag'] },
|
||
{ name: 'Tech', items: ['SIM card', 'Plug adapter'] },
|
||
],
|
||
}
|
||
|
||
interface ListsTodo {
|
||
name: string
|
||
category: string
|
||
due_date?: string
|
||
priority?: number
|
||
/** Assigned to whoever runs the capture, so the My Tasks filter has a row. */
|
||
mine?: boolean
|
||
/** Ticked off afterwards, so Done and the progress card are not empty. */
|
||
done?: boolean
|
||
}
|
||
|
||
const LISTS_TODOS: ListsTodo[] = [
|
||
{ name: 'Confirm ryokan check-in time', category: 'Before departure', due_date: day(4), priority: 3, mine: true },
|
||
{ name: 'Buy a Suica top-up', category: 'On arrival', done: true },
|
||
]
|
||
|
||
export async function ensureListsFixtures(api: APIRequestContext): Promise<void> {
|
||
const { tripId } = seededTrip()
|
||
|
||
const templates = await listOf<{ id: number; name: string }>(api, '/api/admin/packing-templates', 'templates')
|
||
if (!templates.some(t => t.name === LISTS_TEMPLATE.name)) {
|
||
const created = await api.post('/api/admin/packing-templates', { data: { name: LISTS_TEMPLATE.name } })
|
||
if (!created.ok()) throw new Error(`could not create the lists template: ${created.status()} ${await created.text()}`)
|
||
const body = (await created.json()) as { id?: number; template?: { id: number } }
|
||
const templateId = body.id ?? body.template?.id
|
||
if (!templateId) throw new Error('the lists template came back without an id')
|
||
for (const cat of LISTS_TEMPLATE.categories) {
|
||
const catRes = await api.post(`/api/admin/packing-templates/${templateId}/categories`, { data: { name: cat.name } })
|
||
if (!catRes.ok()) throw new Error(`could not add template list "${cat.name}": ${catRes.status()} ${await catRes.text()}`)
|
||
const category = (await catRes.json()) as { id?: number; category?: { id: number } }
|
||
const catId = category.id ?? category.category?.id
|
||
if (!catId) throw new Error(`template list "${cat.name}" came back without an id`)
|
||
for (const name of cat.items) {
|
||
const itemRes = await api.post(`/api/admin/packing-templates/${templateId}/categories/${catId}/items`, { data: { name } })
|
||
if (!itemRes.ok()) throw new Error(`could not add template item "${name}": ${itemRes.status()} ${await itemRes.text()}`)
|
||
}
|
||
}
|
||
}
|
||
|
||
const membersRes = await api.get(`/api/trips/${tripId}/members`)
|
||
if (!membersRes.ok()) throw new Error(`could not read the trip members: ${membersRes.status()} ${await membersRes.text()}`)
|
||
const { current_user_id: me } = (await membersRes.json()) as { current_user_id?: number }
|
||
|
||
const tasks = await listOf<{ id: number; name: string }>(api, `/api/trips/${tripId}/todo`, 'items')
|
||
for (const todo of LISTS_TODOS) {
|
||
if (tasks.some(t => t.name === todo.name)) continue
|
||
const created = await api.post(`/api/trips/${tripId}/todo`, {
|
||
data: {
|
||
name: todo.name,
|
||
category: todo.category,
|
||
due_date: todo.due_date ?? null,
|
||
priority: todo.priority ?? 0,
|
||
assigned_user_id: todo.mine ? (me ?? null) : null,
|
||
},
|
||
})
|
||
if (!created.ok()) throw new Error(`could not create the task "${todo.name}": ${created.status()} ${await created.text()}`)
|
||
if (!todo.done) continue
|
||
const { item } = (await created.json()) as { item: { id: number } }
|
||
const ticked = await api.put(`/api/trips/${tripId}/todo/${item.id}`, { data: { checked: true } })
|
||
if (!ticked.ok()) throw new Error(`could not tick "${todo.name}" off: ${ticked.status()} ${await ticked.text()}`)
|
||
}
|
||
}
|
||
|
||
// ── Trip: costs ───────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* The one thing the Costs tab of the seeded trip is missing: an expense nobody
|
||
* has paid for. All five seeded expenses have a payer, so Outstanding amount
|
||
* reads zero, no row carries the Unfinished pill, and two of the four summary
|
||
* cards say the same thing. This adds a counter fare the group has not booked
|
||
* yet: it counts into Total trip spend, stays out of every balance, and gives
|
||
* the screen its fourth state. It stays for every guide; what a guide creates
|
||
* itself, that guide deletes again.
|
||
*
|
||
* `payers` is left out on purpose. The server only re-derives total_price from
|
||
* the payers when there is at least one, so the total survives and the item is
|
||
* unfinished.
|
||
*/
|
||
const UNPAID_EXPENSE = {
|
||
name: 'Airport transfer (Narita Express)',
|
||
category: 'transport',
|
||
total_price: 12000,
|
||
currency: 'JPY',
|
||
expense_date: day(-8),
|
||
note: 'Nobody has booked it yet, so this is the counter fare for three.',
|
||
}
|
||
|
||
export async function ensureCostsFixtures(api: APIRequestContext): Promise<void> {
|
||
const { tripId, memberIds } = seededTrip()
|
||
const res = await api.get(`/api/trips/${tripId}/budget`)
|
||
const { items } = (await res.json()) as { items: { name: string }[] }
|
||
if (items.some(i => i.name === UNPAID_EXPENSE.name)) return
|
||
const created = await api.post(`/api/trips/${tripId}/budget`, {
|
||
data: { ...UNPAID_EXPENSE, member_ids: [1, ...memberIds] },
|
||
})
|
||
if (!created.ok()) throw new Error(`could not create "${UNPAID_EXPENSE.name}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
// ── Trip: files ───────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* What the Files guides act on. The seed creates no document at all, so without
|
||
* this the tab is an empty state in every picture. Nothing in the repository may
|
||
* carry a real ticket or someone's photograph, so the whole set is drawn here on
|
||
* first use, the way `coverFixture` draws its cover: the pictures from an SVG
|
||
* through sharp, the PDFs assembled by hand, the text files written out.
|
||
*/
|
||
|
||
/** One-page PDFs. The body is what the reader would see if they opened the file. */
|
||
const FILE_PDFS: Record<string, PdfDoc> = {
|
||
'JR-Pass-voucher': {
|
||
issuer: 'Japan Rail Pass',
|
||
title: 'Exchange order',
|
||
reference: 'Order 7714-20-JP',
|
||
fields: [
|
||
['Pass', 'Japan Rail Pass, Ordinary'],
|
||
['Validity', '14 consecutive days'],
|
||
['Travellers', '2 adults'],
|
||
['Exchange at', 'Haneda Airport Terminal 3, JR East Travel Service Center'],
|
||
['Opening hours', 'Daily 07:30 to 18:30'],
|
||
],
|
||
footer: 'The pass is valid from the day it is exchanged, not from the day of purchase.',
|
||
},
|
||
'LH716-boarding-pass': {
|
||
issuer: 'Lufthansa',
|
||
title: 'Boarding pass',
|
||
reference: 'Booking LH-4QK2PZ, flight LH716',
|
||
fields: [
|
||
['Passenger', 'BOE / MAURICE MR'],
|
||
['From', 'Frankfurt (FRA), Terminal 1'],
|
||
['To', 'Tokyo Haneda (HND), Terminal 3'],
|
||
['Date', short(-9)],
|
||
['Boarding / departure', '12:20 at gate A34, departure 13:05'],
|
||
['Seat / class', '34K, window, Economy'],
|
||
],
|
||
footer: 'Be at the gate 20 minutes before departure. Boarding closes 15 minutes before.',
|
||
},
|
||
'old-draft-itinerary': {
|
||
issuer: 'Autumn in Japan',
|
||
title: 'Itinerary, first draft',
|
||
reference: 'Superseded by the plan in TREK',
|
||
fields: [
|
||
['Day 1', 'Asakusa, Senso-ji and the river'],
|
||
['Day 2', 'Shibuya, Meiji Jingu, Harajuku'],
|
||
['Day 3', 'Free, weather permitting'],
|
||
['Day 4', 'Shinkansen to Kyoto, Gion in the evening'],
|
||
],
|
||
footer: 'Kept for the notes on day 4; everything else moved into the trip.',
|
||
},
|
||
'hakone-ryokan-confirmation': {
|
||
issuer: 'Hakone Ginyu',
|
||
title: 'Reservation confirmed',
|
||
reference: 'Confirmation RY-4471',
|
||
fields: [
|
||
['Guests', '2 adults, one room'],
|
||
['Nights', 'Two nights, half board'],
|
||
['Check-in / check-out', 'From 15:00, until 11:00'],
|
||
['Dinner', 'Kaiseki served at 18:30 in the room'],
|
||
['Total', 'JPY 96,000, paid by card'],
|
||
],
|
||
footer: 'Cancellation is free up to seven days before arrival.',
|
||
},
|
||
'kyoto-bus-pass': {
|
||
issuer: 'Kyoto City Bus',
|
||
title: 'One day pass',
|
||
reference: 'Pass 0421-8837',
|
||
fields: [
|
||
['Valid on', 'All city lines inside the flat-fare zone'],
|
||
['Valid for', 'One calendar day, first use to last bus'],
|
||
['Not valid on', 'Kyoto Bus express services and the airport lines'],
|
||
],
|
||
footer: 'Show the pass to the driver when you leave the bus, printed side up.',
|
||
},
|
||
}
|
||
|
||
/** Pictures, drawn flat so they read at thumbnail size as well as full screen. */
|
||
/**
|
||
* The pictures of the trip. No photograph may live in this repository, so they
|
||
* are composed instead: three layers per picture, the far one thrown out of
|
||
* focus, the near one sharp, and grain over the lot. A single flat drawing
|
||
* reads as a drawing at any size; a depth of field does not.
|
||
*/
|
||
interface PhotoLayer {
|
||
/** The SVG body of this layer, over the 1600×900 frame. */
|
||
svg: string
|
||
/** How far out of focus it is, in pixels. */
|
||
blur?: number
|
||
}
|
||
|
||
interface PhotoFixture {
|
||
ext: 'jpg' | 'png'
|
||
layers: readonly PhotoLayer[]
|
||
}
|
||
|
||
/** Dust and film grain, sprinkled from a fixed seed so a re-run draws the same frame. */
|
||
const grain = (seed: number, count = 900): string =>
|
||
Array.from({ length: count }, (_, i) => {
|
||
const r = (n: number) => (Math.sin(seed + i * n) + 1) / 2
|
||
return `<rect x="${(r(12.9898) * 1600).toFixed(0)}" y="${(r(78.233) * 900).toFixed(0)}" width="${(1 + r(9.31) * 2).toFixed(1)}" height="${(1 + r(5.77) * 2).toFixed(1)}" fill="${r(3.3) > 0.5 ? '#ffffff' : '#000000'}" opacity="${(0.02 + r(4.14) * 0.06).toFixed(3)}"/>`
|
||
}).join('')
|
||
|
||
/** Somebody with their back to us, which is what fills a market lane. */
|
||
const person = (x: number, ground: number, h: number, tone: string): string =>
|
||
`<g fill="${tone}"><circle cx="${x}" cy="${(ground - h * 0.87).toFixed(0)}" r="${(h * 0.1).toFixed(0)}"/>` +
|
||
`<path d="M${(x - h * 0.19).toFixed(0)} ${ground} L${(x - h * 0.15).toFixed(0)} ${(ground - h * 0.52).toFixed(0)} Q${x} ${(ground - h * 0.84).toFixed(0)} ${(x + h * 0.15).toFixed(0)} ${(ground - h * 0.52).toFixed(0)} L${(x + h * 0.19).toFixed(0)} ${ground} Z"/></g>`
|
||
|
||
/** A pile of produce: a handful of small round things, not one big rectangle. */
|
||
const pile = (x: number, y: number, colour: string, n = 9): string =>
|
||
Array.from({ length: n }, (_, i) => {
|
||
const row = Math.floor(i / 4)
|
||
return `<circle cx="${x + (i % 4) * 17 + row * 8}" cy="${y - row * 12}" r="${9 - row}" fill="${colour}" opacity="${0.95 - row * 0.12}"/>`
|
||
}).join('')
|
||
|
||
/** A haze of light: what a lamp or the sun does to the air in front of it. */
|
||
const bloom = (x: number, y: number, r: number, colour: string, opacity = 0.7): string =>
|
||
`<circle cx="${x}" cy="${y}" r="${r}" fill="${colour}" opacity="${opacity}"/>`
|
||
|
||
const FILE_IMAGES: Record<string, PhotoFixture> = {
|
||
'nishiki-market': {
|
||
// What people photograph for later is rarely the market itself; it is the
|
||
// map with the market pinned on it.
|
||
ext: 'jpg',
|
||
layers: [
|
||
{
|
||
svg: `<defs>
|
||
<filter id="drop" x="-30%" y="-30%" width="160%" height="160%">
|
||
<feDropShadow dx="0" dy="2" stdDeviation="4" flood-color="#1b2430" flood-opacity="0.22"/>
|
||
</filter>
|
||
</defs>
|
||
<rect width="1600" height="900" fill="#f4f1ea"/>
|
||
${[0, 1, 2, 3, 4, 5, 6, 7].map(i => [0, 1, 2, 3, 4].map(k => `<rect x="${40 + i * 190}" y="${40 + k * 180}" width="150" height="130" rx="4" fill="#e9e4d8"/>`).join('')).join('\n ')}
|
||
<path d="M1360 0 C1400 220 1330 420 1390 620 C1430 760 1380 840 1400 900 L1600 900 L1600 0 Z" fill="#a9cde6"/>
|
||
<path d="M1360 0 C1400 220 1330 420 1390 620 C1430 760 1380 840 1400 900" stroke="#8fb9d6" stroke-width="4" fill="none"/>
|
||
<rect x="150" y="560" width="300" height="230" rx="18" fill="#cfe6c0"/>
|
||
<rect x="980" y="120" width="250" height="190" rx="18" fill="#cfe6c0"/>
|
||
${[0, 1, 2, 3, 4].map(k => `<path d="M0 ${20 + k * 180} H1600" stroke="#ded8cb" stroke-width="26"/>`).join('\n ')}
|
||
${[0, 1, 2, 3, 4].map(k => `<path d="M0 ${20 + k * 180} H1600" stroke="#ffffff" stroke-width="18"/>`).join('\n ')}
|
||
${[0, 1, 2, 3, 4, 5, 6, 7].map(i => `<path d="M${20 + i * 190} 0 V900" stroke="#ded8cb" stroke-width="22"/>`).join('\n ')}
|
||
${[0, 1, 2, 3, 4, 5, 6, 7].map(i => `<path d="M${20 + i * 190} 0 V900" stroke="#ffffff" stroke-width="15"/>`).join('\n ')}
|
||
<path d="M0 560 H1600" stroke="#e8cf92" stroke-width="34"/>
|
||
<path d="M0 560 H1600" stroke="#fbe9b6" stroke-width="26"/>
|
||
<path d="M780 0 V900" stroke="#e8cf92" stroke-width="30"/>
|
||
<path d="M780 0 V900" stroke="#fbe9b6" stroke-width="22"/>
|
||
<path d="M0 740 H1330" stroke="#c9c3b4" stroke-width="7"/>
|
||
<path d="M0 740 H1330" stroke="#ffffff" stroke-width="5" stroke-dasharray="16 16"/>
|
||
<path d="M120 380 H1240" stroke="#e7e1d4" stroke-width="30"/>
|
||
<path d="M120 380 H1240" stroke="#ffffff" stroke-width="23"/>
|
||
<path d="M120 380 H1240" stroke="#f0d6c8" stroke-width="9" stroke-dasharray="2 14" stroke-linecap="round"/>
|
||
<text x="150" y="372" font-family="Arial, sans-serif" font-size="19" fill="#8b8676">Nishiki-koji Street</text>
|
||
<text x="820" y="552" font-family="Arial, sans-serif" font-size="21" fill="#8b8676">Shijo-dori</text>
|
||
<text x="1420" y="300" font-family="Arial, sans-serif" font-size="21" fill="#5b8fb0">Kamo River</text>
|
||
<text x="196" y="700" font-family="Arial, sans-serif" font-size="20" fill="#6f8b62">Shinsen-en</text>
|
||
<text x="1018" y="240" font-family="Arial, sans-serif" font-size="20" fill="#6f8b62">Gosho Park</text>
|
||
<text x="640" y="838" font-family="Arial, sans-serif" font-size="22" fill="#9b968a">NAKAGYO</text>
|
||
${[[300, 300], [1080, 470], [560, 690], [1180, 660]].map(([x, y]) => `<circle cx="${x}" cy="${y}" r="7" fill="#c9723b"/>`).join('\n ')}
|
||
<g filter="url(#drop)">
|
||
<path d="M700 430 C700 388 734 356 776 356 C818 356 852 388 852 430 C852 482 776 540 776 540 C776 540 700 482 700 430 Z" fill="#d93025"/>
|
||
<circle cx="776" cy="428" r="24" fill="#ffffff"/>
|
||
</g>
|
||
<g filter="url(#drop)">
|
||
<rect x="606" y="252" width="342" height="86" rx="14" fill="#ffffff"/>
|
||
<text x="628" y="290" font-family="Arial, sans-serif" font-size="25" font-weight="bold" fill="#1b2430">Nishiki Market</text>
|
||
<text x="628" y="320" font-family="Arial, sans-serif" font-size="20" fill="#7a7566">4.4 (12,806) · Market</text>
|
||
</g>
|
||
<g filter="url(#drop)">
|
||
<rect x="44" y="40" width="470" height="66" rx="33" fill="#ffffff"/>
|
||
<circle cx="86" cy="73" r="13" fill="none" stroke="#7a7566" stroke-width="4"/>
|
||
<path d="M96 83 L108 95" stroke="#7a7566" stroke-width="4" stroke-linecap="round"/>
|
||
<text x="122" y="82" font-family="Arial, sans-serif" font-size="23" fill="#3c4450">Nishiki Market, Kyoto</text>
|
||
</g>
|
||
<g filter="url(#drop)">
|
||
<rect x="1494" y="40" width="62" height="124" rx="12" fill="#ffffff"/>
|
||
<path d="M1512 82 H1538 M1525 69 V95" stroke="#3c4450" stroke-width="5" stroke-linecap="round"/>
|
||
<path d="M1494 102 H1556" stroke="#e6e2d8" stroke-width="2"/>
|
||
<path d="M1512 132 H1538" stroke="#3c4450" stroke-width="5" stroke-linecap="round"/>
|
||
</g>
|
||
<path d="M44 860 V876 H204 V860" stroke="#5b6472" stroke-width="3" fill="none"/>
|
||
<text x="212" y="878" font-family="Arial, sans-serif" font-size="19" fill="#5b6472">200 m</text>
|
||
<text x="1556" y="878" text-anchor="end" font-family="Arial, sans-serif" font-size="17" fill="#6d7686">Map data © OpenStreetMap contributors</text>
|
||
${grain(6.2, 200)}`,
|
||
},
|
||
],
|
||
},
|
||
'hakone-ryokan': {
|
||
// The confirmation as it looked in the browser, saved to the trip.
|
||
ext: 'jpg',
|
||
layers: [
|
||
{
|
||
svg: `<defs>
|
||
<filter id="card" x="-20%" y="-20%" width="140%" height="140%">
|
||
<feDropShadow dx="0" dy="3" stdDeviation="8" flood-color="#0f172a" flood-opacity="0.12"/>
|
||
</filter>
|
||
</defs>
|
||
<rect width="1600" height="900" fill="#eef0f3"/>
|
||
<rect width="1600" height="64" fill="#e3e6ea"/>
|
||
<circle cx="44" cy="32" r="9" fill="#ed6a5e"/><circle cx="76" cy="32" r="9" fill="#f4bf4f"/><circle cx="108" cy="32" r="9" fill="#61c554"/>
|
||
<rect x="150" y="14" width="740" height="36" rx="18" fill="#ffffff"/>
|
||
<path d="M176 32 a7 7 0 0 1 14 0 v6 h-14 z" fill="none" stroke="#7b8494" stroke-width="3"/>
|
||
<text x="204" y="39" font-family="Arial, sans-serif" font-size="19" fill="#5b6472">hakone-ginyu.jp/reservations/RY-4471</text>
|
||
<rect y="64" width="1600" height="836" fill="#ffffff"/>
|
||
<text x="80" y="150" font-family="Georgia, serif" font-size="40" fill="#16202c">Hakone Ginyu</text>
|
||
<text x="80" y="186" font-family="Arial, sans-serif" font-size="21" fill="#6b7482">Ryokan · Miyanoshita, Hakone-machi, Kanagawa</text>
|
||
<rect x="1180" y="112" width="200" height="46" rx="23" fill="#e6f4ea"/>
|
||
<path d="M1206 135 l10 11 l20 -22" stroke="#137333" stroke-width="5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
|
||
<text x="1246" y="143" font-family="Arial, sans-serif" font-size="21" font-weight="bold" fill="#137333">Confirmed</text>
|
||
<path d="M80 224 H1520" stroke="#e5e8ec" stroke-width="2"/>
|
||
<text x="80" y="268" font-family="Arial, sans-serif" font-size="18" fill="#8b93a1">CONFIRMATION</text>
|
||
<text x="80" y="300" font-family="Arial, sans-serif" font-size="27" font-weight="bold" fill="#16202c">RY-4471</text>
|
||
${[['Check-in', `${short(-4)}, from 15:00`], ['Check-out', `${short(-2)}, until 11:00`], ['Guests', '2 adults, one room'], ['Room', 'Japanese suite with open-air bath'], ['Meals', 'Kaiseki dinner and breakfast included']].map(([k, v], i) => `<g>
|
||
<text x="80" y="${376 + i * 82}" font-family="Arial, sans-serif" font-size="18" fill="#8b93a1">${k.toUpperCase()}</text>
|
||
<text x="80" y="${408 + i * 82}" font-family="Arial, sans-serif" font-size="25" fill="#16202c">${v}</text>
|
||
<path d="M80 ${430 + i * 82} H880" stroke="#eef0f3" stroke-width="2"/>
|
||
</g>`).join('\n ')}
|
||
<text x="80" y="824" font-family="Arial, sans-serif" font-size="18" fill="#8b93a1">TOTAL, PAID BY CARD</text>
|
||
<text x="80" y="860" font-family="Arial, sans-serif" font-size="31" font-weight="bold" fill="#16202c">JPY 96,000</text>
|
||
<g filter="url(#card)">
|
||
<rect x="960" y="256" width="560" height="380" rx="16" fill="#ffffff"/>
|
||
<rect x="960" y="256" width="560" height="220" rx="16" fill="#e8eadf"/>
|
||
<rect x="960" y="400" width="560" height="76" fill="#e8eadf"/>
|
||
<path d="M960 380 C1080 356 1180 400 1290 372 C1390 348 1460 380 1520 366" stroke="#a9cde6" stroke-width="26" fill="none"/>
|
||
<rect x="1010" y="300" width="120" height="70" rx="6" fill="#dfe3d4"/>
|
||
<rect x="1180" y="284" width="150" height="60" rx="6" fill="#dfe3d4"/>
|
||
<path d="M960 340 H1520" stroke="#ffffff" stroke-width="10"/>
|
||
<path d="M1120 256 V476" stroke="#ffffff" stroke-width="8"/>
|
||
<path d="M1216 336 C1216 320 1229 308 1245 308 C1261 308 1274 320 1274 336 C1274 356 1245 378 1245 378 C1245 378 1216 356 1216 336 Z" fill="#d93025"/>
|
||
<circle cx="1245" cy="335" r="9" fill="#ffffff"/>
|
||
<text x="992" y="528" font-family="Arial, sans-serif" font-size="18" fill="#8b93a1">ADDRESS</text>
|
||
<text x="992" y="560" font-family="Arial, sans-serif" font-size="22" fill="#16202c">100-1 Miyanoshita, Hakone-machi</text>
|
||
<text x="992" y="592" font-family="Arial, sans-serif" font-size="22" fill="#16202c">Ashigarashimo, Kanagawa 250-0404</text>
|
||
</g>
|
||
<rect x="960" y="672" width="560" height="188" rx="16" fill="#f5f6f8"/>
|
||
<text x="992" y="716" font-family="Arial, sans-serif" font-size="20" font-weight="bold" fill="#16202c">Cancellation</text>
|
||
<text x="992" y="754" font-family="Arial, sans-serif" font-size="20" fill="#5b6472">Free until seven days before arrival.</text>
|
||
<text x="992" y="788" font-family="Arial, sans-serif" font-size="20" fill="#5b6472">After that, one night is charged.</text>
|
||
<text x="992" y="828" font-family="Arial, sans-serif" font-size="19" fill="#8b93a1">Questions: +81 460 82 3355</text>
|
||
${grain(9.4, 160)}`,
|
||
},
|
||
],
|
||
},
|
||
'jr-pass-map': {
|
||
ext: 'png',
|
||
layers: [
|
||
{
|
||
// A printed network map: paper, its fold and the grid under the lines.
|
||
svg: `<defs>
|
||
<linearGradient id="paper" x1="0" y1="0" x2="1" y2="1">
|
||
<stop offset="0" stop-color="#fcfaf4"/><stop offset="0.5" stop-color="#f3f0e6"/><stop offset="1" stop-color="#e9e5d8"/>
|
||
</linearGradient>
|
||
</defs>
|
||
<rect width="1600" height="900" fill="url(#paper)"/>
|
||
<g opacity="0.45">
|
||
${Array.from({ length: 9 }, (_, i) => `<path d="M0 ${100 * i + 50} H1600" stroke="#dbd5c4" stroke-width="1"/>`).join('\n ')}
|
||
${Array.from({ length: 16 }, (_, i) => `<path d="M${100 * i + 50} 0 V900" stroke="#dbd5c4" stroke-width="1"/>`).join('\n ')}
|
||
</g>
|
||
<path d="M800 0 V900" stroke="#cfc9b6" stroke-width="3" opacity="0.5"/>
|
||
<path d="M0 450 H1600" stroke="#cfc9b6" stroke-width="3" opacity="0.35"/>
|
||
<path d="M120 760 Q300 760 420 690 L640 560 Q760 490 900 490 L1300 490 Q1400 490 1470 420" stroke="#bcd3c4" stroke-width="32" fill="none" stroke-linecap="round"/>
|
||
<path d="M120 760 Q300 760 420 690 L640 560 Q760 490 900 490 L1300 490 Q1400 490 1470 420" stroke="#1f6f3f" stroke-width="13" fill="none" stroke-linecap="round"/>
|
||
<path d="M150 230 L600 230 Q700 230 760 290 L900 430 Q960 490 1060 490 L1460 490" stroke="#e7c8c2" stroke-width="32" fill="none" stroke-linecap="round"/>
|
||
<path d="M150 230 L600 230 Q700 230 760 290 L900 430 Q960 490 1060 490 L1460 490" stroke="#c0392b" stroke-width="13" fill="none" stroke-linecap="round"/>
|
||
<path d="M330 862 L980 862" stroke="#c8b78e" stroke-width="9" fill="none" stroke-linecap="round" stroke-dasharray="3 20"/>
|
||
${[[120, 760, 'Hakata'], [420, 690, 'Hiroshima'], [640, 560, 'Osaka'], [900, 490, 'Kyoto'], [1300, 490, 'Nagoya'], [1470, 420, 'Tokyo'], [150, 230, 'Kanazawa'], [600, 230, 'Toyama'], [1060, 490, 'Gifu']].map(([x, y, name]) =>
|
||
`<g><circle cx="${x}" cy="${y}" r="14" fill="#ffffff" stroke="#2c3e50" stroke-width="6"/><text x="${x}" y="${(y as number) - 30}" text-anchor="middle" font-family="Arial, sans-serif" font-size="25" fill="#3d4756">${name}</text></g>`).join('\n ')}
|
||
<g>
|
||
<rect x="70" y="60" width="440" height="126" rx="14" fill="#ffffff" opacity="0.93"/>
|
||
<text x="100" y="112" font-family="Arial, sans-serif" font-size="33" font-weight="bold" fill="#22303f">Rail pass network</text>
|
||
<rect x="100" y="134" width="34" height="8" rx="4" fill="#1f6f3f"/><text x="146" y="144" font-family="Arial, sans-serif" font-size="21" fill="#4a5568">Sanyo line</text>
|
||
<rect x="292" y="134" width="34" height="8" rx="4" fill="#c0392b"/><text x="338" y="144" font-family="Arial, sans-serif" font-size="21" fill="#4a5568">Hokuriku</text>
|
||
</g>
|
||
${grain(5.5, 260)}`,
|
||
},
|
||
],
|
||
},
|
||
arashiyama: {
|
||
ext: 'jpg',
|
||
layers: [
|
||
{
|
||
// The grove behind the path: light coming down through it, nothing in focus.
|
||
blur: 24,
|
||
svg: `<defs>
|
||
<linearGradient id="canopy" x1="0" y1="0" x2="0" y2="1">
|
||
<stop offset="0" stop-color="#e8f3c2"/><stop offset="0.3" stop-color="#8cb857"/><stop offset="1" stop-color="#1e3d1d"/>
|
||
</linearGradient>
|
||
</defs>
|
||
<rect width="1600" height="900" fill="url(#canopy)"/>
|
||
${bloom(780, 90, 460, '#fbffd8', 0.55)}
|
||
${Array.from({ length: 26 }, (_, i) => {
|
||
const x = -30 + i * 64
|
||
const tilt = ((i % 5) - 2) * 9
|
||
return `<path d="M${x} 900 L${x + tilt} 0 L${x + tilt + 26} 0 L${x + 26} 900 Z" fill="${['#33602d', '#487f37', '#5e9d45'][i % 3]}" opacity="0.9"/>`
|
||
}).join('\n ')}`,
|
||
},
|
||
{
|
||
// The stems either side of the path, just off the focal plane.
|
||
blur: 4,
|
||
svg: `${Array.from({ length: 9 }, (_, i) => {
|
||
const x = i < 5 ? 20 + i * 120 : 1000 + (i - 5) * 130
|
||
const w = 42 + (i % 3) * 12
|
||
const tilt = ((i % 4) - 1.5) * 12
|
||
return `<g>
|
||
<path d="M${x} 900 L${x + tilt} -40 L${x + tilt + w} -40 L${x + w} 900 Z" fill="${i % 2 ? '#3f7333' : '#557f38'}"/>
|
||
${Array.from({ length: 6 }, (_, k) => `<rect x="${x + tilt * (1 - k / 6) - 2}" y="${90 + k * 150}" width="${w + 4}" height="9" rx="4" fill="#24451f" opacity="0.55"/>`).join('')}
|
||
<path d="M${x + w - 8} 900 L${x + tilt + w - 8} -40 L${x + tilt + w} -40 L${x + w} 900 Z" fill="#d7e9a8" opacity="0.35"/>
|
||
</g>`
|
||
}).join('\n ')}`,
|
||
},
|
||
{
|
||
// The path itself, in focus, with the fence along it and the dapple of
|
||
// light that falls between the stems.
|
||
svg: `<path d="M0 806 Q420 748 820 782 Q1220 816 1600 764 V900 H0 Z" fill="#6a583a"/>
|
||
<path d="M0 826 Q420 768 820 802 Q1220 836 1600 784 V900 H0 Z" fill="#4c3d27"/>
|
||
<path d="M0 812 Q420 754 820 788 Q1220 822 1600 770" stroke="#8d7850" stroke-width="5" fill="none" opacity="0.6"/>
|
||
${[0, 1, 2, 3, 4, 5, 6, 7].map(i => `<g opacity="0.85">
|
||
<rect x="${-10 + i * 210}" y="700" width="14" height="120" rx="6" fill="#7a6540"/>
|
||
<rect x="${-10 + i * 210}" y="726" width="200" height="10" rx="5" fill="#8b7549"/>
|
||
</g>`).join('\n ')}
|
||
${[0, 1, 2, 3, 4, 5, 6, 7].map(i => `<ellipse cx="${90 + i * 210}" cy="${840 + (i % 3) * 16}" rx="${60 + (i % 3) * 30}" ry="${9 + (i % 2) * 5}" fill="#fdf6c8" opacity="0.05" transform="rotate(${-4 + (i % 3) * 4} ${90 + i * 210} ${840 + (i % 3) * 16})"/>`).join('\n ')}
|
||
${grain(2.4, 420)}
|
||
<rect width="1600" height="900" fill="url(#vig3)"/>
|
||
<defs><radialGradient id="vig3" cx="0.5" cy="0.4" r="0.8">
|
||
<stop offset="0.5" stop-color="#000000" stop-opacity="0"/><stop offset="1" stop-color="#000000" stop-opacity="0.5"/>
|
||
</radialGradient></defs>
|
||
${grain(11.3)}`,
|
||
},
|
||
],
|
||
},
|
||
}
|
||
|
||
/** The two plain-text documents; written out rather than drawn. */
|
||
const FILE_TEXTS = {
|
||
'travel-notes.md': `# Travel notes
|
||
|
||
What the rail passes cover, and what they do not.
|
||
|
||
- Activate the Japan Rail Pass at the counter in the arrivals hall, not before
|
||
- Reserve the Nozomi seats a day ahead; the pass does not cover Nozomi itself
|
||
- Keep the paper voucher, the gates do not read the app
|
||
|
||
## Legs
|
||
|
||
| Leg | Train | Time |
|
||
| --- | --- | --- |
|
||
| Tokyo to Kyoto | Nozomi 21 | 2h15 |
|
||
| Kyoto to Osaka | Local | 0h30 |
|
||
|
||
## Left to book
|
||
|
||
1. The bus up to Arashiyama
|
||
2. A table at Nishiki for the last evening
|
||
`,
|
||
'tokyo-metro-lines.csv': `line,colour,from,to,transfers
|
||
Ginza,orange,Asakusa,Shibuya,9
|
||
Marunouchi,red,Ogikubo,Ikebukuro,11
|
||
Hibiya,grey,Naka-Meguro,Kita-Senju,8
|
||
Oedo,magenta,Hikarigaoka,Tochomae,12
|
||
Yamanote,green,Tokyo,Tokyo,29
|
||
`,
|
||
} as const
|
||
|
||
/** The note the seed writes; its attachment is what puts the Collab Notes tab on the screen. */
|
||
const COLLAB_NOTE = 'Rail passes'
|
||
const COLLAB_ATTACHMENT = 'jr-pass-map.png'
|
||
/** Uploaded and then thrown away, so the trash is never empty and Empty Trash is always there. */
|
||
const TRASHED = { name: 'hakone-ryokan-confirmation.pdf', description: '2 nights, kaiseki at 18:30' }
|
||
|
||
/**
|
||
* The documents of the trip, in the order they are uploaded: the list is sorted
|
||
* newest first, so the last one here stands at the top of the screen.
|
||
*
|
||
* `travel-notes.md` goes up as `application/octet-stream` on purpose. The
|
||
* Documents tab counts by file name (`.doc`, `.xls`, `.txt`, `.csv`) but filters
|
||
* by MIME type (`word`, `excel`, `text`), so a markdown file sent as `text/*`
|
||
* would be listed under a badge that says 0. As an octet-stream it is on neither
|
||
* side of that split, and the preview finds it by its extension anyway.
|
||
*/
|
||
const TRIP_DOCUMENTS: { name: string; mimeType: string; from: () => string | Promise<string>; place?: string }[] = [
|
||
{ name: 'JR-Pass-voucher.pdf', mimeType: 'application/pdf', from: () => filesPdfFixture('JR-Pass-voucher') },
|
||
{ name: 'LH716-boarding-pass.pdf', mimeType: 'application/pdf', from: () => filesPdfFixture('LH716-boarding-pass') },
|
||
{ name: 'old-draft-itinerary.pdf', mimeType: 'application/pdf', from: () => filesPdfFixture('old-draft-itinerary') },
|
||
{ name: 'tokyo-metro-lines.csv', mimeType: 'text/csv', from: () => filesTextFixture('tokyo-metro-lines.csv') },
|
||
{ name: 'travel-notes.md', mimeType: 'application/octet-stream', from: () => filesTextFixture('travel-notes.md') },
|
||
{ name: 'hakone-ryokan.jpg', mimeType: 'image/jpeg', from: () => filesImageFixture('hakone-ryokan') },
|
||
{ name: 'nishiki-market.jpg', mimeType: 'image/jpeg', from: () => filesImageFixture('nishiki-market'), place: 'Nishiki Market' },
|
||
]
|
||
|
||
const tmpDir = (): string => {
|
||
const dir = path.join(process.cwd(), 'e2e', '.tmp')
|
||
mkdirSync(dir, { recursive: true })
|
||
return dir
|
||
}
|
||
|
||
/**
|
||
* A one-page PDF, written by hand because no PDF library is a dependency here.
|
||
* Five objects and an xref table whose offsets are counted off the assembled
|
||
* buffer; everything in it is ASCII, so bytes and characters are the same thing.
|
||
* Exported for the document-sync guide, which puts two of these into the store
|
||
* (`external.ts`) rather than into the trip.
|
||
*/
|
||
export interface PdfDoc {
|
||
/** The company or office the paper comes from, printed in the band at the top. */
|
||
issuer: string
|
||
/** What the document is, under the issuer. */
|
||
title: string
|
||
/** The line under the title: a booking code, an order number. */
|
||
reference: string
|
||
/** The body: a label and its value per row, the way a confirmation prints them. */
|
||
fields: readonly (readonly [string, string])[]
|
||
/** The small print along the bottom. */
|
||
footer: string
|
||
}
|
||
|
||
export function drawPdf(doc: PdfDoc): Buffer {
|
||
const esc = (v: string) => v.replace(/([\\()])/g, '\\$1')
|
||
// A4 in points, the origin at the bottom left. The band is drawn first, then
|
||
// the type over it; everything is Helvetica, which every PDF reader has.
|
||
const W = 595
|
||
const ink = '0.07 0.09 0.15'
|
||
const parts: string[] = [
|
||
`${ink} rg 0 762 ${W} 80 re f`,
|
||
`BT /F2 17 Tf 1 1 1 rg 56 806 Td (${esc(doc.issuer.toUpperCase())}) Tj ET`,
|
||
`BT /F1 10 Tf 0.75 0.78 0.85 rg 56 786 Td (${esc(doc.footer)}) Tj ET`,
|
||
`BT /F2 21 Tf 0.07 0.09 0.15 rg 56 706 Td (${esc(doc.title)}) Tj ET`,
|
||
`BT /F1 11 Tf 0.35 0.38 0.45 rg 56 684 Td (${esc(doc.reference)}) Tj ET`,
|
||
`0.85 0.86 0.9 RG 1 w 56 668 m ${W - 56} 668 l S`,
|
||
]
|
||
doc.fields.forEach(([label, value], i) => {
|
||
const y = 636 - i * 34
|
||
parts.push(`BT /F1 9 Tf 0.45 0.48 0.55 rg 56 ${y + 14} Td (${esc(label.toUpperCase())}) Tj ET`)
|
||
parts.push(`BT /F2 13 Tf 0.07 0.09 0.15 rg 56 ${y} Td (${esc(value)}) Tj ET`)
|
||
parts.push(`0.92 0.93 0.95 RG 0.6 w 56 ${y - 12} m ${W - 56} ${y - 12} l S`)
|
||
})
|
||
const bottom = 636 - doc.fields.length * 34 - 40
|
||
parts.push(`0.96 0.97 0.98 rg 56 ${bottom - 46} ${W - 112} 58 re f`)
|
||
parts.push(`BT /F1 10 Tf 0.35 0.38 0.45 rg 72 ${bottom - 12} Td (${esc(doc.footer)}) Tj ET`)
|
||
parts.push(`BT /F1 9 Tf 0.55 0.58 0.65 rg 72 ${bottom - 30} Td (${esc('This document was issued electronically and needs no signature.')}) Tj ET`)
|
||
const content = parts.join('\n')
|
||
const objects = [
|
||
'<< /Type /Catalog /Pages 2 0 R >>',
|
||
'<< /Type /Pages /Kids [3 0 R] /Count 1 >>',
|
||
'<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 5 0 R /F2 6 0 R >> >> /Contents 4 0 R >>',
|
||
`<< /Length ${Buffer.byteLength(content, 'latin1')} >>\nstream\n${content}\nendstream`,
|
||
'<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>',
|
||
'<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold >>',
|
||
]
|
||
let pdf = '%PDF-1.4\n'
|
||
const offsets: number[] = []
|
||
objects.forEach((body, i) => {
|
||
offsets.push(Buffer.byteLength(pdf, 'latin1'))
|
||
pdf += `${i + 1} 0 obj\n${body}\nendobj\n`
|
||
})
|
||
const startxref = Buffer.byteLength(pdf, 'latin1')
|
||
pdf += `xref\n0 ${objects.length + 1}\n0000000000 65535 f \n`
|
||
for (const offset of offsets) pdf += `${String(offset).padStart(10, '0')} 00000 n \n`
|
||
pdf += `trailer\n<< /Size ${objects.length + 1} /Root 1 0 R >>\nstartxref\n${startxref}\n%%EOF\n`
|
||
return Buffer.from(pdf, 'latin1')
|
||
}
|
||
|
||
/**
|
||
* One of the trip's PDFs as a file in `e2e/.tmp`. Drawn on every call: the
|
||
* boarding pass names its day, which is relative to the picture day, so a
|
||
* file left over from an earlier run would carry that run's date.
|
||
*/
|
||
export function filesPdfFixture(id: keyof typeof FILE_PDFS): string {
|
||
const file = path.join(tmpDir(), `${id}.pdf`)
|
||
writeFileSync(file, drawPdf(FILE_PDFS[id]))
|
||
return file
|
||
}
|
||
|
||
/** A 1600×900 picture, its layers blurred to their own degree and laid over each other. */
|
||
export async function filesImageFixture(id: keyof typeof FILE_IMAGES): Promise<string> {
|
||
const { ext, layers } = FILE_IMAGES[id]
|
||
const file = path.join(tmpDir(), `${id}.${ext}`)
|
||
if (existsSync(file)) return file
|
||
const render = async (layer: PhotoLayer): Promise<Buffer> => {
|
||
const document = `<svg xmlns="http://www.w3.org/2000/svg" width="1600" height="900" viewBox="0 0 1600 900">\n ${layer.svg}\n</svg>`
|
||
const drawn = sharp(Buffer.from(document))
|
||
return (layer.blur ? drawn.blur(layer.blur) : drawn).png().toBuffer()
|
||
}
|
||
const [base, ...rest] = await Promise.all(layers.map(render))
|
||
const composed = sharp(base).composite(rest.map(input => ({ input })))
|
||
await (ext === 'png' ? composed.png() : composed.jpeg({ quality: 88 })).toFile(file)
|
||
return file
|
||
}
|
||
|
||
/** The markdown and the CSV, written out on first use. */
|
||
export function filesTextFixture(id: keyof typeof FILE_TEXTS): string {
|
||
const file = path.join(tmpDir(), id)
|
||
if (existsSync(file)) return file
|
||
writeFileSync(file, FILE_TEXTS[id])
|
||
return file
|
||
}
|
||
|
||
async function uploadTripFile(
|
||
api: APIRequestContext,
|
||
tripId: number,
|
||
doc: { name: string; mimeType: string; from: () => string | Promise<string> },
|
||
fields: Record<string, string> = {},
|
||
): Promise<number> {
|
||
const res = await api.post(`/api/trips/${tripId}/files`, {
|
||
multipart: {
|
||
file: { name: doc.name, mimeType: doc.mimeType, buffer: readFileSync(await doc.from()) },
|
||
...fields,
|
||
},
|
||
})
|
||
if (!res.ok()) throw new Error(`could not upload "${doc.name}": ${res.status()} ${await res.text()}`)
|
||
const { file } = (await res.json()) as { file: { id: number } }
|
||
return file.id
|
||
}
|
||
|
||
export async function ensureFilesFixtures(api: APIRequestContext): Promise<void> {
|
||
// The Assign File dialog only shows a Booking section beside Transport once
|
||
// the trip has a reservation that is not a transport, and the day fixtures
|
||
// make one. Their hotel also gives the dialog a place under Unassigned.
|
||
await ensureDaysFixtures(api)
|
||
|
||
const { tripId } = seededTrip()
|
||
const placesRes = await api.get(`/api/trips/${tripId}/places`)
|
||
const placesBody = (await placesRes.json()) as { places?: { id: number; name: string }[] } | { id: number; name: string }[]
|
||
const places = Array.isArray(placesBody) ? placesBody : (placesBody.places ?? [])
|
||
|
||
const namesIn = async (trash: boolean): Promise<string[]> => {
|
||
const res = await api.get(`/api/trips/${tripId}/files${trash ? '?trash=true' : ''}`)
|
||
const body = (await res.json()) as { files?: { original_name: string }[] }
|
||
return (body.files ?? []).map(f => f.original_name)
|
||
}
|
||
// Both lists, so a document the fixture threw away is not uploaded a second time.
|
||
const present = new Set([...(await namesIn(false)), ...(await namesIn(true))])
|
||
|
||
for (const doc of TRIP_DOCUMENTS) {
|
||
if (present.has(doc.name)) continue
|
||
const placeId = doc.place ? places.find(p => p.name === doc.place)?.id : undefined
|
||
await uploadTripFile(api, tripId, doc, placeId ? { place_id: String(placeId) } : {})
|
||
}
|
||
|
||
// The Collab Notes tab and the "From Collab Notes" badge exist only while a
|
||
// note carries an attachment. It is an ordinary trip file with a note on it,
|
||
// so it shows up in this list too.
|
||
if (!present.has(COLLAB_ATTACHMENT)) {
|
||
const notesRes = await api.get(`/api/trips/${tripId}/collab/notes`)
|
||
const { notes = [] } = (await notesRes.json()) as { notes?: { id: number; title: string }[] }
|
||
const note = notes.find(n => n.title === COLLAB_NOTE)
|
||
if (!note) throw new Error(`fixture collab note "${COLLAB_NOTE}" is missing`)
|
||
const attached = await api.post(`/api/trips/${tripId}/collab/notes/${note.id}/files`, {
|
||
multipart: {
|
||
file: { name: COLLAB_ATTACHMENT, mimeType: 'image/png', buffer: readFileSync(await filesImageFixture('jr-pass-map')) },
|
||
},
|
||
})
|
||
if (!attached.ok()) throw new Error(`could not attach "${COLLAB_ATTACHMENT}": ${attached.status()} ${await attached.text()}`)
|
||
}
|
||
|
||
// One document in the trash from the start: without it the trash view is an
|
||
// empty state and Empty Trash, which one step is a picture of, is not drawn.
|
||
if (!present.has(TRASHED.name)) {
|
||
const id = await uploadTripFile(
|
||
api,
|
||
tripId,
|
||
{ name: TRASHED.name, mimeType: 'application/pdf', from: () => filesPdfFixture('hakone-ryokan-confirmation') },
|
||
{ description: TRASHED.description },
|
||
)
|
||
const deleted = await api.delete(`/api/trips/${tripId}/files/${id}`)
|
||
if (!deleted.ok()) throw new Error(`could not put "${TRASHED.name}" in the trash: ${deleted.status()} ${await deleted.text()}`)
|
||
}
|
||
}
|
||
|
||
// ── Trip: collab ──────────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Three links the trip runs on. The seed creates none, so without them the
|
||
* Links panel is an empty state in the hero and in every Links picture.
|
||
*/
|
||
export const COLLAB_LINKS = [
|
||
{ title: 'Japan Rail Pass activation', url: 'https://www.japanrailpass.net/en/' },
|
||
{ title: 'teamLab Planets tickets', url: 'https://www.teamlab.art/e/planets/' },
|
||
{ title: 'Shared photo album', url: 'https://photos.example/autumn-in-japan' },
|
||
]
|
||
|
||
/**
|
||
* A poll to spend. Closing one cannot be undone (there is no reopen route), so
|
||
* the guide about closing must not be pointed at either of the seeded polls.
|
||
* `ensureCollabFixtures` also has a member cast one vote on it: a closed poll
|
||
* nobody voted on has no winning option, and `isWinner` in `CollabPolls.tsx`
|
||
* needs a count above zero before it tints one green, which is what the guide's
|
||
* text says.
|
||
*/
|
||
export const COLLAB_SPARE_POLL = {
|
||
question: 'Rent a car for the Hakone leg?',
|
||
options: ['Yes, a small one', 'No, trains only'],
|
||
multiple: false,
|
||
}
|
||
|
||
/**
|
||
* The two stops What's Next reads. Both places are already on the trip, so this
|
||
* adds no row to the places column that the other trip screens photograph: it
|
||
* only puts them on the last day as well. One carries a time, one stays untimed
|
||
* and reads TBD, which is also the fallback when the run starts too late in the
|
||
* evening for a time on today to still be ahead.
|
||
*/
|
||
export const WHATS_NEXT_STOPS = { timed: 'Nishiki Market', untimed: 'Fushimi Inari Taisha' }
|
||
|
||
/** The seeded member who votes on the spare poll. */
|
||
const COLLAB_VOTER = { email: 'mira@example.com', password: 'DemoSeed12345!' }
|
||
|
||
/**
|
||
* A request context acting as COLLAB_VOTER, or undefined when the login fails.
|
||
* Its own context with a bearer token: a login on the shared one would set the
|
||
* session cookie there, and every later write would be the member's.
|
||
*/
|
||
async function collabMember(): Promise<APIRequestContext | undefined> {
|
||
const anon = await apiRequest.newContext({ baseURL: E2E_BASE_URL, storageState: undefined })
|
||
const login = await anon.post('/api/auth/login', { data: COLLAB_VOTER })
|
||
const token = login.ok() ? ((await login.json()) as { token?: string }).token : undefined
|
||
await anon.dispose()
|
||
if (!token) return undefined
|
||
return apiRequest.newContext({
|
||
baseURL: E2E_BASE_URL,
|
||
storageState: undefined,
|
||
extraHTTPHeaders: { Authorization: `Bearer ${token}` },
|
||
})
|
||
}
|
||
|
||
/**
|
||
* What the Collab guides need beyond the seed, which already holds the three
|
||
* notes, the two polls and the seven message conversation. Safe to run again:
|
||
* every collection is read first and only what is missing is written, except
|
||
* the spare poll, which is always made fresh because closing it is final.
|
||
*/
|
||
export async function ensureCollabFixtures(api: APIRequestContext): Promise<void> {
|
||
const { tripId, dayIds } = seededTrip()
|
||
const collab = `/api/trips/${tripId}/collab`
|
||
|
||
const linksRes = await api.get(`${collab}/links`)
|
||
const { links } = (await linksRes.json()) as { links: { title: string }[] }
|
||
for (const link of COLLAB_LINKS) {
|
||
if (links.some(l => l.title === link.title)) continue
|
||
const created = await api.post(`${collab}/links`, { data: link })
|
||
if (!created.ok()) throw new Error(`could not add the link "${link.title}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
|
||
// The spare poll is thrown away and made again rather than reused: closing is
|
||
// irreversible, so one left behind by a run that stopped short would already
|
||
// be closed and the guide could not close it. Fresh means open and unvoted.
|
||
const pollsRes = await api.get(`${collab}/polls`)
|
||
const { polls } = (await pollsRes.json()) as { polls: { id: number; question: string }[] }
|
||
for (const old of polls.filter(p => p.question === COLLAB_SPARE_POLL.question)) {
|
||
await api.delete(`${collab}/polls/${old.id}`)
|
||
}
|
||
const spareRes = await api.post(`${collab}/polls`, { data: COLLAB_SPARE_POLL })
|
||
if (!spareRes.ok()) throw new Error(`could not create the spare poll: ${spareRes.status()} ${await spareRes.text()}`)
|
||
const { poll: spare } = (await spareRes.json()) as { poll: { id: number } }
|
||
// One vote on it, so the poll the close-poll guide closes has a winner to tint.
|
||
// Cast by another member: a winner the viewer picked wears the accent tint of
|
||
// their own vote instead of the green the guide's text describes. A login that
|
||
// fails falls back to the admin's vote rather than to no winner at all.
|
||
const voter = await collabMember()
|
||
const voted = await (voter ?? api).post(`${collab}/polls/${spare.id}/vote`, { data: { option_index: 0 } })
|
||
await voter?.dispose()
|
||
if (!voted.ok()) throw new Error(`could not vote on the spare poll: ${voted.status()} ${await voted.text()}`)
|
||
|
||
// What's Next lists a stop on a later day, or one on today whose start has not
|
||
// passed yet. The trip's last day is the picture day by construction, so both
|
||
// stops go there and the time is computed from the pinned clock.
|
||
const lastDay = dayIds[dayIds.length - 1]
|
||
const placesRes = await api.get(`/api/trips/${tripId}/places`)
|
||
const placesBody = (await placesRes.json()) as { places?: { id: number; name: string }[] } | { id: number; name: string }[]
|
||
const places = Array.isArray(placesBody) ? placesBody : (placesBody.places ?? [])
|
||
const dayRes = await api.get(`/api/trips/${tripId}/days/${lastDay}/assignments`)
|
||
const { assignments } = (await dayRes.json()) as { assignments: { id: number; place_id: number }[] }
|
||
|
||
const putOnLastDay = async (name: string): Promise<number> => {
|
||
const place = places.find(p => p.name === name)
|
||
if (!place) throw new Error(`fixture place "${name}" is not on the seeded trip`)
|
||
const already = assignments.find(a => a.place_id === place.id)
|
||
if (already) return already.id
|
||
const created = await api.post(`/api/trips/${tripId}/days/${lastDay}/assignments`, { data: { place_id: place.id } })
|
||
if (!created.ok()) throw new Error(`could not put "${name}" on the last day: ${created.status()} ${await created.text()}`)
|
||
const { assignment } = (await created.json()) as { assignment: { id: number } }
|
||
return assignment.id
|
||
}
|
||
|
||
const timedId = await putOnLastDay(WHATS_NEXT_STOPS.timed)
|
||
await putOnLastDay(WHATS_NEXT_STOPS.untimed)
|
||
|
||
const pad = (n: number): string => String(n).padStart(2, '0')
|
||
const clock = (d: Date): string => `${pad(d.getHours())}:${pad(d.getMinutes())}`
|
||
// Timed against the day the pictures are taken on, not against the wall clock
|
||
// of whoever is running this. What's Next only lists a stop whose start is
|
||
// still ahead, and the browser's clock is pinned, so a time worked out from
|
||
// the real hour is in the panel's past as often as not.
|
||
const from = new Date(PICTURE_DAY.getTime() + 45 * 60_000)
|
||
const until = new Date(PICTURE_DAY.getTime() + 165 * 60_000)
|
||
const timed = await api.put(`/api/trips/${tripId}/assignments/${timedId}/time`, {
|
||
data: { place_time: clock(from), end_time: clock(until) },
|
||
})
|
||
if (!timed.ok()) throw new Error(`could not time the What's Next stop: ${timed.status()} ${await timed.text()}`)
|
||
}
|
||
|
||
// ── Trip: road trip ───────────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* The drive out of Tokyo. Every seeded day is a walk across one city, and a ten
|
||
* kilometre leg has no alternatives worth offering, never runs a tank dry and
|
||
* gives the corridor search almost nothing to find. Day 4 is empty in the seed,
|
||
* so it gets a real one: about 95 km of Tomei expressway, which is long enough
|
||
* for the router to have opinions about it and long enough to matter to a range.
|
||
*/
|
||
const ROADTRIP_DRIVE = [
|
||
{
|
||
name: 'Shinjuku Gyoen',
|
||
lat: 35.6852,
|
||
lng: 139.71,
|
||
address: '11 Naitomachi, Shinjuku City, Tokyo',
|
||
description: 'The garden the drive out of Tokyo starts from.',
|
||
},
|
||
{
|
||
name: 'Hakone Shrine',
|
||
lat: 35.2046,
|
||
lng: 139.0256,
|
||
address: '80-1 Motohakone, Hakone, Kanagawa',
|
||
description: 'Torii standing in the water at the edge of Lake Ashi.',
|
||
},
|
||
]
|
||
|
||
/**
|
||
* What the road trip guides act on beyond the seed.
|
||
*
|
||
* Four things the seed does not have: the addon itself, which is off by default
|
||
* and without which there is no mode switch, no rail and no /roadtrip route at
|
||
* all; the drive above; a track and a day to fit it to, for the guide that
|
||
* follows one; and the driving settings, so the card carries badges and the
|
||
* rail has a point where the tank runs out.
|
||
*
|
||
* Deliberately NOT set here: the daily travel times. They force Connect the
|
||
* days on, which routes the night between every pair of days and puts extra
|
||
* rows and extra days into every other guide's pictures. `roadtrip-day-window`
|
||
* sets them and clears them again itself.
|
||
*
|
||
* Everything is idempotent, and the guides call it again to undo what they
|
||
* changed, so the preferences are written in full rather than only when absent.
|
||
*/
|
||
export async function ensureRoadtripFixtures(api: APIRequestContext): Promise<void> {
|
||
const { tripId, dayIds } = seededTrip()
|
||
|
||
// Instance-wide and admin-only; the seeded user is the admin. Every
|
||
// /roadtrip route 404s without it, so this comes first.
|
||
const addon = await api.put('/api/admin/addons/roadtrip', { data: { enabled: true } })
|
||
if (!addon.ok()) throw new Error(`could not enable the Road trip addon: ${addon.status()} ${await addon.text()}`)
|
||
|
||
const placesOf = async (): Promise<{ id: number; name: string }[]> => {
|
||
const res = await api.get(`/api/trips/${tripId}/places`)
|
||
const body = (await res.json()) as { places?: { id: number; name: string }[] } | { id: number; name: string }[]
|
||
return Array.isArray(body) ? body : (body.places ?? [])
|
||
}
|
||
const pin = async (dayId: number, placeId: number): Promise<void> => {
|
||
const res = await api.get(`/api/trips/${tripId}/days/${dayId}/assignments`)
|
||
const body = (await res.json()) as { assignments?: { place_id: number }[] }
|
||
if ((body.assignments ?? []).some(a => a.place_id === placeId)) return
|
||
const created = await api.post(`/api/trips/${tripId}/days/${dayId}/assignments`, { data: { place_id: placeId } })
|
||
if (!created.ok()) {
|
||
throw new Error(`could not put place ${placeId} on day ${dayId}: ${created.status()} ${await created.text()}`)
|
||
}
|
||
}
|
||
|
||
for (const place of ROADTRIP_DRIVE) {
|
||
if ((await placesOf()).some(p => p.name === place.name)) continue
|
||
const created = await api.post(`/api/trips/${tripId}/places`, { data: place })
|
||
if (!created.ok()) throw new Error(`could not create "${place.name}": ${created.status()} ${await created.text()}`)
|
||
}
|
||
const places = await placesOf()
|
||
// In this order: the drive runs out of the city, not into it.
|
||
for (const place of ROADTRIP_DRIVE) {
|
||
const found = places.find(p => p.name === place.name)
|
||
if (!found) throw new Error(`fixture place "${place.name}" is missing`)
|
||
await pin(dayIds[3], found.id)
|
||
}
|
||
|
||
// The loop, and the two stops the day is for, so the track reads as one along
|
||
// this day rather than as one a long way off it.
|
||
await ensureTrack(api, tripId, 'arashiyama-loop')
|
||
const withTrack = await placesOf()
|
||
for (const name of ['Togetsukyo Bridge', 'Okochi Sanso Villa']) {
|
||
const found = withTrack.find(p => p.name === name)
|
||
if (!found) throw new Error(`the imported track's waypoint "${name}" is missing`)
|
||
await pin(dayIds[6], found.id)
|
||
}
|
||
|
||
const prefs = await api.put(`/api/trips/${tripId}/roadtrip/preferences`, {
|
||
data: {
|
||
roadtrip_vehicle: 'combustion',
|
||
roadtrip_range_km: 70,
|
||
roadtrip_fill_percent: 80,
|
||
roadtrip_leg_minutes: 90,
|
||
roadtrip_day_minutes: 240,
|
||
roadtrip_day_start: '',
|
||
roadtrip_day_end: '',
|
||
roadtrip_day_end_mode: 'route',
|
||
},
|
||
})
|
||
if (!prefs.ok()) throw new Error(`could not write the driving settings: ${prefs.status()} ${await prefs.text()}`)
|
||
}
|