mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 02:56:10 +00:00
bac4599d64
A nullable day_assignments.stay_minutes holds the stay of one visit; a visit without one keeps reading the place's duration, so existing trips drive as before. REST PUT /trips/:tripId/assignments/:id/stay and the MCP tool set_assignment_stay write it with day_edit.
238 lines
9.1 KiB
TypeScript
238 lines
9.1 KiB
TypeScript
import type { AssistantChangeEffect } from '@trek/shared';
|
|
|
|
import { dayPoints, type LatLng } from '../../store/assistantMapModel';
|
|
import type { Assignment, AssignmentsMap, Place } from '../../types';
|
|
import { haversineKm } from '../../utils/geo';
|
|
import { stayOf } from '../Roadtrip/stayReading';
|
|
|
|
/**
|
|
* A day as it would read once the waiting changes of a card ran: the stops it
|
|
* keeps, the ones that join it and the ones that leave it, each with the way
|
|
* from the stop before. Pure and React-free, so the change card draws it and a
|
|
* test can pin it.
|
|
*
|
|
* Only what the assistant can do shows up here. It cannot set a time or a
|
|
* position, so a stop that joins the day lands at its end, the way the server
|
|
* appends it. The way between two stops is a straight line bent by a detour
|
|
* factor and read at the leg's speed: a quick estimate, which the card marks
|
|
* with "≈", and no router request per suggestion.
|
|
*/
|
|
|
|
/** One waiting change, as much of it as the day plan needs. */
|
|
export interface DayChange {
|
|
toolCallId: string;
|
|
effect: AssistantChangeEffect;
|
|
/** What the card calls it, for a stop the trip does not hold yet. */
|
|
subject: string | null;
|
|
}
|
|
|
|
type StopStatus = 'kept' | 'new' | 'removed';
|
|
|
|
/** How a stop follows the one before it on the day. */
|
|
interface StopLead {
|
|
/** Estimated minutes on the way there; null without both positions. */
|
|
travelMinutes: number | null;
|
|
/** Minutes left free between the two, the way there taken off; null when the times do not say. */
|
|
freeMinutes: number | null;
|
|
/** The stop before, when the two take the same time. */
|
|
overlapsWith: string | null;
|
|
/** Minutes the way there is longer than the time between the two; null when it fits or the times do not say. */
|
|
shortBy: number | null;
|
|
}
|
|
|
|
export interface TimelineStop {
|
|
key: string;
|
|
name: string;
|
|
status: StopStatus;
|
|
/** The change that adds or removes it; null for a stop the card leaves alone. */
|
|
toolCallId: string | null;
|
|
/** The planned start as written, "09:30"; null when none is set. */
|
|
time: string | null;
|
|
/** Null for the first stop of the day and for one that leaves it. */
|
|
lead: StopLead | null;
|
|
}
|
|
|
|
export interface DayAfter {
|
|
dayId: number;
|
|
stops: TimelineStop[];
|
|
}
|
|
|
|
/** Free time below this is not worth a line. */
|
|
const GAP_MIN_MINUTES = 30;
|
|
/** Roads and paths are longer than the straight line. */
|
|
const DETOUR_FACTOR = 1.3;
|
|
|
|
/** km/h on a leg, by its travel mode. */
|
|
function speedOf(mode: string): number {
|
|
if (mode === 'walking') return 4.5;
|
|
if (mode === 'cycling' || mode === 'bicycle' || mode === 'bike') return 15;
|
|
return 50;
|
|
}
|
|
|
|
/** Minutes since midnight of an "HH:MM" value; null for anything else. */
|
|
export function minutesOf(value: string | null | undefined): number | null {
|
|
const match = value ? /^(\d{1,2}):(\d{2})/.exec(value) : null;
|
|
if (!match) return null;
|
|
const hours = Number(match[1]);
|
|
const minutes = Number(match[2]);
|
|
return hours < 24 && minutes < 60 ? hours * 60 + minutes : null;
|
|
}
|
|
|
|
interface Draft {
|
|
stop: Omit<TimelineStop, 'lead'>;
|
|
lat: number | null;
|
|
lng: number | null;
|
|
start: number | null;
|
|
end: number | null;
|
|
legMode: string | null;
|
|
}
|
|
|
|
function draftOf(visit: Assignment, status: StopStatus, toolCallId: string | null, key: string): Draft {
|
|
const place = visit.place;
|
|
const time = visit.assignment_time ?? place?.place_time ?? null;
|
|
const start = minutesOf(time);
|
|
const explicitEnd = minutesOf(visit.assignment_end_time ?? place?.end_time ?? null);
|
|
const duration = stayOf(visit);
|
|
const end = explicitEnd ?? (start !== null && typeof duration === 'number' && duration > 0 ? start + duration : null);
|
|
return {
|
|
stop: { key, name: place?.name ?? '', status, toolCallId, time: start === null ? null : time },
|
|
lat: typeof place?.lat === 'number' ? place.lat : null,
|
|
lng: typeof place?.lng === 'number' ? place.lng : null,
|
|
start,
|
|
end,
|
|
legMode: visit.leg_transport_mode ?? null,
|
|
};
|
|
}
|
|
|
|
function findVisit(assignments: AssignmentsMap, dayId: number | null, assignmentId: number | null) {
|
|
if (dayId === null || assignmentId === null) return undefined;
|
|
return (assignments[dayId] ?? []).find((v) => v.id === assignmentId);
|
|
}
|
|
|
|
/** A stop the change brings onto the day; null when there is nothing to name it by. */
|
|
function joiningDraft(
|
|
change: DayChange,
|
|
assignments: AssignmentsMap,
|
|
places: ReadonlyMap<number, Place>
|
|
): Draft | null {
|
|
const { effect, toolCallId } = change;
|
|
const key = `new:${toolCallId}`;
|
|
const moved = effect.kind === 'move' ? findVisit(assignments, effect.fromDayId, effect.assignmentId) : undefined;
|
|
if (moved) return draftOf(moved, 'new', toolCallId, key);
|
|
const place = effect.placeId === null ? undefined : places.get(effect.placeId);
|
|
const name = effect.place?.name ?? place?.name ?? change.subject;
|
|
if (!name) return null;
|
|
const lat = effect.place?.lat ?? place?.lat ?? null;
|
|
const lng = effect.place?.lng ?? place?.lng ?? null;
|
|
return {
|
|
stop: { key, name, status: 'new', toolCallId, time: null },
|
|
lat,
|
|
lng,
|
|
start: null,
|
|
end: null,
|
|
legMode: null,
|
|
};
|
|
}
|
|
|
|
/** The visits of the day that a change takes off it, by assignment, with the change that does. */
|
|
function leavingVisits(dayId: number, changes: readonly DayChange[]): Map<number, string> {
|
|
const leaving = new Map<number, string>();
|
|
for (const { effect, toolCallId } of changes) {
|
|
if (effect.assignmentId === null) continue;
|
|
const removes = effect.kind === 'remove' && effect.dayId === dayId;
|
|
const movesAway = effect.kind === 'move' && effect.fromDayId === dayId && effect.dayId !== dayId;
|
|
if (removes || movesAway) leaving.set(effect.assignmentId, toolCallId);
|
|
}
|
|
return leaving;
|
|
}
|
|
|
|
function leadOf(prev: Draft, cur: Draft, defaultMode: string): StopLead {
|
|
const travelMinutes =
|
|
prev.lat !== null && prev.lng !== null && cur.lat !== null && cur.lng !== null
|
|
? Math.round(
|
|
((haversineKm({ lat: prev.lat, lng: prev.lng }, { lat: cur.lat, lng: cur.lng }) * DETOUR_FACTOR) /
|
|
speedOf(prev.legMode ?? defaultMode)) *
|
|
60
|
|
)
|
|
: null;
|
|
const none = { freeMinutes: null, overlapsWith: null, shortBy: null };
|
|
if (cur.start === null || prev.end === null) return { travelMinutes, ...none };
|
|
if (cur.start < prev.end) return { travelMinutes, ...none, overlapsWith: prev.stop.name };
|
|
const free = cur.start - prev.end - (travelMinutes ?? 0);
|
|
if (free < 0) return { travelMinutes, ...none, shortBy: -free };
|
|
return { travelMinutes, ...none, freeMinutes: free >= GAP_MIN_MINUTES ? free : null };
|
|
}
|
|
|
|
/**
|
|
* The day after the changes: its own stops in their order (hotel stops left
|
|
* out, as the day plan hides them), the ones a change takes away marked, the
|
|
* ones that join it at the end.
|
|
*/
|
|
export function buildDayAfter(input: {
|
|
dayId: number;
|
|
assignments: AssignmentsMap;
|
|
places: readonly Place[];
|
|
changes: readonly DayChange[];
|
|
defaultMode: string | null | undefined;
|
|
}): DayAfter {
|
|
const { dayId, assignments, changes } = input;
|
|
const places = new Map(input.places.map((p) => [p.id, p]));
|
|
const leaving = leavingVisits(dayId, changes);
|
|
const own = [...(assignments[dayId] ?? [])]
|
|
.filter((v) => !v.accommodation_id)
|
|
.sort((a, b) => a.order_index - b.order_index);
|
|
const drafts = own.map((v) => {
|
|
const by = leaving.get(v.id) ?? null;
|
|
return draftOf(v, by ? 'removed' : 'kept', by, `a:${v.id}`);
|
|
});
|
|
for (const change of changes) {
|
|
const { effect } = change;
|
|
if (effect.dayId !== dayId || effect.kind === 'remove' || effect.fromDayId === dayId) continue;
|
|
const draft = joiningDraft(change, assignments, places);
|
|
if (draft) drafts.push(draft);
|
|
}
|
|
const defaultMode = input.defaultMode ?? 'walking';
|
|
let prev: Draft | null = null;
|
|
const stops = drafts.map((d) => {
|
|
if (d.stop.status === 'removed') return { ...d.stop, lead: null };
|
|
const lead = prev ? leadOf(prev, d, defaultMode) : null;
|
|
prev = d;
|
|
return { ...d.stop, lead };
|
|
});
|
|
return { dayId, stops };
|
|
}
|
|
|
|
/**
|
|
* Where the map should look to show a card's changes: each change's own place
|
|
* (a new one by its coordinates, a planned one by the trip's) and the stops of
|
|
* the days they touch, so the suggestion shows beside the rest of its day.
|
|
*/
|
|
export function changePoints(
|
|
changes: readonly DayChange[],
|
|
assignments: AssignmentsMap,
|
|
places: readonly Place[]
|
|
): LatLng[] {
|
|
const byId = new Map(places.map((p) => [p.id, p]));
|
|
const points: LatLng[] = [];
|
|
for (const { effect } of changes) {
|
|
const place = effect.placeId === null ? undefined : byId.get(effect.placeId);
|
|
const lat = effect.place?.lat ?? place?.lat;
|
|
const lng = effect.place?.lng ?? place?.lng;
|
|
if (typeof lat === 'number' && typeof lng === 'number') points.push([lat, lng]);
|
|
}
|
|
return [...points, ...dayPoints(assignments, changedDays(changes))];
|
|
}
|
|
|
|
/** The days a card's changes touch, in the order they come: where each lands, then where a move leaves. */
|
|
export function changedDays(changes: readonly DayChange[]): number[] {
|
|
const days: number[] = [];
|
|
const add = (id: number | null) => {
|
|
if (id !== null && !days.includes(id)) days.push(id);
|
|
};
|
|
for (const { effect } of changes) {
|
|
add(effect.dayId);
|
|
add(effect.fromDayId);
|
|
}
|
|
return days;
|
|
}
|