Hornwitser
985b8e0950
Rename the base Entity type to ApiEntity, and the base EntityToombstone to ApiTombstone to better reflect the reality that its only used in the API interface and that the client and server types uses its own base if any. Remove EntityLiving and pull EntityTombstone out of of the base entity type so that the types based on ApiEntity are always living entities and if it's possible for it to contain tombstone this will be explicitly told with the type including a union with ApiTombstone. Refactor the types of the ClientEntity and ClientMap to better reflect the types of the entities it stores and converts to/from.
96 lines
2.6 KiB
TypeScript
96 lines
2.6 KiB
TypeScript
import { readSchedule, type ServerUser, writeSchedule } from '~/server/database';
|
|
import { broadcastEvent } from '~/server/streams';
|
|
import type { ApiSchedule, ApiTombstone } from '~/shared/types/api';
|
|
|
|
export async function updateScheduleInterestedCounts(users: ServerUser[]) {
|
|
const eventCounts = new Map<number, number>();
|
|
const eventSlotCounts = new Map<number, number>();
|
|
for (const user of users) {
|
|
if (user.deleted)
|
|
continue;
|
|
if (user.interestedEventIds)
|
|
for (const id of user.interestedEventIds)
|
|
eventCounts.set(id, (eventCounts.get(id) ?? 0) + 1);
|
|
if (user.interestedEventSlotIds)
|
|
for (const id of user.interestedEventSlotIds)
|
|
eventSlotCounts.set(id, (eventSlotCounts.get(id) ?? 0) + 1);
|
|
}
|
|
|
|
const schedule = await readSchedule();
|
|
if (schedule.deleted) {
|
|
throw new Error("Deleted schedule not implemented");
|
|
}
|
|
const update: ApiSchedule = {
|
|
id: schedule.id,
|
|
updatedAt: new Date().toISOString(),
|
|
events: [],
|
|
};
|
|
const updatedFrom = schedule.updatedAt;
|
|
for (const event of schedule.events ?? []) {
|
|
let modified = false;
|
|
if (event.deleted)
|
|
continue;
|
|
|
|
let count = eventCounts.get(event.id);
|
|
if (count !== event.interested) {
|
|
event.interested = eventCounts.get(event.id);
|
|
modified = true;
|
|
}
|
|
for (const slot of event.slots) {
|
|
let slotCount = eventSlotCounts.get(slot.id);
|
|
if (slotCount !== slot.interested) {
|
|
slot.interested = slotCount;
|
|
modified = true;
|
|
}
|
|
}
|
|
if (modified) {
|
|
event.updatedAt = update.updatedAt;
|
|
update.events!.push(event);
|
|
}
|
|
}
|
|
if (!update.events!.length) {
|
|
return; // No changes
|
|
}
|
|
schedule.updatedAt = updatedFrom;
|
|
await writeSchedule(schedule);
|
|
await broadcastEvent({
|
|
type: "schedule-update",
|
|
updatedFrom,
|
|
data: update,
|
|
});
|
|
}
|
|
|
|
export function canSeeAnonymous(userType: string | undefined) {
|
|
return userType === "admin";
|
|
}
|
|
|
|
export function canSeeCrew(userType: string | undefined) {
|
|
return userType === "crew" || userType === "admin";
|
|
}
|
|
|
|
/** Filters out crew visible only parts of schedule */
|
|
export function filterSchedule(schedule: ApiSchedule | ApiTombstone): ApiSchedule | ApiTombstone {
|
|
if (schedule.deleted) {
|
|
return schedule;
|
|
}
|
|
return {
|
|
id: schedule.id,
|
|
updatedAt: schedule.updatedAt,
|
|
locations: schedule.locations,
|
|
events: (schedule.events ?? [])
|
|
.map(event => (
|
|
event.deleted
|
|
? event
|
|
: event.crew
|
|
// Pretend crew events are deleted.
|
|
? { id: event.id, deleted: true, updatedAt: event.updatedAt }
|
|
: {
|
|
...event,
|
|
slots: event.slots.map(slot => ({
|
|
...slot,
|
|
assigned: undefined,
|
|
}
|
|
)),
|
|
})),
|
|
}
|
|
}
|