Krockskydd för mallar, inställningar och markeringar, flera val i kopplingsfält, Word-import av scheman och kartregister, fler namn för äldre år

Mallar, bokinställningar och kartmarkeringar skickar med version och visar
en krockruta. Kopplingsfält kan ha flera val. Scheman och kartregister kan
importeras från Word, och nya ID hoppar över upptagna. Äldre födelseår får
fler namn genom två SCB-tabeller och grannår. Migrering 0008.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
bobbanandClaude Sonnet 5.5 committed 2026-11-08 23:23:31 +01:00
1 parent 86fd435438
commit 1fd1ce78cb
37 files changed
+2258 -133

No files matched your search

+8 -4
View File
@@ -115,6 +115,8 @@ Fälttypen **Koppling till post** pekar direkt på en annan post, till exempel *
Standardmallarna använder det för Lokal och Skiss i Företag, Lokal, Bostad och Utbildning, Företag i Utbildning, Ägare och Referens i Fordon och Kopplat till i Scenario. I JSON ser ett sådant fält ut så här: `{ "key": "premises", "label": "Lokal", "type": "reference", "refKind": "PREMISES" }` (utan `refKind` kan alla typer väljas).
**Flera val.** Ett kopplingsfält kan tillåta flera poster, till exempel flera lokaler för ett företag. Slå på *Flera val* på fältet i mallredigeraren (eller `"multiple": true` i JSON). I formuläret blir fältet en lista där man markerar flera, och värdet sparas som en lista. Standardmallarna har flera val för Lokal och Skiss i Företag, Utbildning, Bostad och Lokal. Fält som redan hade ett värde behåller det, och på postens sida listas alla valda poster, som alla får se var de används. Slås flera val av igen behålls det första värdet.
Ändrar du en mall försvinner ingen data: värden för borttagna fält finns kvar i databasen.
## Släktträd och tidslinje
@@ -152,13 +154,13 @@ Behörigheten kontrolleras på servern vid varje ändring, så en dold knapp är
## Samtidiga ändringar
Två personer kan redigera samma post eller relation samtidigt. Formuläret skickar med versionen det öppnades med, och har någon annan sparat sedan dess sparas ingenting. I stället visas en ruta ovanför formuläret med vem som sparade, när, och hur ditt formulär skiljer sig från den sparade versionen. Det du skrivit finns kvar. Du väljer *Spara mina ändringar ändå* (den andras version hamnar i historiken, för poster) eller *Ladda om sidan*. Kontrollen gäller poster, relationer och händelser och görs i databasen i samma steg som sparningen, så två sparningar i exakt samma ögonblick kan inte skriva över varandra.
Två personer kan redigera samma sak samtidigt. Formuläret skickar med versionen det öppnades med, och har någon annan sparat sedan dess sparas ingenting. I stället visas en ruta ovanför formuläret med vem som sparade, när, och hur ditt formulär skiljer sig från den sparade versionen. Det du skrivit finns kvar. Du väljer *Spara mina ändringar ändå* (den andras version hamnar i historiken, för poster) eller *Ladda om sidan*. Kontrollen gäller poster, relationer, händelser, **mallar** (med en jämförelse fält för fält), **bokinställningar** och **kartmarkeringar** (när du sparar eller drar en markering visas samma ruta, och en markering som ändrats av någon annan flyttas inte). Den görs i databasen i samma steg som sparningen, så två sparningar i exakt samma ögonblick kan inte skriva över varandra. En mall som återställts till standard av någon annan räknas också som en krock.
## Importera från Word
Under *Planering → Importera från Word* laddar du upp ifyllda Word-mallar (.docx) från `Mall/` och `Register/`, flera i taget. Appen läser dokumenten, visar vad den hittade och sparar först när du bekräftar.
- **Dokumenttyp** känns igen på dokumentets eget ID-fält (*Karaktärs ID*, *Bostads ID* och så vidare) eller på etiketterna, och kan bytas i rullistan. Karaktär, husdjur, bostad, företag, lokal, utbildning, scenario, relation, fordon, referens, research, app och hemsida stöds. Scheman och kartregistret importeras inte, de har egna sidor.
- **Dokumenttyp** känns igen på dokumentets eget ID-fält (*Karaktärs ID*, *Bostads ID* och så vidare) eller på etiketterna, och kan bytas i rullistan. Karaktär, husdjur, bostad, företag, lokal, utbildning, scenario, relation, fordon, referens, research, app och hemsida stöds. **Scheman** (Schema dag och natt) blir pass: timmar med innehåll i en kolumn blir pass, och följande timmar med samma innehåll slås ihop (08:00–16:00), även över midnatt i nattschemat. Innehållet blir passets beteckning, och ett ensamt X ger inget. Person och arbetsplats kommer från **schemaregistret** i samma uppladdning (Schema-ID ger person och arbetsplats), eller från ett schema med samma Schema-ID som redan finns i boken, annars väljer du dem i förhandsgranskningen. Pass som redan finns läggs inte till igen, och du kan välja att ersätta personens befintliga pass hos arbetsplatsen. **Kartregistret** skapar kartor (riktiga kartor, inte bildkartor) med en markering per placering. Markeringarna saknar position och läggs i kartans mitt, så du drar dem på plats i kartan. ID i dokumentet behålls om de är lediga.
- **Fyll i** genom att skriva värdet efter etiketten i samma cell, i cellen bredvid eller på raden under, och markera val med ett X (till exempel `Ja: X Nej:`). Val utan markering räknas som tomma. Mallens hjälptexter i parentes och frågor räknas aldrig som värden. Etiketter får vara skrivna lite annorlunda än i appens mall.
- **Namn och ID.** Namn sätts ihop av *Förnamn* och *Efternamn*, eller tas från *Namn*, *Företagets namn* och liknande. Poster utan namnfält (bostad, lokal, scenario) får adress, typ och ID som namn. Du kan ändra namnet i förhandsgranskningen. Ett ID i dokumentet behålls om det är ledigt, annars får posten ett nytt, och räknarna fortsätter efter det.
- **Kopplingar.** Deltagarlistor blir relationer: *Boende* blir ”Bor på”, *Anställda* ”Jobbar på” (med rollen som anteckning), lärare och elever ”Lärare på” och ”Elev på”, *Involverade* och *Berörda karaktärer* ”Involverad i” och ”Berörd av”, och *Anställd hos* och *Ägare* (husdjur) kopplas åt rätt håll. Personer och företag hittas i boken på ID eller exakt namn. De som inte hittas visas och hoppas över. Kopplingsfält (till exempel *Lokal ID* i en företagsmall) fylls i på samma sätt. En relationsmall blir en relation mellan de som hittades (minst två), och *Partner* ger släktbandet partner.
@@ -232,13 +234,15 @@ Namnen viktas efter hur vanliga de var, så en man född 1960 blir oftare Anders
| Födelseår | Källa |
|---|---|
| 1922–1997 | SCB, tilltalsnamn bland folkbokförda (de 200 vanligaste namnen) |
| 1922–1997 | SCB, tilltalsnamn och förnamn bland folkbokförda (de 100 vanligaste per kön), med grannår |
| 1998–2020 | SCB, nyfödda efter tilltalsnamn och namngivningsår |
| 2021 och senare | Skatteverket, öppna data *Namn på nyfödda* |
| Efternamn | SCB, efternamn med minst 10 bärare (2020), de 100, 1 000 eller 5 000 vanligaste |
Året flyttas till närmaste år med statistik (tidigast 1922). Servern behöver nå `api.scb.se` och `skatteverket.entryscape.net`. Går det inte används den inbyggda namnlistan i `src/lib/names.ts` (cirka 150 förnamn per kön och 160 efternamn) och sidan visar en varning. Du kan också stänga av statistiken med reglaget *Använd namnstatistik*.
**Äldre år.** SCB publicerar bara de 100 vanligaste namnen per kön, inte en full lista per födelseår, så äldre år har färre namn än nyare. För att få fler kombineras två tabeller (*Tilltalsnamn* och *Förnamn*, som ger ett trettiotal tidstypiska namn till som Gösta, Rune, Märta och Ingvar), och namn som saknar bärare just det året får en liten andel av grannåren (±2 år). Listor som sparats på det gamla sättet hämtas om automatiskt, och en äldre lista används om SCB inte svarar.
## Kartor
- **Riktig karta**: sök adress, klicka där markeringen ska sitta, koppla den till en bostad, lokal eller plats. Dra för att flytta. *Spara vy* minns utsnittet.
@@ -248,7 +252,7 @@ Namnen viktas efter hur vanliga de var, så en man född 1960 blir oftare Anders
## Tester
Testerna körs med Vitest (`npm test`). Det finns cirka 430 tester:
Testerna körs med Vitest (`npm test`). Det finns cirka 520 tester:
- **Enhetstester utan databas** (`tests/unit`): roller och behörighet, tolkning av Word-dokument (etiketter, val i rutor, listor, register och ifyllda versioner av de riktiga mallarna i `Mall/` och `Register/`), datum och åldersberäkning, släktträdets layout, tidslinjens sammanställning, mallar och deras validering, ID-prefix, hastighetsbegränsning, säkerhetsrubriker, namngenerering, historikens jämförelser, bildbehandling (storlek, EXIF-rotation, borttagen metadata) och läsning och kontroll av importfiler (inklusive skydd mot för stora filer).
- **Databastester** (`tests/db`): löpande ID (även vid samtidiga anrop), export och import fram och tillbaka med bilder och kopplingar, delning och behörigheter för varje roll, skydd mot kolliderande ändringar (även med flera samtidiga sparningar), import från Word, släktband, perioder och händelser (även i papperskorgen), papperskorg (poster och böcker), historikens gräns, fältvärden och kopplingskontroller, säkerhetskopiering (rensning, schema, att zip-filerna går att importera), lagringskvot, administratör och sök.
+4 -4
View File
@@ -112,6 +112,9 @@ Samma `act_runner` som för publiceringen räcker. Tjänstecontainern nås som `
- Importen från Word är provad mot de blanka mallarna i `Mall/` och `Register/` och mot versioner jag fyllt i på de sätt som beskrivs i README. Prova med några av dina egna ifyllda dokument och berätta vad som tolkas fel, särskilt hur du markerar val (X, symbol eller ruta) och var du skriver värden.
- Delning: logga in som en andra användare med riktiga Authentik-konton och prova rollerna (läsare, redaktör, administratör) i en delad bok.
- Word-import av scheman och kartregister är provad mot de blanka mallarna och mot versioner jag fyllt i. Prova med egna dokument, särskilt hur du fyller i rutnätet i Schema dag och natt (text, kryss eller något annat) och vilka rader du använder i schemaregistret och kartregistret.
- Namn för äldre år hämtas om från SCB första gången ett år används efter uppdateringen (två tabeller). Kontrollera i riktig miljö att *Förnamn*-tabellen svarar och att namnlistan blir längre.
- Migreringen 0008 lägger till kolumner för krockskydd på böcker, mallar och markeringar.
- Ladda upp en stor kartbild (10–15 MB). Gränsen för förfrågningar via inloggningskontrollen höjdes till 300 MB i samband med import och export, men en stor kartbild är inte testad.
- Kör Docker-filerna på riktigt (`docker compose ... config` och en full start). Dev- och prod-compose har inte körts i miljön där koden skrevs.
@@ -126,9 +129,6 @@ Samma `act_runner` som för publiceringen räcker. Tjänstecontainern nås som `
## Idéer
- Delning med en inbjudningslänk (roll och giltighetstid) för den som inte har loggat in än. Idag delas bara med e-postadressen till en befintlig användare.
- Skydd mot kolliderande ändringar även i mallredigeraren, bokinställningarna och kartmarkeringar. Idag gäller det poster, relationer och händelser.
- Import från Word av scheman (Schema dag och natt) och kartregistret. De importeras inte idag.
- Kartregistret skapar markeringar i kartans mitt. Erbjud att slå upp en adress eller plats så att de hamnar rätt direkt.
- Visa vem som har en post öppen just nu (ett diskret märke), så att krockar undviks i förväg.
- Flera val i kopplingsfält (till exempel flera lokaler för ett företag). Idag är det en koppling per fält.
- Äldre år i namngeneratorn har färre namn, eftersom SCB bara publicerar de 200 vanligaste namnen totalt för födda före 1998.
@@ -0,0 +1,9 @@
-- AlterTable
ALTER TABLE "Book" ADD COLUMN "updatedById" TEXT;
-- AlterTable
ALTER TABLE "Marker" ADD COLUMN "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
ADD COLUMN "updatedById" TEXT;
-- AlterTable
ALTER TABLE "Template" ADD COLUMN "updatedById" TEXT;
+4
View File
@@ -72,6 +72,7 @@ model Book {
description String? @db.Text
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
updatedById String?
owner User @relation(fields: [ownerId], references: [id], onDelete: Cascade)
entities Entity[]
@@ -204,6 +205,8 @@ model Marker {
lat Float
lng Float
createdAt DateTime @default(now())
updatedAt DateTime @default(now()) @updatedAt
updatedById String?
map BookMap @relation(fields: [mapId], references: [id], onDelete: Cascade)
entity Entity? @relation(fields: [entityId], references: [id], onDelete: SetNull)
@@ -220,6 +223,7 @@ model Template {
kind String
fields Json
updatedAt DateTime @updatedAt
updatedById String?
book Book @relation(fields: [bookId], references: [id], onDelete: Cascade)
+27 -2
View File
@@ -1,11 +1,14 @@
"use server";
import { Prisma } from "@prisma/client";
import { redirect } from "next/navigation";
import { revalidatePath } from "next/cache";
import { conflictInfo, isStale, type SaveResult } from "@/lib/conflict";
import { prisma } from "@/lib/db";
import { trashBook } from "@/lib/trash";
import { optStr, revalidateBook, str } from "@/lib/form";
import { requireBook, requireUser } from "@/lib/session";
import { getT } from "@/i18n/server";
export async function createBook(formData: FormData) {
const user = await requireUser();
@@ -24,19 +27,41 @@ export async function createBook(formData: FormData) {
redirect(`/books/${book.id}`);
}
export async function updateBook(formData: FormData) {
export async function updateBook(formData: FormData): Promise<SaveResult> {
const book = await requireBook(str(formData, "bookId"), "ADMIN");
const title = str(formData, "title", 200);
if (!title) return;
// Har någon annan ändrat bokens uppgifter sedan sidan öppnades?
const { t } = await getT();
const labels = { title: t("common.title"), subtitle: t("books.subtitle"), genre: t("books.genre"), description: t("common.description") };
const changes = (current: { title: string; subtitle: string | null; genre: string | null; description: string | null }) => {
const mine = { title, subtitle: optStr(formData, "subtitle", 200), genre: optStr(formData, "genre", 100), description: optStr(formData, "description") };
return (["title", "subtitle", "genre", "description"] as const)
.filter((key) => (current[key] ?? "") !== (mine[key] ?? ""))
.map((key) => ({ label: labels[key], before: current[key] ?? "", after: mine[key] ?? "" }));
};
if (isStale(str(formData, "version", 30), book.updatedAt)) return { conflict: await conflictInfo(book, changes(book)) };
try {
await prisma.book.update({
where: { id: book.id },
// Villkoret på updatedAt gör att en samtidig sparning av någon annan inte skrivs över
where: { id: book.id, updatedAt: book.updatedAt },
data: {
title,
subtitle: optStr(formData, "subtitle", 200),
genre: optStr(formData, "genre", 100),
description: optStr(formData, "description"),
updatedById: book.userId,
},
});
} catch (error) {
if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2025") {
const current = await prisma.book.findUnique({ where: { id: book.id } });
if (current) return { conflict: await conflictInfo(current, changes(current)) };
}
throw error;
}
revalidateBook(book.id);
revalidatePath("/");
}
+49 -10
View File
@@ -1,12 +1,14 @@
"use server";
import { redirect } from "next/navigation";
import { conflictInfo, isStale, versionOf, type ConflictChange, type ConflictInfo } from "@/lib/conflict";
import { prisma } from "@/lib/db";
import { deleteImage, isUpload, saveImage } from "@/lib/files";
import { revalidateBook, str } from "@/lib/form";
import { MARKER_COLORS } from "@/lib/kinds";
import { nextMapCode, nextMarkerCode } from "@/lib/ids";
import { requireBook } from "@/lib/session";
import { getT } from "@/i18n/server";
import { withinQuota } from "@/lib/storage";
async function requireMap(bookId: string, mapId: string) {
@@ -94,24 +96,61 @@ async function cleanMarker(bookId: string, input: MarkerInput) {
export async function createMarker(bookId: string, mapId: string, input: MarkerInput) {
const { book, map } = await requireMap(bookId, mapId);
const data = await cleanMarker(book.id, input);
await prisma.marker.create({ data: { ...data, code: await nextMarkerCode(book.id), mapId: map.id } });
await prisma.marker.create({ data: { ...data, code: await nextMarkerCode(book.id), mapId: map.id, updatedById: book.userId } });
revalidateBook(book.id);
}
export async function updateMarker(bookId: string, mapId: string, markerId: string, input: MarkerInput) {
const { book, map } = await requireMap(bookId, mapId);
await prisma.marker.updateMany({
where: { id: markerId, mapId: map.id },
data: await cleanMarker(book.id, input),
/** Svar från en ändring av en markering: ny version, en krock med någons annans ändring, eller att markeringen är borta. */
export type MarkerResult = { version: string } | { conflict: ConflictInfo } | { gone: true };
type MarkerChange = { label?: string; note?: string | null; color?: string; entityId?: string | null; lat?: number; lng?: number };
/**
* Skriver en ändring om markeringen inte har ändrats sedan användaren läste den (version). Villkoret på updatedAt
* gör att en samtidig ändring av någon annan inte skrivs över.
*/
async function changeMarker(book: { id: string; userId: string }, mapId: string, markerId: string, change: MarkerChange, version: string): Promise<MarkerResult> {
const current = await prisma.marker.findFirst({ where: { id: markerId, mapId } });
if (!current) return { gone: true };
const conflict = async (marker: typeof current): Promise<MarkerResult> => {
const { t } = await getT();
const changes: ConflictChange[] = [];
const diff = (label: string, before: unknown, after: unknown) => {
if (after !== undefined && String(before ?? "") !== String(after ?? "")) changes.push({ label, before: String(before ?? ""), after: String(after ?? "") });
};
diff(t("map.markerLabel"), marker.label, change.label);
diff(t("common.note"), marker.note, change.note);
diff(t("map.color"), marker.color, change.color);
if (change.lat !== undefined && (change.lat !== marker.lat || change.lng !== marker.lng)) {
changes.push({ label: t("map.position"), before: `${marker.lat.toFixed(5)}, ${marker.lng.toFixed(5)}`, after: `${change.lat.toFixed(5)}, ${(change.lng ?? 0).toFixed(5)}` });
}
return { conflict: await conflictInfo(marker, changes) };
};
if (isStale(version, current.updatedAt)) return conflict(current);
const { count } = await prisma.marker.updateMany({
where: { id: markerId, mapId, updatedAt: current.updatedAt },
data: { ...change, updatedAt: new Date(), updatedById: book.userId },
});
if (count === 0) {
const now = await prisma.marker.findFirst({ where: { id: markerId, mapId } });
return now ? conflict(now) : { gone: true };
}
revalidateBook(book.id);
const saved = await prisma.marker.findFirstOrThrow({ where: { id: markerId, mapId } });
return { version: versionOf(saved.updatedAt) };
}
export async function moveMarker(bookId: string, mapId: string, markerId: string, lat: number, lng: number) {
export async function updateMarker(bookId: string, mapId: string, markerId: string, input: MarkerInput, version = ""): Promise<MarkerResult> {
const { book, map } = await requireMap(bookId, mapId);
if (![lat, lng].every(Number.isFinite)) return;
await prisma.marker.updateMany({ where: { id: markerId, mapId: map.id }, data: { lat, lng } });
revalidateBook(book.id);
return changeMarker(book, map.id, markerId, await cleanMarker(book.id, input), version);
}
export async function moveMarker(bookId: string, mapId: string, markerId: string, lat: number, lng: number, version = ""): Promise<MarkerResult> {
const { book, map } = await requireMap(bookId, mapId);
if (![lat, lng].every(Number.isFinite)) throw new Error("Invalid position");
return changeMarker(book, map.id, markerId, { lat, lng }, version);
}
export async function deleteMarker(bookId: string, mapId: string, markerId: string) {
+44 -8
View File
@@ -1,20 +1,22 @@
"use server";
import type { Prisma } from "@prisma/client";
import { Prisma } from "@prisma/client";
import { redirect } from "next/navigation";
import { conflictInfo, isStaleVersion, versionOfOptional, type SaveResult } from "@/lib/conflict";
import { prisma } from "@/lib/db";
import { revalidateBook, str } from "@/lib/form";
import { parseTemplateKind, templateSlug } from "@/lib/kinds";
import { requireBook } from "@/lib/session";
import { validateFields } from "@/lib/templates";
import { templateChanges } from "@/lib/template-diff";
import { validateFields, type FieldDef } from "@/lib/templates";
export async function saveTemplate(formData: FormData) {
export async function saveTemplate(formData: FormData): Promise<SaveResult> {
const book = await requireBook(str(formData, "bookId"), "ADMIN");
const kind = parseTemplateKind(str(formData, "kind"));
if (!kind) throw new Error("Invalid kind");
const url = `/books/${book.id}/templates/${templateSlug(kind)}`;
let fields;
let fields: FieldDef[];
try {
fields = validateFields(JSON.parse(str(formData, "fields", 200000)));
} catch (error) {
@@ -22,11 +24,45 @@ export async function saveTemplate(formData: FormData) {
redirect(`${url}?error=${encodeURIComponent(reason)}`);
}
await prisma.template.upsert({
where: { bookId_kind: { bookId: book.id, kind } },
update: { fields: fields as unknown as Prisma.InputJsonArray },
create: { bookId: book.id, kind, fields: fields as unknown as Prisma.InputJsonArray },
// Har någon annan sparat mallen sedan sidan öppnades?
const conflict = async (current: { fields: unknown; updatedAt: Date; updatedById: string | null }): Promise<SaveResult> => {
let saved: FieldDef[] = [];
try {
saved = validateFields(current.fields);
} catch {
// trasig mall: ingen jämförelse
}
return { conflict: await conflictInfo(current, templateChanges(saved, fields)) };
};
const existing = await prisma.template.findUnique({ where: { bookId_kind: { bookId: book.id, kind } } });
if (isStaleVersion(str(formData, "version", 30), versionOfOptional(existing?.updatedAt))) {
// Mallen har ändrats, eller tagits bort så att standardmallen gäller igen
return existing ? conflict(existing) : { conflict: { version: versionOfOptional(null), by: null, at: new Date().toISOString(), changes: [] } };
}
const data = fields as unknown as Prisma.InputJsonArray;
if (existing) {
// Villkoret på updatedAt gör att en samtidig sparning av någon annan inte skrivs över
const { count } = await prisma.template.updateMany({
where: { id: existing.id, updatedAt: existing.updatedAt },
data: { fields: data, updatedAt: new Date(), updatedById: book.userId },
});
if (count === 0) {
const current = await prisma.template.findUnique({ where: { id: existing.id } });
return current ? conflict(current) : { conflict: { version: versionOfOptional(null), by: null, at: new Date().toISOString(), changes: [] } };
}
} else {
try {
await prisma.template.create({ data: { bookId: book.id, kind, fields: data, updatedById: book.userId } });
} catch (error) {
if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2002") {
const current = await prisma.template.findUnique({ where: { bookId_kind: { bookId: book.id, kind } } });
if (current) return conflict(current);
}
throw error;
}
}
revalidateBook(book.id);
redirect(`${url}?saved=1`);
}
+30 -7
View File
@@ -3,10 +3,22 @@
import { revalidateBook, str } from "@/lib/form";
import { requireBook } from "@/lib/session";
import { MAX_DOCX_BYTES } from "@/lib/word-docx";
import { IMPORT_KINDS, type ImportKind } from "@/lib/word-import";
import { MAX_WORD_FILES, MAX_WORD_ITEMS, commitWordImport, previewWordFiles, type CommitItem, type CommitResult, type PreviewDocument } from "@/lib/word-import-db";
import { IMPORT_KINDS, SPECIAL_KINDS, type DocKind } from "@/lib/word-import";
import {
MAX_WORD_FILES,
MAX_WORD_ITEMS,
commitWordImport,
loadScheduleOptions,
previewWordFiles,
type CommitItem,
type CommitMap,
type CommitResult,
type CommitSchedule,
type PreviewDocument,
} from "@/lib/word-import-db";
export type PreviewResponse = { docs: PreviewDocument[] } | { error: "no-files" | "limit" };
export type ScheduleOptions = Awaited<ReturnType<typeof loadScheduleOptions>>;
export type PreviewResponse = ({ docs: PreviewDocument[] } & ScheduleOptions) | { error: "no-files" | "limit" };
/** Läser uppladdade Word-filer och visar vad som hittades. Ingenting sparas. */
export async function previewWordImport(formData: FormData): Promise<PreviewResponse> {
@@ -15,7 +27,8 @@ export async function previewWordImport(formData: FormData): Promise<PreviewResp
if (uploads.length === 0) return { error: "no-files" };
if (uploads.length > MAX_WORD_FILES) return { error: "limit" };
const kinds = formData.getAll("kinds").map((k) => (IMPORT_KINDS as string[]).includes(String(k)) ? (String(k) as ImportKind) : null);
const allKinds: string[] = [...IMPORT_KINDS, ...SPECIAL_KINDS];
const kinds = formData.getAll("kinds").map((k) => (allKinds.includes(String(k)) ? (String(k) as DocKind) : null));
const files = await Promise.all(
uploads.map(async (file) => ({
name: file.name.slice(0, 200),
@@ -25,14 +38,24 @@ export async function previewWordImport(formData: FormData): Promise<PreviewResp
})),
);
const docs = await previewWordFiles(book.id, files.map(({ name, bytes }) => ({ name, bytes })), kinds);
return { docs: docs.map((doc, i) => (files[i].tooLarge ? { ...doc, error: "too-large" as const } : doc)) };
return { docs: docs.map((doc, i) => (files[i].tooLarge ? { ...doc, error: "too-large" as const } : doc)), ...(await loadScheduleOptions(book.id)) };
}
/** Sparar det användaren valt i förhandsgranskningen. Allt kontrolleras igen mot boken innan det sparas. */
export async function saveWordImport(input: { bookId: string; items: CommitItem[]; appendUnmatched: boolean }): Promise<CommitResult> {
export async function saveWordImport(input: {
bookId: string;
items: CommitItem[];
appendUnmatched: boolean;
schedules?: CommitSchedule[];
maps?: CommitMap[];
}): Promise<CommitResult> {
const book = await requireBook(String(input.bookId), "EDITOR");
const items = Array.isArray(input.items) ? input.items.slice(0, MAX_WORD_ITEMS) : [];
const result = await commitWordImport(book.id, book.userId, items, { appendUnmatched: input.appendUnmatched === true });
const result = await commitWordImport(book.id, book.userId, items, {
appendUnmatched: input.appendUnmatched === true,
schedules: Array.isArray(input.schedules) ? input.schedules : [],
maps: Array.isArray(input.maps) ? input.maps : [],
});
revalidateBook(book.id);
return result;
}
@@ -12,10 +12,10 @@ import { fileUrl } from "@/lib/files";
import { KIND_INFO, WORKPLACE_KINDS } from "@/lib/kinds";
import { hasRole } from "@/lib/access";
import { requireBook, requireEntity } from "@/lib/session";
import { formatFieldValue, getTemplate, type FieldDef } from "@/lib/templates";
import { formatFieldValue, getTemplate, refIds, type FieldDef } from "@/lib/templates";
type RefTarget = { id: string; name: string; code: string | null };
type Group = { section?: string; items: { field: FieldDef; value: string; target?: RefTarget }[] };
type Group = { section?: string; items: { field: FieldDef; value: string; targets?: RefTarget[] }[] };
function groupFields(fields: FieldDef[], data: Record<string, unknown>, byId: Map<string, RefTarget>): Group[] {
const groups: Group[] = [];
@@ -26,8 +26,8 @@ function groupFields(fields: FieldDef[], data: Record<string, unknown>, byId: Ma
current = { section: field.section, items: [] };
}
if (field.type === "reference") {
const target = typeof data[field.key] === "string" ? byId.get(data[field.key] as string) : undefined;
if (target) current.items.push({ field, value: target.name, target });
const targets = refIds(data[field.key]).flatMap((id) => byId.get(id) ?? []);
if (targets.length > 0) current.items.push({ field, value: targets.map((t) => t.name).join(", "), targets });
continue;
}
const value = formatFieldValue(field, data[field.key]);
@@ -79,7 +79,7 @@ export default async function EntityPage({ params }: { params: Promise<{ bookId:
// Poster som pekar hit via ett kopplingsfält i sin mall, t.ex. företag som använder den här lokalen
const referencing = bookEntities.filter(
(e) => e.id !== entity.id && Object.values((e.data ?? {}) as Record<string, unknown>).some((v) => v === entity.id),
(e) => e.id !== entity.id && Object.values((e.data ?? {}) as Record<string, unknown>).some((v) => v === entity.id || (Array.isArray(v) && v.includes(entity.id))),
);
const referencingTemplates = new Map(
await Promise.all(
@@ -88,7 +88,7 @@ export default async function EntityPage({ params }: { params: Promise<{ bookId:
);
const backlinks = referencing.map((e) => {
const data = (e.data ?? {}) as Record<string, unknown>;
const field = (referencingTemplates.get(e.kind) ?? []).find((f) => f.type === "reference" && data[f.key] === entity.id);
const field = (referencingTemplates.get(e.kind) ?? []).find((f) => f.type === "reference" && refIds(data[f.key]).includes(entity.id));
return { entity: e, label: field?.label ?? null };
});
const isWorkplace = WORKPLACE_KINDS.includes(entity.kind);
@@ -215,15 +215,19 @@ export default async function EntityPage({ params }: { params: Promise<{ bookId:
<div key={i} className={i > 0 ? "mt-4" : ""}>
{group.section ? <h4 className="subheader border-bottom pb-2 mb-3">{group.section}</h4> : null}
<dl className="mb-0">
{group.items.map(({ field, value, target }) => (
{group.items.map(({ field, value, targets }) => (
<div className="row mb-2" key={field.key}>
<dt className="col-sm-4 text-secondary fw-normal">{field.label}</dt>
<dd className={`col-sm-8 mb-0 ${field.type === "textarea" ? "bm-prewrap" : ""}`}>
{target ? (
{targets ? (
targets.map((target) => (
<div key={target.id}>
<Link href={entityHref(target.id)} className="fw-bold">
{target.code ? <span className="badge me-2">{target.code}</span> : null}
{target.name}
</Link>
</div>
))
) : field.type === "url" ? (
<a href={value} target="_blank" rel="noopener noreferrer nofollow">
{value}
@@ -7,6 +7,7 @@ import { getT } from "@/i18n/server";
import { prisma } from "@/lib/db";
import { fileUrl } from "@/lib/files";
import { hasRole } from "@/lib/access";
import { versionOf } from "@/lib/conflict";
import { requireBook } from "@/lib/session";
// Standard är OpenStreetMaps publika tjänster. Byt via miljövariabler vid tyngre användning.
@@ -64,6 +65,7 @@ export default async function MapPage({
lat: m.lat,
lng: m.lng,
entityId: m.entityId,
version: versionOf(m.updatedAt),
}))}
entities={entities}
tileUrl={TILE_URL}
@@ -97,7 +97,7 @@ export default async function RelationPage({
/>
<PageBody>
{saved ? <div className="alert alert-success">{t("common.saved")}</div> : null}
<ConflictForm action={saveRelation} version={versionOf(relation.updatedAt)}>
<ConflictForm key={versionOf(relation.updatedAt)} action={saveRelation} version={versionOf(relation.updatedAt)}>
<input type="hidden" name="bookId" value={bookId} />
<input type="hidden" name="id" value={relation.id} />
<div className="card mb-3">
+4 -2
View File
@@ -2,9 +2,11 @@ import { IconDownload } from "@tabler/icons-react";
import { deleteBook, updateBook } from "@/actions/books";
import { changeMemberRole, leaveSharedBook, removeBookMember, shareBook } from "@/actions/sharing";
import { ConfirmSubmit } from "@/components/confirm-submit";
import { ConflictForm } from "@/components/conflict-form";
import { PageBody, PageHeader } from "@/components/page";
import { getT } from "@/i18n/server";
import { MEMBER_ROLES, canChangeMember, hasRole, manageableRoles } from "@/lib/access";
import { versionOf } from "@/lib/conflict";
import { requireBook } from "@/lib/session";
import { SHARE_RESULTS, listMembers, type ShareResult } from "@/lib/sharing";
@@ -34,7 +36,7 @@ export default async function SettingsPage({
<PageBody>
<div className="row row-cards">
<div className="col-lg-8">
<form action={updateBook} className="card mb-3">
<ConflictForm key={versionOf(book.updatedAt)} action={updateBook} version={versionOf(book.updatedAt)} className="card mb-3">
<input type="hidden" name="bookId" value={book.id} />
<fieldset disabled={!isAdmin}>
<div className="card-body">
@@ -66,7 +68,7 @@ export default async function SettingsPage({
</div>
) : null}
</fieldset>
</form>
</ConflictForm>
<div className="card">
<div className="card-header">
@@ -4,6 +4,8 @@ import { TemplateEditor } from "@/components/template-editor";
import { getT } from "@/i18n/server";
import { templateKindFromSlug } from "@/lib/kinds";
import { requireBook } from "@/lib/session";
import { versionOfOptional } from "@/lib/conflict";
import { prisma } from "@/lib/db";
import { getPresets, getTemplate } from "@/lib/templates";
export default async function TemplateEditPage({
@@ -20,6 +22,8 @@ export default async function TemplateEditPage({
if (!kind) notFound();
const { t, locale } = await getT();
const { fields, custom } = await getTemplate(bookId, kind, locale);
const row = await prisma.template.findUnique({ where: { bookId_kind: { bookId, kind } }, select: { updatedAt: true } });
const version = versionOfOptional(row?.updatedAt);
const presets = getPresets(kind, locale).map((p) => ({ ...p, label: t(`template.preset.${p.id}`) }));
const kindLabel = kind === "RELATION" ? t("relation.one") : t(`kind.${kind}.one`);
@@ -33,7 +37,7 @@ export default async function TemplateEditPage({
<PageBody>
{error ? <div className="alert alert-danger">{t("template.invalid", { reason: error })}</div> : null}
{saved ? <div className="alert alert-success">{t("common.saved")}</div> : null}
<TemplateEditor bookId={bookId} kind={kind} initialFields={fields} custom={custom} presets={presets} />
<TemplateEditor key={version} bookId={bookId} kind={kind} initialFields={fields} custom={custom} presets={presets} version={version} />
</PageBody>
</>
);
@@ -51,7 +51,7 @@ export default async function EventPage({
<PageBody>
{saved ? <div className="alert alert-success">{t("common.saved")}</div> : null}
{error === "date" ? <div className="alert alert-danger">{t("timeline.invalidDate")}</div> : null}
<ConflictForm action={saveEvent} version={versionOf(event.updatedAt)}>
<ConflictForm key={versionOf(event.updatedAt)} action={saveEvent} version={versionOf(event.updatedAt)}>
<input type="hidden" name="bookId" value={bookId} />
<input type="hidden" name="id" value={event.id} />
<div className="card mb-3">
+9 -3
View File
@@ -8,7 +8,7 @@ import { NameFill } from "./name-fill";
import { StoryDateInput } from "./story-date-input";
import { fileUrl } from "@/lib/files";
import { KINDS } from "@/lib/kinds";
import type { FieldDef } from "@/lib/templates";
import { refIds, type FieldDef } from "@/lib/templates";
export type RefOption = { id: string; name: string; kind: EntityKind; code: string | null };
@@ -47,8 +47,14 @@ export function FieldInput({
const candidates = (refs?.entities ?? []).filter((e) => !field.refKind || e.kind === field.refKind);
const selected = typeof value === "string" ? value : "";
return (
<select name={name} className="form-select" defaultValue={selected}>
<option value="" />
<select
name={name}
className="form-select"
multiple={field.multiple}
size={field.multiple ? Math.min(8, Math.max(3, candidates.length)) : undefined}
defaultValue={field.multiple ? refIds(value) : selected}
>
{field.multiple ? null : <option value="" />}
{field.refKind
? candidates.map((e) => (
<option key={e.id} value={e.id}>
+79 -6
View File
@@ -7,6 +7,7 @@ import L from "leaflet";
import "leaflet/dist/leaflet.css";
import { IconCurrentLocation, IconPlus, IconSearch, IconX } from "@tabler/icons-react";
import { createMarker, deleteMarker, moveMarker, saveMapView, updateMarker } from "@/actions/maps";
import type { ConflictInfo } from "@/lib/conflict";
import { useT } from "@/i18n/client";
import { KINDS, MARKER_COLORS } from "@/lib/kinds";
@@ -19,6 +20,8 @@ export type MarkerDTO = {
lat: number;
lng: number;
entityId: string | null;
/** Versionen av markeringen, för att upptäcka att någon annan ändrat den */
version: string;
};
export type EntityOpt = { id: string; name: string; kind: string };
@@ -49,6 +52,8 @@ type Draft = {
entityId: string;
lat: number;
lng: number;
/** Tom för en ny markering */
version: string;
};
type GeoHit = { name: string; lat: number; lng: number };
@@ -71,6 +76,8 @@ export default function MapView(props: MapViewProps) {
const t = useT();
const router = useRouter();
const [pending, startTransition] = useTransition();
const [conflict, setConflict] = useState<ConflictInfo | null>(null);
const [notice, setNotice] = useState<string | null>(null);
const containerRef = useRef<HTMLDivElement>(null);
const mapRef = useRef<L.Map | null>(null);
@@ -98,19 +105,31 @@ export default function MapView(props: MapViewProps) {
handlers.current.mapClick = (lat, lng) => {
if (readOnly || !adding) return;
const pre = initial.current.place ?? "";
setDraft({ id: null, label: pre ? entityName(pre) : "", note: "", color: "blue", entityId: pre, lat, lng });
setConflict(null);
setDraft({ id: null, label: pre ? entityName(pre) : "", note: "", color: "blue", entityId: pre, lat, lng, version: "" });
setAdding(false);
};
handlers.current.openMarker = (id) => {
const m = markers.find((x) => x.id === id);
if (!m) return;
setAdding(false);
setDraft({ id: m.id, label: m.label, note: m.note ?? "", color: m.color, entityId: m.entityId ?? "", lat: m.lat, lng: m.lng });
setConflict(null);
setNotice(null);
setDraft({ id: m.id, label: m.label, note: m.note ?? "", color: m.color, entityId: m.entityId ?? "", lat: m.lat, lng: m.lng, version: m.version });
};
handlers.current.moveMarker = (id, lat, lng) => {
const version = markers.find((x) => x.id === id)?.version ?? "";
setDraft((d) => (d && d.id === id ? { ...d, lat, lng } : d));
startTransition(async () => {
await moveMarker(bookId, mapId, id, lat, lng);
const result = await moveMarker(bookId, mapId, id, lat, lng, version);
if ("version" in result) {
setDraft((d) => (d && d.id === id ? { ...d, version: result.version } : d));
} else {
// Någon annan har ändrat eller tagit bort markeringen: flytten sparades inte och kartan laddas om
setNotice("gone" in result ? t("map.markerGone") : t("map.markerMoved"));
setConflict(null);
setDraft((d) => (d && d.id === id ? null : d));
}
router.refresh();
});
};
@@ -251,6 +270,11 @@ export default function MapView(props: MapViewProps) {
function submitDraft(event: React.FormEvent) {
event.preventDefault();
save();
}
/** Sparar markeringen. `version` anges när användaren valt att spara över någon annans ändring. */
function save(version?: string) {
if (!draft || !draft.label.trim()) return;
const input = {
label: draft.label,
@@ -261,8 +285,17 @@ export default function MapView(props: MapViewProps) {
lng: draft.lng,
};
startTransition(async () => {
if (draft.id) await updateMarker(bookId, mapId, draft.id, input);
else await createMarker(bookId, mapId, input);
if (draft.id) {
const result = await updateMarker(bookId, mapId, draft.id, input, version ?? draft.version);
if ("conflict" in result) {
setConflict(result.conflict);
return;
}
if ("gone" in result) setNotice(t("map.markerGone"));
} else {
await createMarker(bookId, mapId, input);
}
setConflict(null);
setDraft(null);
router.refresh();
});
@@ -309,7 +342,7 @@ export default function MapView(props: MapViewProps) {
function chooseHit(hit: GeoHit) {
mapRef.current?.setView([hit.lat, hit.lng], 16);
setAdding(false);
setDraft({ id: null, label: hit.name.split(",")[0], note: "", color: "blue", entityId: "", lat: hit.lat, lng: hit.lng });
setDraft({ id: null, label: hit.name.split(",")[0], note: "", color: "blue", entityId: "", lat: hit.lat, lng: hit.lng, version: "" });
setHits(null);
}
@@ -320,6 +353,11 @@ export default function MapView(props: MapViewProps) {
</div>
<div className="col-lg-4">
{notice ? (
<div className="alert alert-warning" role="alert">
{notice}
</div>
) : null}
<div className="card mb-3">
<div className="card-body d-flex flex-wrap gap-2 align-items-center">
{readOnly ? null : (
@@ -384,6 +422,41 @@ export default function MapView(props: MapViewProps) {
</div>
) : null}
</div>
{conflict ? (
<div className="alert alert-warning m-3 mb-0" role="alert">
<h4 className="alert-title">{t("conflict.title")}</h4>
<div className="mb-2">
{conflict.by
? t("conflict.by", { name: conflict.by, time: new Date(conflict.at).toLocaleString() })
: t("conflict.byUnknown", { time: new Date(conflict.at).toLocaleString() })}
</div>
{conflict.changes.length > 0 ? (
<ul className="mb-2">
{conflict.changes.map((c) => (
<li key={c.label}>
<strong>{c.label}:</strong> {c.before || t("conflict.empty")} → {c.after || t("conflict.empty")}
</li>
))}
</ul>
) : null}
<div className="d-flex flex-wrap gap-2">
<button type="button" className="btn btn-warning btn-sm" disabled={pending} onClick={() => save(conflict.version)}>
{t("conflict.overwrite")}
</button>
<button
type="button"
className="btn btn-sm"
onClick={() => {
setConflict(null);
setDraft(null);
router.refresh();
}}
>
{t("conflict.reload")}
</button>
</div>
</div>
) : null}
<fieldset disabled={readOnly}>
<div className="card-body">
<div className="mb-3">
+14 -2
View File
@@ -5,6 +5,7 @@ import { IconArrowDown, IconArrowUp, IconPlus, IconX } from "@tabler/icons-react
import type { TemplateKind } from "@/lib/kinds";
import { resetTemplate, saveTemplate } from "@/actions/templates";
import { ConfirmSubmit } from "@/components/confirm-submit";
import { ConflictForm } from "@/components/conflict-form";
import { useT } from "@/i18n/client";
import { KINDS, parseKind } from "@/lib/kinds";
import { FIELD_TYPES, type FieldDef, type FieldType } from "@/lib/templates";
@@ -30,12 +31,15 @@ export function TemplateEditor({
initialFields,
custom,
presets,
version,
}: {
bookId: string;
kind: TemplateKind;
initialFields: FieldDef[];
custom: boolean;
presets: { id: string; label: string; fields: FieldDef[] }[];
/** Mallens version när sidan öppnades, för att upptäcka att någon annan sparat under tiden */
version: string;
}) {
const t = useT();
const [nextId, setNextId] = useState(initialFields.length);
@@ -56,6 +60,7 @@ export function TemplateEditor({
.filter(Boolean);
}
if (f.type === "reference" && f.refKind) field.refKind = f.refKind;
if (f.type === "reference" && f.multiple) field.multiple = true;
if (f.section) field.section = f.section;
return field;
});
@@ -86,6 +91,7 @@ export function TemplateEditor({
type: FIELD_TYPES.includes(f.type) ? f.type : "text",
section: f.section,
refKind: parseKind(f.refKind) ?? undefined,
multiple: f.multiple === true,
optionsText: Array.isArray(f.options) ? f.options.join(", ") : "",
rowId: id++,
})),
@@ -108,7 +114,7 @@ export function TemplateEditor({
return (
<>
<form action={saveTemplate}>
<ConflictForm action={saveTemplate} version={version}>
<input type="hidden" name="bookId" value={bookId} />
<input type="hidden" name="kind" value={kind} />
<input type="hidden" name="fields" value={fieldsJson} />
@@ -198,6 +204,12 @@ export function TemplateEditor({
<input className="form-control" value={row.section ?? ""} onChange={(e) => update(row.rowId, { section: e.target.value })} />
</div>
) : null}
{row.type === "reference" ? (
<label className="form-check form-switch mt-2 mb-0">
<input type="checkbox" className="form-check-input" checked={row.multiple === true} onChange={(e) => update(row.rowId, { multiple: e.target.checked })} />
<span className="form-check-label">{t("template.multiple")}</span>
</label>
) : null}
</div>
))}
</div>
@@ -218,7 +230,7 @@ export function TemplateEditor({
</button>
</div>
</div>
</form>
</ConflictForm>
<div className="row row-cards">
<div className="col-lg-8">
+213 -6
View File
@@ -2,15 +2,33 @@
import Link from "next/link";
import { useState, useTransition } from "react";
import { previewWordImport, saveWordImport } from "@/actions/word-import";
import { previewWordImport, saveWordImport, type ScheduleOptions } from "@/actions/word-import";
import { useT } from "@/i18n/client";
import type { ImportKind } from "@/lib/word-import";
import type { DocKind } from "@/lib/word-import";
import type { CommitResult, PreviewDocument } from "@/lib/word-import-db";
const KINDS: ImportKind[] = ["CHARACTER", "PET", "HOME", "COMPANY", "PREMISES", "EDUCATION", "SCENARIO", "RELATION", "VEHICLE", "REFERENCE", "RESEARCH", "APP", "WEBSITE"];
const KINDS: DocKind[] = [
"CHARACTER",
"PET",
"HOME",
"COMPANY",
"PREMISES",
"EDUCATION",
"SCENARIO",
"RELATION",
"VEHICLE",
"REFERENCE",
"RESEARCH",
"APP",
"WEBSITE",
"SCHEDULE",
"SCHEDULE_REGISTER",
"MAP_REGISTER",
];
const SHOWN_ITEMS = 40;
type Decision = { include: boolean; name: string };
type ScheduleDecision = { include: boolean; personId: string; workplaceId: string; replace: boolean };
/** Importerar ifyllda Word-mallar: ladda upp, granska vad som hittades, bekräfta. Inget sparas före bekräftelsen. */
export function WordImport({ bookId }: { bookId: string }) {
@@ -18,7 +36,10 @@ export function WordImport({ bookId }: { bookId: string }) {
const [files, setFiles] = useState<File[]>([]);
const [kinds, setKinds] = useState<string[]>([]);
const [docs, setDocs] = useState<PreviewDocument[] | null>(null);
const [options, setOptions] = useState<ScheduleOptions>({ people: [], workplaces: [] });
const [decisions, setDecisions] = useState<Decision[][]>([]);
const [schedules, setSchedules] = useState<Record<number, ScheduleDecision>>({});
const [maps, setMaps] = useState<Record<number, boolean[]>>({});
const [append, setAppend] = useState(true);
const [error, setError] = useState<string | null>(null);
const [result, setResult] = useState<CommitResult | null>(null);
@@ -41,6 +62,7 @@ export function WordImport({ bookId }: { bookId: string }) {
return;
}
setDocs(response.docs);
setOptions({ people: response.people, workplaces: response.workplaces });
// Poster som redan finns är avmarkerade, och relationer utan två kända deltagare går inte att importera
setDecisions(
response.docs.map((doc) =>
@@ -50,6 +72,14 @@ export function WordImport({ bookId }: { bookId: string }) {
})),
),
);
setSchedules(
Object.fromEntries(
response.docs.flatMap((doc, d) =>
doc.schedule ? [[d, { include: !!doc.schedule.personId && doc.schedule.shifts.length > 0, personId: doc.schedule.personId ?? "", workplaceId: doc.schedule.workplaceId ?? "", replace: false }]] : [],
),
),
);
setMaps(Object.fromEntries(response.docs.flatMap((doc, d) => (doc.maps.length > 0 ? [[d, doc.maps.map((m) => m.kind === "GEO")]] : []))));
});
}
@@ -57,7 +87,19 @@ export function WordImport({ bookId }: { bookId: string }) {
setDecisions((all) => all.map((list, d) => (d === doc ? list.map((x, i) => (i === item ? { ...x, ...change } : x)) : list)));
}
const selectedCount = decisions.reduce((sum, list) => sum + list.filter((d) => d.include).length, 0);
function updateSchedule(doc: number, change: Partial<ScheduleDecision>) {
setSchedules((all) => {
const next = { ...all[doc], ...change };
// Ett schema utan person går inte att importera
if (!next.personId) next.include = false;
return { ...all, [doc]: next };
});
}
const selectedCount =
decisions.reduce((sum, list) => sum + list.filter((d) => d.include).length, 0) +
Object.values(schedules).filter((s) => s.include).length +
Object.values(maps).reduce((sum, list) => sum + list.filter(Boolean).length, 0);
function commit() {
if (!docs) return;
@@ -73,14 +115,28 @@ export function WordImport({ bookId }: { bookId: string }) {
participants: item.entityKind === "RELATION" ? (doc.relation?.participants.map((p) => p.entityId).filter((id): id is string => !!id) ?? []) : undefined,
})),
);
const scheduleItems = docs.flatMap((doc, d) =>
doc.schedule && schedules[d]
? [{ include: schedules[d].include, code: doc.schedule.code, personId: schedules[d].personId || null, workplaceId: schedules[d].workplaceId || null, shifts: doc.schedule.shifts, replace: schedules[d].replace }]
: [],
);
const mapItems = docs.flatMap((doc, d) => doc.maps.map((m, i) => ({ include: maps[d]?.[i] ?? false, code: m.code, name: m.name, kind: m.kind, markers: m.markers })));
startTransition(async () => {
setResult(await saveWordImport({ bookId, items, appendUnmatched: append }));
try {
setResult(await saveWordImport({ bookId, items, appendUnmatched: append, schedules: scheduleItems, maps: mapItems }));
setError(null);
setDocs(null);
setFiles([]);
setKinds([]);
} catch {
// Sparandet är allt eller inget, så ingenting har ändrats
setError(t("wordimport.error.save"));
}
});
}
const kindLabel = (k: DocKind) => (k === "RELATION" ? t("relation.one") : k === "SCHEDULE" || k === "SCHEDULE_REGISTER" || k === "MAP_REGISTER" ? t(`wordimport.kind.${k}`) : t(`kind.${k}.one`));
return (
<div>
<div className="card mb-3">
@@ -116,6 +172,7 @@ export function WordImport({ bookId }: { bookId: string }) {
{result ? (
<div className="alert alert-success">
{t("wordimport.done", { created: result.created, relations: result.relations, skipped: result.skipped })}{" "}
{result.shifts + result.maps + result.markers > 0 ? `${t("wordimport.doneMore", { shifts: result.shifts, maps: result.maps, markers: result.markers })} ` : ""}
<Link href={`/books/${bookId}`}>{t("common.back")}</Link>
</div>
) : null}
@@ -141,7 +198,7 @@ export function WordImport({ bookId }: { bookId: string }) {
{doc.kind ? null : <option value="">{t("wordimport.unknownType")}</option>}
{KINDS.map((k) => (
<option key={k} value={k}>
{k === "RELATION" ? t("relation.one") : t(`kind.${k}.one`)}
{kindLabel(k)}
</option>
))}
</select>
@@ -157,6 +214,127 @@ export function WordImport({ bookId }: { bookId: string }) {
))}
{doc.items.length > 0 ? <div className="text-secondary mb-2">{t("wordimport.items", { n: doc.items.length })}</div> : null}
{doc.schedule && schedules[d] ? (
<div>
<p className="text-secondary small">{t("wordimport.schedule.help")}</p>
<div className="d-flex flex-wrap gap-2 mb-2">
{doc.schedule.code ? <span className="badge">{doc.schedule.code}</span> : null}
<span className="badge bg-blue-lt">{t("wordimport.schedule.shifts", { n: doc.schedule.shifts.length })}</span>
</div>
<ul className="small">
{doc.schedule.shifts.slice(0, 30).map((s, i) => (
<li key={i}>
{t(`day.${s.weekday}`)} {s.startTime}–{s.endTime}
{s.label ? ` · ${s.label}` : ""}
</li>
))}
{doc.schedule.shifts.length > 30 ? <li className="text-secondary">{t("wordimport.more", { n: doc.schedule.shifts.length - 30 })}</li> : null}
</ul>
{doc.schedule.source === "register" ? <div className="text-success small mb-2">{t("wordimport.schedule.fromRegister")}</div> : null}
{doc.schedule.source === "existing" ? <div className="text-success small mb-2">{t("wordimport.schedule.fromExisting")}</div> : null}
{!schedules[d].personId ? <div className="text-warning small mb-2">{t("wordimport.schedule.needPerson")}</div> : null}
<div className="row g-2 align-items-end">
<div className="col-md-5">
<label className="form-label">{t("wordimport.schedule.person")}</label>
<select className="form-select" value={schedules[d].personId} onChange={(e) => updateSchedule(d, { personId: e.target.value, include: e.target.value !== "" })}>
<option value="">{t("wordimport.schedule.choosePerson")}</option>
{options.people.map((p) => (
<option key={p.id} value={p.id}>
{p.code ? `${p.code} · ${p.name}` : p.name}
</option>
))}
</select>
</div>
<div className="col-md-5">
<label className="form-label">{t("wordimport.schedule.workplace")}</label>
<select className="form-select" value={schedules[d].workplaceId} onChange={(e) => updateSchedule(d, { workplaceId: e.target.value })}>
<option value="">{t("wordimport.schedule.noWorkplace")}</option>
{options.workplaces.map((w) => (
<option key={w.id} value={w.id}>
{w.code ? `${w.code} · ${w.name}` : w.name}
</option>
))}
</select>
</div>
<div className="col-md-2">
<label className="form-check mb-2">
<input
type="checkbox"
className="form-check-input"
checked={schedules[d].include}
disabled={!schedules[d].personId || doc.schedule.shifts.length === 0}
onChange={(e) => updateSchedule(d, { include: e.target.checked })}
/>
<span className="form-check-label">{t("wordimport.import", { n: 1 })}</span>
</label>
</div>
</div>
{schedules[d].personId ? (
<ExistingShifts personId={schedules[d].personId} workplaceId={schedules[d].workplaceId} decision={schedules[d]} initial={doc.schedule} onReplace={(replace) => updateSchedule(d, { replace })} />
) : null}
</div>
) : null}
{doc.scheduleRows.length > 0 ? (
<div>
<p className="text-secondary small">{t("wordimport.register.help")}</p>
<table className="table table-sm">
<tbody>
{doc.scheduleRows.map((r, i) => (
<tr key={i}>
<td>
<span className="badge">{r.code}</span>
</td>
<td className={r.personId ? "" : "text-warning"}>
{r.personText || "–"} {r.personText ? `(${r.personId ? t("wordimport.register.found") : t("wordimport.register.notFound")})` : ""}
</td>
<td className={r.workplaceId || !r.workplaceText ? "" : "text-warning"}>
{r.workplaceText || "–"} {r.workplaceText ? `(${r.workplaceId ? t("wordimport.register.found") : t("wordimport.register.notFound")})` : ""}
</td>
<td className="text-secondary">{r.dayNight}</td>
</tr>
))}
</tbody>
</table>
</div>
) : null}
{doc.maps.length > 0 ? (
<div>
<p className="text-secondary small">{t("wordimport.maps.help")}</p>
{doc.maps.map((m, i) => (
<div key={i} className="border rounded p-2 mb-2">
<div className="d-flex align-items-center gap-2 flex-wrap">
<input
type="checkbox"
className="form-check-input m-0"
checked={maps[d]?.[i] ?? false}
disabled={m.kind !== "GEO"}
onChange={(e) => setMaps((all) => ({ ...all, [d]: (all[d] ?? []).map((x, k) => (k === i ? e.target.checked : x)) }))}
/>
<span className="fw-bold">{m.name}</span>
{m.code ? <span className="badge">{m.code}</span> : null}
<span className="badge bg-blue-lt">{t("wordimport.maps.markers", { n: m.markers.length })}</span>
{m.exists ? <span className="badge bg-yellow-lt">{t("wordimport.maps.exists", { code: m.code ?? "" })}</span> : null}
{m.kind === "IMAGE" ? <span className="badge bg-orange-lt">{t("wordimport.maps.image")}</span> : null}
</div>
{m.markers.length > 0 ? (
<ul className="small mt-2 mb-0">
{m.markers.slice(0, 20).map((k, j) => (
<li key={j}>
{k.code ? `${k.code} · ` : ""}
{k.label}
{k.note ? <span className="text-secondary"> — {k.note}</span> : null}
</li>
))}
{m.markers.length > 20 ? <li className="text-secondary">{t("wordimport.more", { n: m.markers.length - 20 })}</li> : null}
</ul>
) : null}
</div>
))}
</div>
) : null}
{doc.relation ? (
<div className="mb-3">
<div className="fw-bold">{t("wordimport.participants")}</div>
@@ -261,3 +439,32 @@ export function WordImport({ bookId }: { bookId: string }) {
</div>
);
}
/** Antal befintliga pass följer personen och arbetsplatsen som valts, så det kommer från förhandsgranskningen om valet är oförändrat. */
function ExistingShifts({
initial,
personId,
workplaceId,
decision,
onReplace,
}: {
initial: NonNullable<PreviewDocument["schedule"]>;
personId: string;
workplaceId: string;
decision: ScheduleDecision;
onReplace: (replace: boolean) => void;
}) {
const t = useT();
// Förhandsgranskningen räknar bara pass för den person och arbetsplats som den själv hittade. Ett annat val kan ha pass
// som inte syns här, och erbjuder därför alltid att ersätta.
const same = personId === (initial.personId ?? "") && workplaceId === (initial.workplaceId ?? "");
return (
<div className="mt-2">
{same && initial.existing > 0 ? <div className="text-secondary small mb-1">{t("wordimport.schedule.existing", { n: initial.existing })}</div> : null}
<label className="form-check">
<input type="checkbox" className="form-check-input" checked={decision.replace} onChange={(e) => onReplace(e.target.checked)} />
<span className="form-check-label">{t("wordimport.schedule.replace")}</span>
</label>
</div>
);
}
+33 -1
View File
@@ -498,7 +498,7 @@ export const en: Record<keyof typeof sv, string> = {
"nav.importWord": "Import from Word",
"wordimport.title": "Import from Word",
"wordimport.help": "Upload filled-in Word templates (.docx) from Mall/ and Register/. The app interprets them and shows what it found. Nothing is saved until you confirm, and you can change names, deselect items and change the document type.",
"wordimport.helpFormat": "Write the value after the label in the same cell or the cell next to it, and mark choices with an X (for example Yes: X No:). Schedules and the map register are not imported.",
"wordimport.helpFormat": "Write the value after the label in the same cell or the cell next to it, and mark choices with an X (for example Yes: X No:). The schedule register links schedules to people and workplaces, and the map register creates maps.",
"wordimport.choose": "Word files",
"wordimport.review": "Review",
"wordimport.reading": "Reading…",
@@ -535,4 +535,36 @@ export const en: Record<keyof typeof sv, string> = {
"wordimport.another": "Import more",
"wordimport.warning.unsupported": "Schedules and the map register are not imported here. Add schedules under Schedules and maps under Maps.",
"template.multiple": "Multiple (several items can be chosen)",
"map.markerGone": "The marker has been removed by someone else.",
"map.markerMoved": "The marker has been changed by someone else. The map is reloading.",
"map.color": "Colour",
"map.position": "Position",
"wordimport.kind.SCHEDULE": "Schedule",
"wordimport.kind.SCHEDULE_REGISTER": "Schedule register",
"wordimport.kind.MAP_REGISTER": "Map register",
"wordimport.schedule.person": "Person",
"wordimport.schedule.workplace": "Workplace",
"wordimport.schedule.noWorkplace": "No workplace",
"wordimport.schedule.choosePerson": "Choose person",
"wordimport.schedule.shifts": "{n} shifts",
"wordimport.schedule.existing": "There are already {n} shifts for the person at the workplace. Shifts that already exist are not added again.",
"wordimport.schedule.replace": "Replace the existing shifts",
"wordimport.schedule.fromRegister": "Person and workplace were taken from the schedule register.",
"wordimport.schedule.fromExisting": "Person and workplace were taken from a schedule in the book with the same schedule ID.",
"wordimport.schedule.needPerson": "Choose which person the schedule is for. The schedule has no schedule ID found in a schedule register or in the book.",
"wordimport.schedule.help": "Hours with content become shifts, and consecutive hours with the same content are merged into one shift. The content becomes the shift's label.",
"wordimport.register.help": "The schedule register links schedule IDs to a person and a workplace. It is used for the schedules in the same upload and is not saved by itself.",
"wordimport.register.found": "found",
"wordimport.register.notFound": "not found in the book",
"wordimport.maps.help": "The map register creates maps with markers. The markers have no position and are placed in the middle of the map; drag them into place on the map.",
"wordimport.maps.exists": "Already exists ({code}), created as a new one",
"wordimport.maps.image": "Image map: needs an image and is not imported here",
"wordimport.maps.markers": "{n} markers",
"wordimport.doneMore": "{shifts} shifts, {maps} maps and {markers} markers were created.",
"wordimport.error.save": "The import could not be saved. Nothing has been changed.",
};
+33 -1
View File
@@ -496,7 +496,7 @@ export const sv = {
"nav.importWord": "Importera från Word",
"wordimport.title": "Importera från Word",
"wordimport.help": "Ladda upp ifyllda Word-mallar (.docx) från Mall/ och Register/. Appen tolkar dem och visar vad den hittade. Först när du bekräftar sparas något, och du kan ändra namn, välja bort poster och byta dokumenttyp.",
"wordimport.helpFormat": "Skriv värdet efter etiketten i samma cell eller i cellen bredvid, och markera val med ett X (till exempel Ja: X Nej:). Scheman och kartregistret importeras inte.",
"wordimport.helpFormat": "Skriv värdet efter etiketten i samma cell eller i cellen bredvid, och markera val med ett X (till exempel Ja: X Nej:). Schemaregistret kopplar scheman till personer och arbetsplatser, och kartregistret skapar kartor.",
"wordimport.choose": "Word-filer",
"wordimport.review": "Granska",
"wordimport.reading": "Läser…",
@@ -533,4 +533,36 @@ export const sv = {
"wordimport.another": "Importera fler",
"wordimport.warning.unsupported": "Scheman och kartregister importeras inte här. Lägg in scheman under Scheman och kartor under Kartor.",
"template.multiple": "Flera val (flera poster kan väljas)",
"map.markerGone": "Markeringen har tagits bort av någon annan.",
"map.markerMoved": "Markeringen har ändrats av någon annan. Kartan laddas om.",
"map.color": "Färg",
"map.position": "Position",
"wordimport.kind.SCHEDULE": "Schema",
"wordimport.kind.SCHEDULE_REGISTER": "Schemaregister",
"wordimport.kind.MAP_REGISTER": "Kartregister",
"wordimport.schedule.person": "Person",
"wordimport.schedule.workplace": "Arbetsplats",
"wordimport.schedule.noWorkplace": "Ingen arbetsplats",
"wordimport.schedule.choosePerson": "Välj person",
"wordimport.schedule.shifts": "{n} pass",
"wordimport.schedule.existing": "Det finns redan {n} pass för personen hos arbetsplatsen. Pass som redan finns läggs inte till en gång till.",
"wordimport.schedule.replace": "Ersätt de befintliga passen",
"wordimport.schedule.fromRegister": "Person och arbetsplats hämtades från schemaregistret.",
"wordimport.schedule.fromExisting": "Person och arbetsplats hämtades från ett schema i boken med samma Schema-ID.",
"wordimport.schedule.needPerson": "Välj vilken person schemat gäller. Schemat har inget Schema-ID som finns i ett schemaregister eller i boken.",
"wordimport.schedule.help": "Timmar med innehåll blir pass, och följande timmar med samma innehåll slås ihop till ett pass. Innehållet blir passets beteckning.",
"wordimport.register.help": "Schemaregistret kopplar Schema-ID till person och arbetsplats. Det används för scheman i samma uppladdning och sparas inte för sig.",
"wordimport.register.found": "hittades",
"wordimport.register.notFound": "hittades inte i boken",
"wordimport.maps.help": "Kartregistret skapar kartor med markeringar. Markeringarna saknar position och läggs i kartans mitt, dra dem på plats i kartan.",
"wordimport.maps.exists": "Finns redan ({code}), skapas som en ny",
"wordimport.maps.image": "Bildkarta: kräver en bild och importeras inte här",
"wordimport.maps.markers": "{n} markeringar",
"wordimport.doneMore": "{shifts} pass, {maps} kartor och {markers} markeringar skapades.",
"wordimport.error.save": "Importen kunde inte sparas. Ingenting har ändrats.",
} as const;
+5
View File
@@ -21,6 +21,11 @@ export type SaveResult = { conflict: ConflictInfo } | undefined;
export const versionOf = (updatedAt: Date) => String(updatedAt.getTime());
/** Version för något som kanske inte finns än (en mall som bara är standardmallen). */
export const NO_VERSION = "none";
export const versionOfOptional = (updatedAt?: Date | null) => (updatedAt ? versionOf(updatedAt) : NO_VERSION);
export const isStaleVersion = (expected: string, current: string) => expected !== "" && expected !== current;
/** Sant om formuläret öppnades med en äldre version än den sparade. Saknas version kontrolleras inget. */
export function isStale(expected: string, current: Date): boolean {
return expected !== "" && expected !== versionOf(current);
+17 -5
View File
@@ -1,7 +1,7 @@
import { prisma } from "./db";
import { str } from "./form";
import { normalizeStoryDate } from "./story-date";
import type { FieldDef } from "./templates";
import { refIds, type FieldDef } from "./templates";
/**
* Läser mallfälten (f_<nyckel>) ur ett formulär och lägger dem ovanpå befintlig data.
@@ -22,6 +22,13 @@ export async function collectFieldData(
data[field.key] = formData.has(name);
continue;
}
if (field.type === "reference" && field.multiple) {
// Flera poster: en lista med id. Dubbletter och tomma val tas bort.
const ids = [...new Set(formData.getAll(name).map((v) => String(v).trim()).filter(Boolean))].slice(0, 200);
if (ids.length > 0) data[field.key] = ids;
else delete data[field.key];
continue;
}
const raw = str(formData, name, 20000);
if (raw === "") {
delete data[field.key];
@@ -37,14 +44,19 @@ export async function collectFieldData(
}
}
const refFields = fields.filter((f) => f.type === "reference" && typeof data[f.key] === "string");
// Kopplingar: posterna måste finnas i boken och vara av rätt typ. Ett fält med ett val sparar ett id, ett med flera en lista.
const refFields = fields.filter((f) => f.type === "reference" && refIds(data[f.key]).length > 0);
if (refFields.length > 0) {
const ids = [...new Set(refFields.map((f) => data[f.key] as string))];
const ids = [...new Set(refFields.flatMap((f) => refIds(data[f.key])))];
const found = await prisma.entity.findMany({ where: { bookId, id: { in: ids } }, select: { id: true, kind: true } });
const kindOf = new Map(found.map((e) => [e.id, e.kind]));
for (const field of refFields) {
const kind = kindOf.get(data[field.key] as string);
if (!kind || (field.refKind && kind !== field.refKind)) delete data[field.key];
const valid = refIds(data[field.key]).filter((id) => {
const kind = kindOf.get(id);
return kind && (!field.refKind || kind === field.refKind);
});
if (valid.length === 0) delete data[field.key];
else data[field.key] = field.multiple ? valid : valid[0];
}
}
return data;
+69 -12
View File
@@ -2,7 +2,9 @@ import type { Prisma } from "@prisma/client";
import { prisma } from "./db";
// Namnstatistik från öppna data. Hämtas vid första användning och sparas i databasen (tabellen NameStat).
// - Födda 1922–1997: SCB, "Tilltalsnamn, de 100 vanligaste" per födelseår (antal bärare 31 dec 2021)
// - Födda 1922–1997: SCB, "Tilltalsnamn, de 100 vanligaste" och "Förnamn, de 100 vanligaste" per födelseår (antal bärare 31 dec 2021).
// SCB publicerar bara de 100 vanligaste namnen per kön totalt, inte en full lista per år. Förnamnstabellen ger ett trettiotal namn till som
// var vanliga förr (Gösta, Rune, Märta ...), och grannåren fyller i namn som saknar bärare just det året.
// - Födda 1998–2020: SCB, nyfödda efter tilltalsnamn och namngivningsår
// - Födda 2021 och senare: Skatteverkets öppna data "Namn på nyfödda"
// - Efternamn: SCB, efternamn med minst 10 bärare (2020), de vanligaste sparas
@@ -13,10 +15,16 @@ export type Sex = "female" | "male";
export const MIN_YEAR = 1922;
const SCB_G = "https://api.scb.se/OV0104/v1/doris/sv/ssd/BE/BE0001/BE0001G";
const SCB_F100 = `${SCB_G}/BE0001F100`;
const SCB_D = "https://api.scb.se/OV0104/v1/doris/sv/ssd/BE/BE0001/BE0001D";
const SKATTEVERKET = "https://skatteverket.entryscape.net/rowstore/dataset/da2556d0-c717-45e8-a1d8-3320161d3a7d";
const SURNAME_YEAR = 2020;
const SURNAME_KEEP = 5000;
/** Äldre år har byggts av två tabeller och grannår. Poster i cachen som byggts på annat sätt hämtas om. */
export const OLD_YEARS_MARKER = "tilltalsnamn och förnamn";
export const LAST_OLD_YEAR = 1997;
const NEIGHBOUR_YEARS = 2;
const NEIGHBOUR_WEIGHT = 0.25;
const REFRESH_AFTER_MS = 90 * 24 * 60 * 60 * 1000;
export const maxYear = () => new Date().getFullYear() - 1;
@@ -55,16 +63,57 @@ async function scbQuery(url: string, query: { code: string; selection: { filter:
return body.data;
}
/**
* Slår ihop SCB:s tabeller för ett födelseår: tilltalsnamn i första hand och förnamn för de namn som bara finns där,
* och namn utan bärare det året får en liten andel av grannåren. `tilltal` och `fornamn` är antal per år och namn.
*/
export function blendOldYear(year: number, tilltal: Map<number, Map<string, number>>, fornamn: Map<number, Map<string, number>>): Entry[] {
const base = (y: number, name: string) => tilltal.get(y)?.get(name) ?? fornamn.get(y)?.get(name) ?? 0;
const names = new Set<string>();
for (const table of [tilltal, fornamn]) for (const counts of table.values()) for (const name of counts.keys()) names.add(name);
const blended = new Map<string, number>();
for (const name of names) {
let count = base(year, name);
if (count === 0) {
let around = 0;
for (let d = -NEIGHBOUR_YEARS; d <= NEIGHBOUR_YEARS; d++) if (d !== 0) around += base(year + d, name);
if (around > 0) count = Math.max(1, Math.round(around * NEIGHBOUR_WEIGHT));
}
if (count > 0) blended.set(name, count);
}
return toEntries(blended);
}
/** Läser SCB:s svar med ett namn och ett år per rad, sorterat på år. */
function byYear(rows: { key: string[]; values: string[] }[], prefix: string): Map<number, Map<string, number>> {
const years = new Map<number, Map<string, number>>();
for (const row of rows) {
if (!row.key[0].startsWith(prefix)) continue;
const year = Number(row.key[1]);
if (!Number.isInteger(year)) continue;
const counts = years.get(year) ?? new Map<string, number>();
add(counts, row.key[0].slice(1), row.values[0]);
years.set(year, counts);
}
return years;
}
async function fetchScbOldNames(sex: Sex, year: number): Promise<Entry[]> {
const rows = await scbQuery(`${SCB_G}/BE0001T100`, [
{ code: "Tilltalsnamn", selection: { filter: "all", values: ["*"] } },
{ code: "ContentsCode", selection: { filter: "item", values: ["BE0001AN"] } },
{ code: "Tid", selection: { filter: "item", values: [String(year)] } },
]);
const from = Math.max(MIN_YEAR, year - NEIGHBOUR_YEARS);
const to = Math.min(LAST_OLD_YEAR, year + NEIGHBOUR_YEARS);
const years = Array.from({ length: to - from + 1 }, (_, i) => String(from + i));
const query = (code: string, contents: string) => [
{ code, selection: { filter: "all", values: ["*"] } },
{ code: "ContentsCode", selection: { filter: "item", values: [contents] } },
{ code: "Tid", selection: { filter: "item", values: years } },
];
const prefix = sex === "male" ? "1" : "2"; // SCB lägger 1 (män) eller 2 (kvinnor) framför namnet
const counts = new Map<string, number>();
for (const row of rows) if (row.key[0].startsWith(prefix)) add(counts, row.key[0].slice(1), row.values[0]);
return toEntries(counts);
const [tilltal, fornamn] = await Promise.all([
scbQuery(`${SCB_G}/BE0001T100`, query("Tilltalsnamn", "BE0001AN")),
scbQuery(SCB_F100, query("Fornamn", "BE0001AM")),
]);
return blendOldYear(year, byYear(tilltal, prefix), byYear(fornamn, prefix));
}
async function fetchScbNewborns(sex: Sex, year: number): Promise<Entry[]> {
@@ -109,17 +158,25 @@ export async function getGivenNames(sex: Sex, requestedYear: number): Promise<Gi
for (let attempt = 0; attempt < 3; attempt++, year--) {
const cached = await prisma.nameStat.findUnique({ where: { kind_year: { kind, year } } });
const fresh = cached && (year < 2021 || Date.now() - cached.fetchedAt.getTime() < REFRESH_AFTER_MS);
const oldStyle = year <= LAST_OLD_YEAR && !cached?.source.includes(OLD_YEARS_MARKER);
const fresh = cached && !oldStyle && (year < 2021 || Date.now() - cached.fetchedAt.getTime() < REFRESH_AFTER_MS);
if (cached && fresh) return { entries: cached.entries as Entry[], source: cached.source, year, requestedYear };
const source = sourceFor(year);
const entries = await source.fetch(sex, year);
let entries: Entry[];
try {
entries = await source.fetch(sex, year);
} catch (error) {
// En äldre sparad lista är bättre än inget när SCB inte svarar
if (cached) return { entries: cached.entries as Entry[], source: cached.source, year, requestedYear };
throw error;
}
// Nytt år kan saknas i Skatteverkets data tills det publicerats: pröva året före
if (entries.length === 0) {
if (cached) return { entries: cached.entries as Entry[], source: cached.source, year, requestedYear };
continue;
}
const sourceText = `${source.label}, ${year >= 1998 ? "nyfödda" : "födda"} ${year}`;
const sourceText = year > LAST_OLD_YEAR ? `${source.label}, nyfödda ${year}` : `${source.label}, födda ${year} (${OLD_YEARS_MARKER})`;
await prisma.nameStat.upsert({
where: { kind_year: { kind, year } },
create: { kind, year, source: sourceText, entries: entries as unknown as Prisma.InputJsonArray },
+18
View File
@@ -0,0 +1,18 @@
import type { ConflictChange } from "./conflict";
import type { FieldDef } from "./templates";
const describe = (f: FieldDef | undefined) =>
f ? `${f.label} (${f.type}${f.multiple ? ", flera" : ""}${f.options?.length ? `: ${f.options.join("/")}` : ""}${f.refKind ? `: ${f.refKind}` : ""})` : "";
/** Skillnaden mellan en sparad mall och en som skickats in, fält för fält på nyckeln. */
export function templateChanges(saved: FieldDef[], mine: FieldDef[]): ConflictChange[] {
const before = new Map(saved.map((f) => [f.key, f]));
const after = new Map(mine.map((f) => [f.key, f]));
const changes: ConflictChange[] = [];
for (const key of new Set([...before.keys(), ...after.keys()])) {
const a = before.get(key);
const b = after.get(key);
if (JSON.stringify(a) !== JSON.stringify(b)) changes.push({ label: (b ?? a)!.label, before: describe(a), after: describe(b) });
}
return changes;
}
+20 -8
View File
@@ -3,7 +3,7 @@ import type { EntityKind } from "@prisma/client";
import type { Locale } from "@/i18n/core";
import { parseKind, type TemplateKind } from "./kinds";
// reference = koppling till en annan post (t.ex. en lokal). Värdet är postens id.
// reference = koppling till en annan post (t.ex. en lokal). Värdet är postens id, eller en lista med id om fältet tillåter flera val (multiple).
export type FieldType = "text" | "textarea" | "number" | "date" | "select" | "checkbox" | "url" | "reference";
export const FIELD_TYPES: FieldType[] = ["text", "textarea", "number", "date", "select", "checkbox", "url", "reference"];
@@ -15,15 +15,18 @@ export type FieldDef = {
options?: string[];
// För reference: vilken typ av post som kan väljas. Saknas den kan alla typer väljas.
refKind?: EntityKind;
// För reference: flera poster kan väljas (värdet är då en lista med id). Äldre värden som bara är ett id räknas som en lista med ett id.
multiple?: boolean;
// Ett fält med section startar en ny rubrik i formuläret och på sidan.
section?: string;
};
type L = [string, string]; // [svenska, engelska]
type Spec = { k: string; l: L; t?: FieldType; o?: [string[], string[]]; s?: L; r?: EntityKind };
type Spec = { k: string; l: L; t?: FieldType; o?: [string[], string[]]; s?: L; r?: EntityKind; m?: boolean };
const f = (k: string, l: L, t: FieldType = "text", s?: L, o?: [string[], string[]]): Spec => ({ k, l, t, s, o });
const ref = (k: string, l: L, r?: EntityKind, s?: L): Spec => ({ ...f(k, l, "reference", s), r });
const refs = (k: string, l: L, r?: EntityKind, s?: L): Spec => ({ ...ref(k, l, r, s), m: true });
const yes = (k: string, l: L, s?: L): Spec => f(k, l, "checkbox", s);
const area = (k: string, l: L, s?: L): Spec => f(k, l, "textarea", s);
const pick = (k: string, l: L, sv: string[], en: string[], s?: L): Spec => f(k, l, "select", s, [sv, en]);
@@ -83,7 +86,7 @@ const SPECS: Record<TemplateKind, Spec[]> = {
f("address", ["Adress", "Address"]),
f("rooms", ["Antal rum", "Number of rooms"], "number"),
f("livingArea", ["Boarea (m²)", "Living area (m²)"], "number"),
ref("sketch", ["Skiss", "Sketch"], "SKETCH"),
refs("sketch", ["Skiss", "Sketch"], "SKETCH"),
area("buildingLook", ["Byggnadsutseende", "Building appearance"], ["Byggnaden", "The building"]),
area("buildingHistory", ["Byggnadsinformation (historia)", "Building information (history)"]),
f("floor", ["Våning", "Floor"], "text", ["Lägenhet och hus", "Apartment and building"]),
@@ -135,9 +138,9 @@ const SPECS: Record<TemplateKind, Spec[]> = {
],
COMPANY: [
f("industry", ["Bransch", "Industry"], "text", ["Grunduppgifter", "Basics"]),
ref("premises", ["Lokal", "Premises"], "PREMISES"),
refs("premises", ["Lokal", "Premises"], "PREMISES"),
yes("hasSketches", ["Finns skisser", "Has sketches"]),
ref("sketch", ["Skiss", "Sketch"], "SKETCH"),
refs("sketch", ["Skiss", "Sketch"], "SKETCH"),
yes("workplaceForCharacters", ["Arbetsplats för karaktärer", "Workplace for characters"], ["Annan information", "Other information"]),
yes("socialPlace", ["Plats för karaktärerna att umgås", "Place for the characters to socialise"]),
yes("alcohol", ["Alkoholservering (restaurang/hotell)", "Serves alcohol (restaurant/hotel)"]),
@@ -161,7 +164,7 @@ const SPECS: Record<TemplateKind, Spec[]> = {
f("area", ["Yta (m²)", "Area (m²)"], "number"),
pick("tenure", ["Ägande", "Ownership"], ["Hyr", "Äga"], ["Rent", "Own"]),
f("floors", ["Antal våningar", "Number of floors"], "number"),
ref("sketch", ["Skiss", "Sketch"], "SKETCH"),
refs("sketch", ["Skiss", "Sketch"], "SKETCH"),
f("owner", ["Ägare", "Owner"]),
yes("loadingDock", ["Lastkaj", "Loading dock"], ["Faciliteter", "Facilities"]),
yes("coldStorage", ["Kyl och frys", "Cold storage"]),
@@ -189,9 +192,9 @@ const SPECS: Record<TemplateKind, Spec[]> = {
pick("ownership", ["Ägande", "Ownership"], ["Kommunal", "Privat"], ["Public", "Private"], ["Om skolan", "About the school"]),
f("grades", ["Årskurs", "Grades"]),
f("classCount", ["Antal klasser", "Number of classes"], "number"),
ref("premises", ["Lokal", "Premises"], "PREMISES"),
refs("premises", ["Lokal", "Premises"], "PREMISES"),
ref("company", ["Företag (om privat)", "Company (if private)"], "COMPANY"),
ref("sketch", ["Skiss", "Sketch"], "SKETCH"),
refs("sketch", ["Skiss", "Sketch"], "SKETCH"),
yes("cafeteria", ["Finns cafeteria", "Has cafeteria"]),
yes("youthCentre", ["Finns fritidsgård", "Has youth centre"]),
area("computerUse", ["Hur används datorer", "How computers are used"]),
@@ -269,6 +272,7 @@ function build(specs: Spec[], locale: Locale): FieldDef[] {
type: s.t ?? "text",
...(s.o ? { options: s.o[i] } : {}),
...(s.r ? { refKind: s.r } : {}),
...(s.m ? { multiple: true } : {}),
...(s.s ? { section: s.s[i] } : {}),
}));
}
@@ -316,6 +320,7 @@ export function validateFields(input: unknown): FieldDef[] {
if (!refKind) throw new Error(`refKind (${key})`);
field.refKind = refKind;
}
if (type === "reference" && r.multiple === true) field.multiple = true;
const section = typeof r.section === "string" ? r.section.trim() : "";
if (section) field.section = section.slice(0, 120);
return field;
@@ -338,6 +343,13 @@ export async function getTemplate(
return { fields: getDefaultTemplate(kind, locale), custom: false };
}
/** Id:n i ett kopplingsfält, oavsett om värdet är ett id (äldre data) eller en lista. */
export function refIds(value: unknown): string[] {
if (typeof value === "string") return value ? [value] : [];
if (Array.isArray(value)) return [...new Set(value.filter((v): v is string => typeof v === "string" && v !== ""))];
return [];
}
export function formatFieldValue(field: FieldDef, value: unknown): string {
if (value === null || value === undefined || value === "") return "";
if (field.type === "checkbox") return value ? "✓" : "";
+178 -16
View File
@@ -1,9 +1,9 @@
import type { EntityKind, Prisma } from "@prisma/client";
import { prisma } from "./db";
import { ENTITY_PREFIX, nextEntityCode, nextRelationCode, reserveNumber } from "./ids";
import { parseKind } from "./kinds";
import { ENTITY_PREFIX, nextEntityCode, nextMapCode, nextMarkerCode, nextRelationCode, nextScheduleCode, reserveNumber } from "./ids";
import { WORKPLACE_KINDS, parseKind } from "./kinds";
import { normalizeStoryDate } from "./story-date";
import { getTemplate, type FieldDef } from "./templates";
import { getTemplate, refIds, type FieldDef } from "./templates";
import { DocxError, readDocx } from "./word-docx";
import {
IMPORT_KINDS,
@@ -11,6 +11,7 @@ import {
describeUnmatched,
overflowField,
usableCode,
type DocKind,
type ImportKind,
type ItemLink,
type KnownEntity,
@@ -18,6 +19,7 @@ import {
type ParsedDocument,
type ParsedItem,
} from "./word-import";
import type { ParsedMap, ParsedShift } from "./word-schedule";
// Förhandsgranskning och sparande av importen från Word. Tolkningen själv ligger i word-import.ts.
@@ -26,8 +28,11 @@ export const MAX_WORD_ITEMS = 500;
export type PreviewItem = ParsedItem & { duplicates: { id: string; name: string; code: string | null }[] };
export type PreviewDocument = Omit<ParsedDocument, "items"> & {
export type PreviewMap = ParsedMap & { /** Det finns redan en karta med det Kart-ID:t i boken */ exists: boolean };
export type PreviewDocument = Omit<ParsedDocument, "items" | "maps"> & {
items: PreviewItem[];
maps: PreviewMap[];
/** Satt om filen inte gick att läsa */
error: "not-docx" | "too-large" | "invalid" | null;
};
@@ -44,13 +49,15 @@ async function loadContext(bookId: string) {
export async function previewWordFiles(
bookId: string,
files: { name: string; bytes: Uint8Array }[],
kinds: (ImportKind | null)[] = [],
kinds: (DocKind | null)[] = [],
): Promise<PreviewDocument[]> {
const { known, templates } = await loadContext(bookId);
const byName = new Map<string, KnownEntity[]>();
for (const e of known) byName.set(`${e.kind}|${e.name.toLowerCase()}`, [...(byName.get(`${e.kind}|${e.name.toLowerCase()}`) ?? []), e]);
return files.slice(0, MAX_WORD_FILES).map((file, index): PreviewDocument => {
const mapCodes = new Set((await prisma.bookMap.findMany({ where: { bookId, code: { not: null } }, select: { code: true } })).map((m) => m.code));
const docs = files.slice(0, MAX_WORD_FILES).map((file, index): PreviewDocument => {
try {
const blocks = readDocx(file.bytes);
const parsed = analyzeDocument(blocks, file.name, known, { kind: kinds[index] ?? null, templates });
@@ -62,12 +69,48 @@ export async function previewWordFiles(
duplicates:
item.entityKind === "RELATION" ? [] : (byName.get(`${item.entityKind}|${item.name.toLowerCase()}`) ?? []).map((e) => ({ id: e.id, name: e.name, code: e.code })),
})),
maps: parsed.maps.map((m) => ({ ...m, exists: !!m.code && mapCodes.has(m.code) })),
};
} catch (error) {
if (error instanceof DocxError) return { file: file.name, kind: null, items: [], relation: null, warnings: [], error: error.code };
if (error instanceof DocxError) return { file: file.name, kind: null, items: [], relation: null, schedule: null, scheduleRows: [], maps: [], warnings: [], error: error.code };
throw error;
}
});
await linkSchedules(bookId, docs);
return docs;
}
/**
* Ger importerade scheman en person och en arbetsplats: först från schemaregistret i samma uppladdning, annars från ett
* schema med samma Schema-ID som redan finns i boken. Annars får användaren välja i förhandsgranskningen.
*/
async function linkSchedules(bookId: string, docs: PreviewDocument[]) {
const rows = docs.flatMap((d) => d.scheduleRows);
for (const doc of docs) {
const schedule = doc.schedule;
if (!schedule) continue;
if (schedule.code) {
const row = rows.find((r) => r.code === schedule.code && r.personId);
if (row) {
Object.assign(schedule, { personId: row.personId, workplaceId: row.workplaceId, source: "register" });
} else {
const shift = await prisma.shift.findFirst({ where: { bookId, scheduleCode: schedule.code }, select: { personId: true, workplaceId: true } });
if (shift) Object.assign(schedule, { personId: shift.personId, workplaceId: shift.workplaceId, source: "existing" });
}
}
if (schedule.personId) schedule.existing = await prisma.shift.count({ where: { bookId, personId: schedule.personId, workplaceId: schedule.workplaceId } });
}
}
/** Personer och arbetsplatser att välja bland för scheman som inte fick någon från registret. */
export async function loadScheduleOptions(bookId: string) {
const entities = await prisma.entity.findMany({
where: { bookId, kind: { in: ["CHARACTER", ...WORKPLACE_KINDS] } },
select: { id: true, name: true, kind: true, code: true },
orderBy: { name: "asc" },
});
return { people: entities.filter((e) => e.kind === "CHARACTER"), workplaces: entities.filter((e) => e.kind !== "CHARACTER") };
}
// ─── Spara ──────────────────────────────────────────────────────────────────
@@ -85,7 +128,42 @@ export type CommitItem = {
participants?: string[];
};
export type CommitResult = { created: number; relations: number; skipped: number };
/** Ett schema att spara: personen och arbetsplatsen väljs av användaren eller kommer från schemaregistret. */
export type CommitSchedule = {
include: boolean;
code: string | null;
personId: string | null;
workplaceId: string | null;
shifts: ParsedShift[];
/** Ta bort personens befintliga pass hos arbetsplatsen först */
replace: boolean;
};
export type CommitMap = {
include: boolean;
code: string | null;
name: string;
kind: string;
markers: { code: string | null; label: string; note: string | null }[];
};
export type CommitResult = { created: number; relations: number; skipped: number; shifts: number; maps: number; markers: number };
const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
// Markeringar från kartregistret saknar position och läggs i kartans mitt, lätt utspridda, så att de går att dra på plats
const DEFAULT_CENTER: [number, number] = [59.3293, 18.0686];
/**
* Ett nytt ID från räknaren som inte redan används. Räknaren kan ligga efter om ID har lagts in utan den (till exempel
* poster som skapats för hand eller av en äldre version), och då hoppar vi över de som är upptagna.
*/
async function freeCode(next: () => Promise<string | null>, taken: (code: string) => boolean | Promise<boolean>): Promise<string | null> {
for (let i = 0; i < 200; i++) {
const code = await next();
if (code === null || !(await taken(code))) return code;
}
throw new Error("Hittade inget ledigt ID");
}
const text = (value: unknown, max: number): string => (typeof value === "string" ? value.trim().slice(0, max) : "");
@@ -114,8 +192,11 @@ export function cleanData(fields: FieldDef[], data: Record<string, unknown>, ent
if (typeof value === "string" && /^https?:\/\/\S+$/i.test(value) && value.length <= 2000) clean[field.key] = value;
break;
case "reference": {
const kind = typeof value === "string" ? entities.get(value) : undefined;
if (typeof value === "string" && kind && (!field.refKind || field.refKind === kind)) clean[field.key] = value;
const ids = refIds(value).filter((id) => {
const kind = entities.get(id);
return kind && (!field.refKind || field.refKind === kind);
});
if (ids.length > 0) clean[field.key] = field.multiple ? ids : ids[0];
break;
}
default:
@@ -136,11 +217,13 @@ export async function commitWordImport(
bookId: string,
userId: string,
items: CommitItem[],
options: { appendUnmatched: boolean },
options: { appendUnmatched: boolean; schedules?: CommitSchedule[]; maps?: CommitMap[] },
): Promise<CommitResult> {
const chosen = items.slice(0, MAX_WORD_ITEMS).filter((i) => i && i.include);
const result: CommitResult = { created: 0, relations: 0, skipped: items.length - chosen.length, };
if (chosen.length === 0) return result;
const schedules = (options.schedules ?? []).slice(0, 50).filter((s) => s && s.include);
const maps = (options.maps ?? []).slice(0, 100).filter((m) => m && m.include);
const result: CommitResult = { created: 0, relations: 0, skipped: items.length - chosen.length, shifts: 0, maps: 0, markers: 0 };
if (chosen.length === 0 && schedules.length === 0 && maps.length === 0) return result;
const existing = await prisma.entity.findMany({ where: { bookId }, select: { id: true, kind: true, code: true } });
const kindOf = new Map(existing.map((e) => [e.id, e.kind]));
@@ -176,7 +259,7 @@ export async function commitWordImport(
await tx.relation.create({
data: {
bookId,
code: await nextRelationCode(bookId, tx),
code: await freeCode(() => nextRelationCode(bookId, tx), async (c) => !!(await tx.relation.findFirst({ where: { bookId, code: c }, select: { id: true } }))),
fromId: ids[0],
toId: ids[1],
type: mapped?.type ?? (text(item.name, 100) || "Relation"),
@@ -201,7 +284,7 @@ export async function commitWordImport(
code = wanted;
await reserveNumber(bookId, ENTITY_PREFIX[kind]!, Number(wanted.split("-")[1]), tx);
} else {
code = await nextEntityCode(bookId, kind, tx);
code = await freeCode(() => nextEntityCode(bookId, kind, tx), (c) => takenCodes.has(c));
}
if (code) takenCodes.add(code);
const entity = await tx.entity.create({
@@ -217,7 +300,7 @@ export async function commitWordImport(
await tx.relation.create({
data: {
bookId,
code: await nextRelationCode(bookId, tx),
code: await freeCode(() => nextRelationCode(bookId, tx), async (c) => !!(await tx.relation.findFirst({ where: { bookId, code: c }, select: { id: true } }))),
fromId: link.toDocument ? other : entity.id,
toId: link.toDocument ? entity.id : other,
type,
@@ -228,6 +311,85 @@ export async function commitWordImport(
result.relations++;
}
}
// Scheman: ett schema-ID per person och arbetsplats, och redan befintliga pass läggs inte till en gång till
for (const schedule of schedules) {
const personId = typeof schedule.personId === "string" && kindOf.get(schedule.personId) === "CHARACTER" ? schedule.personId : null;
const workKind = typeof schedule.workplaceId === "string" ? kindOf.get(schedule.workplaceId) : undefined;
const workplaceId = schedule.workplaceId && workKind && WORKPLACE_KINDS.includes(workKind) ? schedule.workplaceId : null;
const shifts = (Array.isArray(schedule.shifts) ? schedule.shifts : [])
.slice(0, 200)
.filter((s) => s && Number.isInteger(s.weekday) && s.weekday >= 0 && s.weekday <= 6 && TIME.test(String(s.startTime)) && TIME.test(String(s.endTime)) && s.startTime !== s.endTime)
.map((s) => ({ weekday: s.weekday, startTime: s.startTime, endTime: s.endTime, label: text(s.label, 100) || null }));
if (!personId || shifts.length === 0) {
result.skipped++;
continue;
}
if (schedule.replace) await tx.shift.deleteMany({ where: { bookId, personId, workplaceId } });
const present = await tx.shift.findMany({ where: { bookId, personId, workplaceId }, select: { weekday: true, startTime: true, endTime: true, scheduleCode: true } });
const have = new Set(present.map((s) => `${s.weekday}|${s.startTime}|${s.endTime}`));
const fresh = shifts.filter((s) => !have.has(`${s.weekday}|${s.startTime}|${s.endTime}`));
let scheduleCode = present.find((s) => s.scheduleCode)?.scheduleCode ?? null;
if (!scheduleCode) {
const wanted = /^SCI-\d+$/.test(text(schedule.code, 20)) ? text(schedule.code, 20) : null;
if (wanted && !(await tx.shift.findFirst({ where: { bookId, scheduleCode: wanted }, select: { id: true } }))) {
scheduleCode = wanted;
await reserveNumber(bookId, "SCI", Number(wanted.split("-")[1]), tx);
} else {
scheduleCode = (await freeCode(() => nextScheduleCode(bookId, tx), async (c) => !!(await tx.shift.findFirst({ where: { bookId, scheduleCode: c }, select: { id: true } })))) as string;
}
}
await tx.shift.createMany({ data: fresh.map((s) => ({ bookId, personId, workplaceId, ...s, weeks: "ALL" as const, scheduleCode })) });
result.shifts += fresh.length;
}
// Kartor och placeringar från kartregistret. Bildkartor kräver en bild och skapas inte här.
for (const map of maps) {
const name = text(map.name, 200);
if (!name || map.kind !== "GEO") {
result.skipped++;
continue;
}
const wantedMap = /^KD-R_\d+$/.test(text(map.code, 20)) ? text(map.code, 20) : null;
let mapCode: string;
if (wantedMap && !(await tx.bookMap.findFirst({ where: { bookId, code: wantedMap }, select: { id: true } }))) {
mapCode = wantedMap;
await reserveNumber(bookId, "KD-R", Number(wantedMap.split("_")[1]), tx);
} else {
mapCode = (await freeCode(() => nextMapCode(bookId, "GEO", tx), async (c) => !!(await tx.bookMap.findFirst({ where: { bookId, code: c }, select: { id: true } })))) as string;
}
const created = await tx.bookMap.create({
data: { bookId, name, kind: "GEO", code: mapCode, centerLat: DEFAULT_CENTER[0], centerLng: DEFAULT_CENTER[1], zoom: 11 },
});
result.maps++;
for (const [i, marker] of (Array.isArray(map.markers) ? map.markers.slice(0, 500) : []).entries()) {
const label = text(marker?.label, 200);
if (!label) continue;
const wanted = /^PI-\d+$/.test(text(marker.code, 20)) ? text(marker.code, 20) : null;
let code: string;
if (wanted && !(await tx.marker.findFirst({ where: { map: { bookId }, code: wanted }, select: { id: true } }))) {
code = wanted;
await reserveNumber(bookId, "PI", Number(wanted.split("-")[1]), tx);
} else {
code = (await freeCode(() => nextMarkerCode(bookId, tx), async (c) => !!(await tx.marker.findFirst({ where: { map: { bookId }, code: c }, select: { id: true } })))) as string;
}
await tx.marker.create({
data: {
mapId: created.id,
code,
label,
note: text(marker.note, 5000) || null,
lat: DEFAULT_CENTER[0] + Math.floor(i / 10) * 0.004,
lng: DEFAULT_CENTER[1] + (i % 10) * 0.004,
updatedById: userId,
},
});
result.markers++;
}
}
},
{ timeout: 60_000, maxWait: 10_000 },
);
+78 -13
View File
@@ -4,6 +4,16 @@ import { normalizeStoryDate } from "./story-date";
import { getDefaultTemplate, type FieldDef } from "./templates";
import type { DocBlock } from "./word-docx";
import { isOptionList, labelsMatch, looseMatch, markedOption, normLabel, parseOptions, parseYesNo, pickOption } from "./word-labels";
import {
findScheduleCode,
isScheduleGrid,
parseMapRegister,
parseScheduleGrid,
parseScheduleRegister,
type ParsedMap,
type ParsedShift,
type ScheduleRow,
} from "./word-schedule";
// Tolkar ifyllda Word-mallar (Mall/ och Register/) till poster. Dokumenten är tabeller med etikett och värde,
// listor över deltagare, stycken under rubriker och register med många rader. Det som inte går att tolka
@@ -11,6 +21,10 @@ import { isOptionList, labelsMatch, looseMatch, markedOption, normLabel, parseOp
export type ImportKind = EntityKind | "RELATION";
/** Dokument som inte blir poster: scheman, schemaregistret (som kopplar scheman till personer) och kartregistret. */
export type DocKind = ImportKind | "SCHEDULE" | "SCHEDULE_REGISTER" | "MAP_REGISTER";
export const SPECIAL_KINDS: DocKind[] = ["SCHEDULE", "SCHEDULE_REGISTER", "MAP_REGISTER"];
export const IMPORT_KINDS: ImportKind[] = [
"CHARACTER",
"PET",
@@ -448,15 +462,21 @@ export function fieldsFor(kind: ImportKind, templates?: Partial<Record<ImportKin
return templates?.[kind] ?? getDefaultTemplate(kind, "sv");
}
/** Scheman och kartregistret går inte att importera här, de har egna sidor. */
function unsupportedDocument(extracted: Extracted): boolean {
const first = extracted.registers.map((r) => normLabel(r.header[0] ?? ""));
return first.some((h) => h === "schema" || h === "kart" || h === "tid") || extracted.texts.some((t) => /^schema\b/i.test(t));
/** Scheman, schemaregistret och kartregistret känns igen på sina tabellrubriker. */
function specialKind(extracted: Extracted): DocKind | null {
for (const table of extracted.registers) {
if (isScheduleGrid(table)) return "SCHEDULE";
const first = normLabel(table.header[0] ?? "");
if (first === "schema") return "SCHEDULE_REGISTER";
if (first === "kart") return "MAP_REGISTER";
}
return null;
}
/** Gissar vilken sorts dokument det är: först efter dokumentets eget ID-fält, annars efter hur många etiketter som passar. */
export function detectKind(extracted: Extracted, filename: string, templates?: Partial<Record<ImportKind, FieldDef[]>>): ImportKind | null {
if (unsupportedDocument(extracted)) return null;
export function detectKind(extracted: Extracted, filename: string, templates?: Partial<Record<ImportKind, FieldDef[]>>): DocKind | null {
const special = specialKind(extracted);
if (special) return special;
const allLabels = [...extracted.labels, ...extracted.registers.flatMap((r) => r.header)];
for (const label of allLabels) {
const kind = KIND_BY_LABEL[normLabel(label)];
@@ -482,8 +502,8 @@ export function detectKind(extracted: Extracted, filename: string, templates?: P
const CODE_IN_TEXT = /\b[A-ZÅÄÖ]{1,4}-\d{2,6}\b/;
/** Hittar en post i boken utifrån text som "KI-0003", "Anna Lind" eller "Anna Lind KI-0003". */
export function findEntity(text: string, known: KnownEntity[], kind?: EntityKind): KnownEntity | null {
const pool = kind ? known.filter((e) => e.kind === kind) : known;
export function findEntity(text: string, known: KnownEntity[], kind?: EntityKind, kinds?: EntityKind[]): KnownEntity | null {
const pool = kind ? known.filter((e) => e.kind === kind) : kinds ? known.filter((e) => kinds.includes(e.kind)) : known;
const code = CODE_IN_TEXT.exec(text)?.[0];
if (code) {
const byCode = pool.find((e) => e.code === code);
@@ -521,7 +541,7 @@ export type ParsedItem = {
type Context = { known: KnownEntity[]; fields: FieldDef[] };
/** Gör om ett värde ur dokumentet till rätt sort för fältet, eller null om det inte går. */
function convert(field: FieldDef, raw: string, ctx: Context): { value: unknown; display?: string } | null {
function convert(field: FieldDef, raw: string, ctx: Context): { value: unknown; display?: string; unresolved?: string[] } | null {
const text = raw.trim();
if (!text) return null;
switch (field.type) {
@@ -544,6 +564,17 @@ function convert(field: FieldDef, raw: string, ctx: Context): { value: unknown;
case "url":
return /^https?:\/\/\S+$/i.test(text) ? { value: text } : null;
case "reference": {
if (field.multiple) {
// Flera poster: varje del för sig. Det som inte hittas rapporteras.
const parts = splitEntries(text).map((part) => ({ part, entity: findEntity(part, ctx.known, field.refKind) }));
const found = parts.flatMap((p) => p.entity ?? []);
if (found.length === 0) return null;
return {
value: [...new Set(found.map((e) => e.id))],
display: found.map((e) => (e.code ? `${e.code} · ${e.name}` : e.name)).join(", "),
unresolved: parts.filter((p) => !p.entity).map((p) => p.part),
};
}
const entity = findEntity(text, ctx.known, field.refKind);
return entity ? { value: entity.id, display: entity.code ? `${entity.code} · ${entity.name}` : entity.name } : null;
}
@@ -621,6 +652,7 @@ export function buildItem(kind: ImportKind, pairs: Pair[], lists: ListBlock[], c
if (field && converted) {
item.data[field.key] = converted.value;
if (converted.display) item.display[field.key] = converted.display;
if (converted.unresolved?.length) item.unmatched.push({ label: pair.label.trim(), value: converted.unresolved.join(", ") });
used.add(field.key);
} else {
item.unmatched.push({ label: pair.label.trim(), value });
@@ -658,9 +690,23 @@ export function usableCode(kind: EntityKind, code: string | null): string | null
// ─── Hela dokument ──────────────────────────────────────────────────────────
export type ParsedSchedule = {
code: string | null;
shifts: ParsedShift[];
personId: string | null;
workplaceId: string | null;
/** Var personen och arbetsplatsen kommer från: schemaregistret i samma uppladdning, ett befintligt schema i boken, eller ingenstans */
source: "register" | "existing" | null;
/** Antal pass som redan finns för personen och arbetsplatsen */
existing: number;
};
export type ParsedDocument = {
file: string;
kind: ImportKind | null;
kind: DocKind | null;
schedule: ParsedSchedule | null;
scheduleRows: ScheduleRow[];
maps: ParsedMap[];
items: ParsedItem[];
/** För en relation: deltagarna, med postens id eller null om den inte hittades */
relation: null | { type: string; participants: { entityId: string | null; text: string }[] };
@@ -694,7 +740,7 @@ export function analyzeDocument(
blocks: DocBlock[],
file: string,
known: KnownEntity[],
options: { kind?: ImportKind | null; templates?: Partial<Record<ImportKind, FieldDef[]>> } = {},
options: { kind?: DocKind | null; templates?: Partial<Record<ImportKind, FieldDef[]>> } = {},
): ParsedDocument {
const templates = options.templates;
const knownLabel = (label: string) =>
@@ -703,9 +749,28 @@ export function analyzeDocument(
labelsMatch(label, "ålderfödelsedatum");
const extracted = extract(blocks, knownLabel);
const kind = options.kind ?? detectKind(extracted, file, templates);
const result: ParsedDocument = { file, kind, items: [], relation: null, warnings: [] };
const result: ParsedDocument = { file, kind, items: [], relation: null, schedule: null, scheduleRows: [], maps: [], warnings: [] };
if (!kind) {
result.warnings.push(unsupportedDocument(extracted) ? "unsupported" : "unknown-kind");
result.warnings.push("unknown-kind");
return result;
}
if (kind === "SCHEDULE") {
const grid = extracted.registers.find(isScheduleGrid);
const shifts = grid ? parseScheduleGrid(grid) : [];
const code = findScheduleCode([...extracted.texts, ...extracted.pairs.map((p) => p.value)]);
result.schedule = { code, shifts, personId: null, workplaceId: null, source: null, existing: 0 };
if (shifts.length === 0) result.warnings.push("empty");
return result;
}
if (kind === "SCHEDULE_REGISTER") {
result.scheduleRows = extracted.registers.flatMap((table) => parseScheduleRegister(table, (text, kinds) => findEntity(text, known, undefined, kinds)));
if (result.scheduleRows.length === 0) result.warnings.push("empty");
return result;
}
if (kind === "MAP_REGISTER") {
result.maps = extracted.registers.flatMap((table) => parseMapRegister(table));
if (result.maps.length === 0) result.warnings.push("empty");
return result;
}
const ctx: Context = { known, fields: fieldsFor(kind, templates) };
+189
View File
@@ -0,0 +1,189 @@
import type { EntityKind } from "@prisma/client";
import type { KnownEntity, RegisterTable } from "./word-import";
import { normLabel, markedOption, parseOptions } from "./word-labels";
// Scheman och kartregister i Word-mallarna. Ett schema är ett rutnät med timmar på raderna och veckodagar i kolumnerna,
// där en ifylld ruta betyder att personen jobbar den timmen. Kartregistret listar kartor och placeringar på dem.
export type ParsedShift = { weekday: number; startTime: string; endTime: string; label: string | null };
const WEEKDAYS: [string, number][] = [
["mån", 0],
["tis", 1],
["ons", 2],
["tor", 3],
["fre", 4],
["lör", 5],
["sön", 6],
];
/** 0 = måndag ... 6 = söndag, eller null om texten inte är en veckodag. */
export function weekdayOf(label: string): number | null {
const n = normLabel(label);
if (n.length < 3) return null;
return WEEKDAYS.find(([prefix]) => n.startsWith(prefix))?.[1] ?? null;
}
/** "6", "6:30", "06.00" och "06:00" blir "HH:MM". */
export function normalizeTime(raw: string): string | null {
const m = /^\s*(\d{1,2})(?:[:.](\d{2}))?\s*$/.exec(raw);
if (!m) return null;
const hour = Number(m[1]);
const minute = Number(m[2] ?? "0");
if (hour > 23 || minute > 59) return null;
return `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
}
const minutes = (time: string) => Number(time.slice(0, 2)) * 60 + Number(time.slice(3));
const clock = (total: number) => {
const t = ((total % 1440) + 1440) % 1440;
return `${String(Math.floor(t / 60)).padStart(2, "0")}:${String(t % 60).padStart(2, "0")}`;
};
const MARKS = /^(?:x|✓|✔|☒|☑|■|•|-|–)$/i;
/** Är tabellen ett schema: första kolumnen "Tid" och minst fem veckodagar som rubriker? */
export function isScheduleGrid(table: RegisterTable): boolean {
return normLabel(table.header[0] ?? "") === "tid" && table.header.filter((h) => weekdayOf(h) !== null).length >= 5;
}
/**
* Läser ett schema. Följande timmar med samma innehåll i en kolumn blir ett pass, så att 08:00–16:00 med innehåll på varje
* timme blir ett pass. Innehållet blir passets beteckning, utom ett ensamt kryss. Rader som följer på varandra över
* midnatt (18:00 ... 06:00 i ett nattschema) blir ett pass som går över midnatt.
*/
export function parseScheduleGrid(table: RegisterTable): ParsedShift[] {
const rows = table.rows.map((cells) => ({ cells, time: normalizeTime(cells[0] ?? "") })).filter((r): r is { cells: string[]; time: string } => r.time !== null);
const shifts: ParsedShift[] = [];
// Avståndet i minuter från rad i till rad j, om raderna följer på varandra med högst två timmar emellan
const gap = (i: number, j: number) => {
const d = (((minutes(rows[j].time) - minutes(rows[i].time)) % 1440) + 1440) % 1440;
return d > 0 && d <= 120 ? d : null;
};
const step = (i: number) => (i + 1 < rows.length ? gap(i, i + 1) : null) ?? (i > 0 ? gap(i - 1, i) : null) ?? 60;
table.header.forEach((head, col) => {
const weekday = weekdayOf(head);
if (weekday === null || col === 0) return;
let run: { start: number; last: number; label: string | null } | null = null;
const flush = () => {
if (!run) return;
const startTime = rows[run.start].time;
const endTime = clock(minutes(rows[run.last].time) + step(run.last));
if (startTime !== endTime) shifts.push({ weekday, startTime, endTime, label: run.label });
run = null;
};
rows.forEach((row, i) => {
const text = (row.cells[col] ?? "").trim();
if (!text) {
flush();
return;
}
const label = MARKS.test(text) ? null : text.slice(0, 100);
const same = run && i === run.last + 1 && gap(run.last, i) !== null && (run.label ?? "").toLowerCase() === (label ?? "").toLowerCase();
if (same && run) run.last = i;
else {
flush();
run = { start: i, last: i, label };
}
});
flush();
});
return shifts.sort((a, b) => a.weekday - b.weekday || a.startTime.localeCompare(b.startTime));
}
export const SCHEDULE_CODE = /\bSCI-\d{2,6}\b/;
export function findScheduleCode(texts: string[]): string | null {
for (const text of texts) {
const match = SCHEDULE_CODE.exec(text);
if (match) return match[0];
}
return null;
}
// ─── Schemaregistret ────────────────────────────────────────────────────────
export type ScheduleRow = {
code: string;
personText: string;
workplaceText: string;
personId: string | null;
workplaceId: string | null;
/** "Dag" eller "Natt" om något är markerat */
dayNight: string;
};
const WORKPLACE_KINDS: EntityKind[] = ["COMPANY", "EDUCATION", "PREMISES", "PLACE"];
/** Schemaregistret kopplar ett Schema-ID till en person och en arbetsplats. Det används för att ge importerade scheman rätt person. */
export function parseScheduleRegister(table: RegisterTable, resolve: (text: string, kinds?: EntityKind[]) => KnownEntity | null): ScheduleRow[] {
const norm = table.header.map((h) => normLabel(h));
const at = (test: (n: string) => boolean) => norm.findIndex(test);
const codeCol = at((n) => n === "schema");
const personCol = at((n) => n.startsWith("karaktärs"));
const workCol = at((n) => n.startsWith("företags"));
const dayCol = at((n) => n.startsWith("dag"));
const rows: ScheduleRow[] = [];
for (const cells of table.rows) {
const code = SCHEDULE_CODE.exec(cells[codeCol] ?? "")?.[0];
if (!code) continue;
const personText = (cells[personCol] ?? "").trim();
const workplaceText = (cells[workCol] ?? "").trim();
const options = parseOptions(cells[dayCol] ?? "");
rows.push({
code,
personText,
workplaceText,
personId: personText ? (resolve(personText, ["CHARACTER"])?.id ?? null) : null,
workplaceId: workplaceText ? (resolve(workplaceText, WORKPLACE_KINDS)?.id ?? null) : null,
dayNight: (options ? markedOption(options) : null) ?? "",
});
}
return rows;
}
// ─── Kartregistret ──────────────────────────────────────────────────────────
export type ParsedMapMarker = { code: string | null; label: string; note: string | null };
export type ParsedMap = { code: string | null; name: string; kind: "GEO" | "IMAGE"; markers: ParsedMapMarker[] };
const MAP_CODE = /\bKD-[RE]_\d{2,6}\b/;
const PLACEMENT_CODE = /\bPI-\d{2,6}\b/;
/**
* Kartregistret listar placeringar: Kart-ID, Placerings-ID, Stad/Område, Beskrivning och Övrigt. Rader med samma Kart-ID
* (eller samma Stad/Område när Kart-ID saknas) hör till samma karta, och varje rad med Placerings-ID eller beskrivning är
* en markering.
*/
export function parseMapRegister(table: RegisterTable): ParsedMap[] {
const norm = table.header.map((h) => normLabel(h));
const at = (test: (n: string) => boolean) => norm.findIndex(test);
const codeCol = at((n) => n === "kart");
const placeCol = at((n) => n.startsWith("placerings"));
const areaCol = at((n) => n.startsWith("stad"));
const descCol = at((n) => n.startsWith("beskrivning"));
const otherCol = at((n) => n.startsWith("övrigt"));
const cell = (cells: string[], col: number) => (col >= 0 ? (cells[col] ?? "").trim() : "");
const maps = new Map<string, ParsedMap>();
for (const cells of table.rows) {
const code = MAP_CODE.exec(cell(cells, codeCol))?.[0] ?? null;
const area = cell(cells, areaCol);
const placement = PLACEMENT_CODE.exec(cell(cells, placeCol))?.[0] ?? null;
const description = cell(cells, descCol);
const note = cell(cells, otherCol) || null;
const key = code ?? (area ? `område:${area.toLowerCase()}` : null);
if (!key) continue;
const map = maps.get(key) ?? { code, name: area, kind: code?.includes("-E_") ? "IMAGE" : "GEO", markers: [] };
if (!map.name && area) map.name = area;
if (placement || description) map.markers.push({ code: placement, label: (description || area || placement || "").slice(0, 200), note });
maps.set(key, map);
}
return [...maps.values()].map((m) => ({ ...m, name: (m.name || m.code || "Karta").slice(0, 200) }));
}
+278
View File
@@ -0,0 +1,278 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { versionOf, versionOfOptional, type ConflictInfo } from "@/lib/conflict";
import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db";
const login = vi.hoisted(() => ({ userId: "" as string }));
vi.mock("@/auth", () => ({ auth: async () => (login.userId ? { user: { id: login.userId } } : null) }));
vi.mock("next/cache", () => ({ revalidatePath: () => undefined }));
vi.mock("next/navigation", () => ({
redirect: (to: string) => {
throw new Error(`REDIRECT:${to}`);
},
notFound: () => {
throw new Error("NOT_FOUND");
},
}));
vi.mock("@/i18n/server", async () => {
const core = await import("@/i18n/core");
return { getLocale: async () => "sv", getT: async () => ({ locale: "sv", t: core.makeT(core.dictionaries.sv) }) };
});
import { updateBook } from "@/actions/books";
import { createMarker, moveMarker, updateMarker } from "@/actions/maps";
import { resetTemplate, saveTemplate } from "@/actions/templates";
import { templateChanges } from "@/lib/template-diff";
const form = (fields: Record<string, string>) => {
const data = new FormData();
for (const [key, value] of Object.entries(fields)) data.append(key, value);
return data;
};
type Outcome = "saved" | { conflict: ConflictInfo };
async function outcome(run: () => Promise<{ conflict: ConflictInfo } | undefined | void>): Promise<Outcome> {
try {
const result = await run();
if (result && "conflict" in result) return result;
return "saved";
} catch (error) {
const message = error instanceof Error ? error.message : "";
if (message.startsWith("REDIRECT:")) return "saved";
throw error;
}
}
const fieldsJson = (...labels: string[]) => JSON.stringify(labels.map((label, i) => ({ key: `f${i}`, label, type: "text" })));
describeDb("skydd mot kolliderande ändringar: mallar, bokinställningar och kartmarkeringar", () => {
let ownerId: string;
let otherId: string;
let bookId: string;
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser("Ägare")).id;
otherId = (await makeUser("Kollega", "kollega@example.com")).id;
bookId = (await makeBook(ownerId, "Bok")).id;
await prisma.bookMember.create({ data: { bookId, userId: otherId, role: "ADMIN" } });
login.userId = ownerId;
});
describe("mallar", () => {
const save = (fields: string, version: string) => outcome(() => saveTemplate(form({ bookId, kind: "CHARACTER", fields, version })));
it("den första sparningen av en standardmall behöver ingen version", async () => {
expect(await save(fieldsJson("A"), versionOfOptional(null))).toBe("saved");
expect(await prisma.template.count({ where: { bookId } })).toBe(1);
});
it("sparar med rätt version och ger en ny", async () => {
await save(fieldsJson("A"), versionOfOptional(null));
const row = await prisma.template.findFirstOrThrow({ where: { bookId } });
expect(await save(fieldsJson("A", "B"), versionOf(row.updatedAt))).toBe("saved");
const after = await prisma.template.findFirstOrThrow({ where: { bookId } });
expect(versionOf(after.updatedAt)).not.toBe(versionOf(row.updatedAt));
expect(after.updatedById).toBe(ownerId);
});
it("avvisar en sparning med gammal version och visar vilka fält som skiljer", async () => {
await save(fieldsJson("A"), versionOfOptional(null));
const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt);
login.userId = otherId;
await save(fieldsJson("A", "Kollegans fält"), opened);
login.userId = ownerId;
const result = await save(fieldsJson("A", "Mitt fält"), opened);
expect(result).not.toBe("saved");
if (result === "saved") return;
expect(result.conflict.by).toBe("Kollega");
expect(result.conflict.changes).toEqual([{ label: "Mitt fält", before: "Kollegans fält (text)", after: "Mitt fält (text)" }]);
expect(((await prisma.template.findFirstOrThrow({ where: { bookId } })).fields as { label: string }[]).map((f) => f.label)).toEqual(["A", "Kollegans fält"]);
// Spara ändå med den nya versionen
expect(await save(fieldsJson("A", "Mitt fält"), (result.conflict as ConflictInfo).version)).toBe("saved");
expect(((await prisma.template.findFirstOrThrow({ where: { bookId } })).fields as { label: string }[]).map((f) => f.label)).toEqual(["A", "Mitt fält"]);
});
it("någon annan skapade mallen medan du tittade på standardmallen", async () => {
login.userId = otherId;
await save(fieldsJson("Kollegans"), versionOfOptional(null));
login.userId = ownerId;
const result = await save(fieldsJson("Min"), versionOfOptional(null));
expect(result).not.toBe("saved");
expect(await prisma.template.count({ where: { bookId } })).toBe(1);
});
it("någon annan återställde mallen till standard", async () => {
await save(fieldsJson("A"), versionOfOptional(null));
const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt);
login.userId = otherId;
await outcome(() => resetTemplate(form({ bookId, kind: "CHARACTER" })));
login.userId = ownerId;
const result = await save(fieldsJson("B"), opened);
expect(result).not.toBe("saved");
if (result === "saved") return;
expect(result.conflict.version).toBe("none");
expect(await save(fieldsJson("B"), "none")).toBe("saved");
});
it("av tre samtidiga sparningar med samma version går bara en igenom", async () => {
await save(fieldsJson("A"), versionOfOptional(null));
const opened = versionOf((await prisma.template.findFirstOrThrow({ where: { bookId } })).updatedAt);
const results = await Promise.all([1, 2, 3].map((n) => save(fieldsJson("A", `Från ${n}`), opened)));
expect(results.filter((r) => r === "saved")).toHaveLength(1);
expect(results.filter((r) => r !== "saved")).toHaveLength(2);
});
it("och tre som skapar mallen samtidigt", async () => {
const results = await Promise.all([1, 2, 3].map((n) => save(fieldsJson(`Skapad ${n}`), "none")));
expect(results.filter((r) => r === "saved")).toHaveLength(1);
expect(await prisma.template.count({ where: { bookId } })).toBe(1);
});
it("ogiltig mall sparas inte och ger ett fel, inte en krock", async () => {
expect(await save("[{\"key\":\"1fel\",\"label\":\"x\",\"type\":\"text\"}]", "none")).toBe("saved"); // redirect med felet
expect(await prisma.template.count({ where: { bookId } })).toBe(0);
});
});
describe("templateChanges", () => {
it("jämför på nyckel och beskriver typ, flera val och alternativ", () => {
const a = [{ key: "x", label: "Lokal", type: "reference" as const, refKind: "PREMISES" as const }, { key: "y", label: "Typ", type: "select" as const, options: ["a", "b"] }];
const b = [{ key: "x", label: "Lokal", type: "reference" as const, refKind: "PREMISES" as const, multiple: true }, { key: "z", label: "Ny", type: "text" as const }];
expect(templateChanges(a, b)).toEqual([
{ label: "Lokal", before: "Lokal (reference: PREMISES)", after: "Lokal (reference, flera: PREMISES)" },
{ label: "Typ", before: "Typ (select: a/b)", after: "" },
{ label: "Ny", before: "", after: "Ny (text)" },
]);
expect(templateChanges(a, a)).toEqual([]);
});
});
describe("bokinställningar", () => {
const save = (title: string, version: string) => outcome(() => updateBook(form({ bookId, title, subtitle: "", genre: "", description: "", version })));
it("sparar med rätt version, och sparar vem som ändrade", async () => {
const book = await prisma.book.findUniqueOrThrow({ where: { id: bookId } });
expect(await save("Ny titel", versionOf(book.updatedAt))).toBe("saved");
const after = await prisma.book.findUniqueOrThrow({ where: { id: bookId } });
expect(after).toMatchObject({ title: "Ny titel", updatedById: ownerId });
expect(versionOf(after.updatedAt)).not.toBe(versionOf(book.updatedAt));
});
it("avvisar en sparning med gammal version och visar skillnaderna med namn", async () => {
const opened = versionOf((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).updatedAt);
login.userId = otherId;
await save("Kollegans titel", opened);
login.userId = ownerId;
const result = await save("Min titel", opened);
expect(result).not.toBe("saved");
if (result === "saved") return;
expect(result.conflict.by).toBe("Kollega");
expect(result.conflict.changes).toEqual([{ label: "Titel", before: "Kollegans titel", after: "Min titel" }]);
expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Kollegans titel");
expect(await save("Min titel", result.conflict.version)).toBe("saved");
expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Min titel");
});
it("tre samtidiga sparningar: en går igenom", async () => {
const opened = versionOf((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).updatedAt);
const results = await Promise.all([1, 2, 3].map((n) => save(`Titel ${n}`, opened)));
expect(results.filter((r) => r === "saved")).toHaveLength(1);
});
});
describe("kartmarkeringar", () => {
let mapId: string;
let markerId: string;
const input = (label: string, extra: { lat?: number; lng?: number; note?: string } = {}) => ({ label, note: extra.note ?? "", color: "blue", entityId: null, lat: extra.lat ?? 59.3, lng: extra.lng ?? 18.0 });
beforeEach(async () => {
mapId = (await prisma.bookMap.create({ data: { bookId, name: "Karta", kind: "GEO" } })).id;
markerId = (await prisma.marker.create({ data: { mapId, label: "Hus", lat: 59.3, lng: 18.0 } })).id;
});
const version = async () => versionOf((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).updatedAt);
it("uppdatering med rätt version lyckas och ger en ny version", async () => {
const result = await updateMarker(bookId, mapId, markerId, input("Villa"), await version());
expect(result).toHaveProperty("version");
const after = await prisma.marker.findUniqueOrThrow({ where: { id: markerId } });
expect(after).toMatchObject({ label: "Villa", updatedById: ownerId });
expect((result as { version: string }).version).toBe(versionOf(after.updatedAt));
});
it("en gammal version ger en krock med skillnader, och ändrar ingenting", async () => {
const opened = await version();
login.userId = otherId;
await updateMarker(bookId, mapId, markerId, input("Kollegans", { note: "Anteckning" }), opened);
login.userId = ownerId;
const result = await updateMarker(bookId, mapId, markerId, input("Mitt"), opened);
expect(result).toHaveProperty("conflict");
const { conflict } = result as { conflict: ConflictInfo };
expect(conflict.by).toBe("Kollega");
expect(conflict.changes).toEqual(expect.arrayContaining([{ label: "Etikett", before: "Kollegans", after: "Mitt" }, { label: "Anteckning", before: "Anteckning", after: "" }]));
expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).label).toBe("Kollegans");
expect(await updateMarker(bookId, mapId, markerId, input("Mitt"), conflict.version)).toHaveProperty("version");
expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).label).toBe("Mitt");
});
it("att flytta en markering som ändrats av någon annan sparar inte flytten", async () => {
const opened = await version();
login.userId = otherId;
await updateMarker(bookId, mapId, markerId, input("Kollegans"), opened);
login.userId = ownerId;
const result = await moveMarker(bookId, mapId, markerId, 60, 19, opened);
expect(result).toHaveProperty("conflict");
expect(await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).toMatchObject({ lat: 59.3, lng: 18 });
});
it("en lyckad flytt ger en version som går att använda direkt efteråt", async () => {
const moved = await moveMarker(bookId, mapId, markerId, 60, 19, await version());
expect(moved).toHaveProperty("version");
expect(await updateMarker(bookId, mapId, markerId, input("Efter flytt", { lat: 60, lng: 19 }), (moved as { version: string }).version)).toHaveProperty("version");
});
it("en borttagen markering ger gone", async () => {
const opened = await version();
await prisma.marker.delete({ where: { id: markerId } });
expect(await updateMarker(bookId, mapId, markerId, input("Spöke"), opened)).toEqual({ gone: true });
expect(await moveMarker(bookId, mapId, markerId, 1, 1, opened)).toEqual({ gone: true });
});
it("av tre samtidiga ändringar med samma version går en igenom", async () => {
const opened = await version();
const results = await Promise.all([1, 2, 3].map((n) => updateMarker(bookId, mapId, markerId, input(`Från ${n}`), opened)));
expect(results.filter((r) => "version" in r)).toHaveLength(1);
expect(results.filter((r) => "conflict" in r)).toHaveLength(2);
});
it("utan version kontrolleras inget (som förut)", async () => {
expect(await updateMarker(bookId, mapId, markerId, input("Utan version"))).toHaveProperty("version");
});
it("nya markeringar får ID och vem som skapade dem", async () => {
await createMarker(bookId, mapId, input("Ny"));
const created = await prisma.marker.findFirstOrThrow({ where: { label: "Ny" } });
expect(created.code).toMatch(/^PI-/);
expect(created.updatedById).toBe(ownerId);
});
it("en markering i en annan bok kan inte ändras", async () => {
const otherBook = await makeBook(ownerId, "Annan");
const foreignMap = await prisma.bookMap.create({ data: { bookId: otherBook.id, name: "K", kind: "GEO" } });
const foreign = await prisma.marker.create({ data: { mapId: foreignMap.id, label: "Främmande", lat: 1, lng: 1 } });
expect(await updateMarker(bookId, mapId, foreign.id, input("Kapad"))).toEqual({ gone: true });
expect((await prisma.marker.findUniqueOrThrow({ where: { id: foreign.id } })).label).toBe("Främmande");
});
it("kopplingen till en post i boken behålls vid uppdatering", async () => {
const entity = await makeEntity(bookId, "PREMISES", "Lokal");
await updateMarker(bookId, mapId, markerId, { ...input("Med koppling"), entityId: entity.id });
expect((await prisma.marker.findUniqueOrThrow({ where: { id: markerId } })).entityId).toBe(entity.id);
});
});
});
+106
View File
@@ -0,0 +1,106 @@
import { beforeEach, expect, it } from "vitest";
import { buildExport, importBook } from "@/lib/book-transfer";
import { collectFieldData } from "@/lib/field-values";
import { getDefaultTemplate, getTemplate, refIds, validateFields, type FieldDef } from "@/lib/templates";
import { restoreEntity, trashEntity } from "@/lib/trash";
import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db";
const form = (fields: Record<string, string | string[]>) => {
const data = new FormData();
for (const [key, value] of Object.entries(fields)) for (const v of Array.isArray(value) ? value : [value]) data.append(key, v);
return data;
};
describeDb("flera val i kopplingsfält", () => {
let ownerId: string;
let bookId: string;
let cafe: { id: string };
let bar: { id: string };
let person: { id: string };
const premisesField: FieldDef = { key: "premises", label: "Lokal", type: "reference", refKind: "PREMISES", multiple: true };
const single: FieldDef = { key: "premises", label: "Lokal", type: "reference", refKind: "PREMISES" };
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser()).id;
bookId = (await makeBook(ownerId)).id;
cafe = await makeEntity(bookId, "PREMISES", "Café");
bar = await makeEntity(bookId, "PREMISES", "Bar");
person = await makeEntity(bookId, "CHARACTER", "Anna");
});
it("refIds läser både ett id och en lista", () => {
expect(refIds("a")).toEqual(["a"]);
expect(refIds(["a", "b", "a", "", 5])).toEqual(["a", "b"]);
expect(refIds("")).toEqual([]);
expect(refIds(undefined)).toEqual([]);
expect(refIds(7)).toEqual([]);
});
it("standardmallarna tillåter flera lokaler och skisser där det passar", () => {
const multiple = (kind: Parameters<typeof getDefaultTemplate>[0], key: string) => getDefaultTemplate(kind, "sv").find((f) => f.key === key)?.multiple === true;
expect(multiple("COMPANY", "premises")).toBe(true);
expect(multiple("COMPANY", "sketch")).toBe(true);
expect(multiple("EDUCATION", "premises")).toBe(true);
expect(multiple("HOME", "sketch")).toBe(true);
expect(multiple("VEHICLE", "owner")).toBe(false); // ett fordon har en ägare
expect(multiple("SCENARIO", "linkedEntity")).toBe(false);
});
it("flera val sparas som en lista, utan dubbletter, och bara poster i boken av rätt typ", async () => {
const otherBook = await makeBook(ownerId, "Annan");
const foreign = await makeEntity(otherBook.id, "PREMISES", "Främmande");
const data = await collectFieldData(bookId, [premisesField], form({ f_premises: [cafe.id, bar.id, cafe.id, foreign.id, person.id, "finns-inte", ""] }), null);
expect(data.premises).toEqual([cafe.id, bar.id]);
});
it("inga val tar bort fältet", async () => {
expect(await collectFieldData(bookId, [premisesField], form({}), { premises: [cafe.id], annat: 1 })).toEqual({ annat: 1 });
expect(await collectFieldData(bookId, [premisesField], form({ f_premises: ["finns-inte"] }), null)).toEqual({});
});
it("ett äldre värde med ett id i ett fält som nu tillåter flera blir en lista", async () => {
const data = await collectFieldData(bookId, [{ key: "other", label: "X", type: "text" }, premisesField], form({ f_premises: [cafe.id] }), { premises: cafe.id });
expect(data.premises).toEqual([cafe.id]);
// Ett värde som lämnas orört i data för ett fält som inte skickas med formuläret tas inte bort av kontrollen
const kept = await collectFieldData(bookId, [{ key: "other", label: "X", type: "text" }], form({}), { premises: [cafe.id, bar.id] });
expect(kept.premises).toEqual([cafe.id, bar.id]);
});
it("ett fält med ett val som tidigare hade flera behåller bara det första", async () => {
// Kopplingskontrollen kör för alla kopplingsfält i mallen, även när formuläret inte skickar något
const data = await collectFieldData(bookId, [single], form({ f_premises: bar.id }), { premises: [cafe.id, bar.id] });
expect(data.premises).toBe(bar.id);
});
it("ett fält med ett val sparar ett id som förut", async () => {
expect((await collectFieldData(bookId, [single], form({ f_premises: cafe.id }), null)).premises).toBe(cafe.id);
expect((await collectFieldData(bookId, [single], form({ f_premises: person.id }), null)).premises).toBeUndefined();
});
it("mallens flera val sparas och läses från bokens egen mall", async () => {
expect(validateFields([{ key: "a", label: "A", type: "reference", multiple: true }])[0].multiple).toBe(true);
expect(validateFields([{ key: "a", label: "A", type: "text", multiple: true }])[0].multiple).toBeUndefined();
expect(validateFields([{ key: "a", label: "A", type: "reference", multiple: "ja" }])[0].multiple).toBeUndefined();
await prisma.template.create({ data: { bookId, kind: "COMPANY", fields: [premisesField as unknown as object] } });
expect((await getTemplate(bookId, "COMPANY", "sv")).fields[0].multiple).toBe(true);
});
it("export och import pekar om alla poster i listan", async () => {
const company = await makeEntity(bookId, "COMPANY", "Firma", { data: { premises: [cafe.id, bar.id] } });
const { data, files } = await buildExport(bookId, false);
const result = await importBook(ownerId, data, files);
const copy = await prisma.entity.findMany({ where: { bookId: result.bookId } });
const byName = Object.fromEntries(copy.map((e) => [e.name, e]));
expect((byName.Firma.data as { premises: string[] }).premises).toEqual([byName["Café"].id, byName.Bar.id]);
expect(company.id).not.toBe(byName.Firma.id);
});
it("en post i papperskorgen kommer tillbaka med sina listor", async () => {
const company = await makeEntity(bookId, "COMPANY", "Firma", { data: { premises: [cafe.id, bar.id] } });
await trashEntity(ownerId, bookId, company.id);
const [item] = await prisma.trashItem.findMany();
await restoreEntity(ownerId, item.id);
expect((await prisma.entity.findUniqueOrThrow({ where: { id: company.id } })).data).toEqual({ premises: [cafe.id, bar.id] });
});
});
+97
View File
@@ -0,0 +1,97 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import { OLD_YEARS_MARKER, getGivenNames } from "@/lib/name-stats";
import { describeDb, prisma, resetAll } from "../helpers/db";
/** Ett svar från SCB: ett namn och ett år per rad. */
const scb = (rows: Record<string, Record<number, number>>) => ({
ok: true,
status: 200,
text: async () =>
JSON.stringify({
data: Object.entries(rows).flatMap(([name, years]) => Object.entries(years).map(([year, n]) => ({ key: [name, year], values: [String(n)] }))),
}),
});
describeDb("namnstatistik för äldre år", () => {
const calls: string[] = [];
beforeEach(async () => {
await resetAll();
calls.length = 0;
});
afterEach(() => vi.unstubAllGlobals());
const stub = (handler: (url: string) => unknown) =>
vi.stubGlobal(
"fetch",
vi.fn(async (url: string) => {
calls.push(url);
return handler(url);
}),
);
it("slår ihop tilltalsnamn och förnamn och sparar resultatet", async () => {
stub((url) =>
url.includes("BE0001F100")
? scb({ "1Anders": { 1960: 500 }, "1Gösta": { 1958: 30, 1960: 20, 1961: 10 } })
: scb({ "1Anders": { 1960: 300 }, "1Rune": { 1959: 40 } }),
);
const result = await getGivenNames("male", 1960);
expect(result.year).toBe(1960);
expect(result.source).toContain(OLD_YEARS_MARKER);
expect(Object.fromEntries(result.entries)).toEqual({ Anders: 300, Gösta: 20, Rune: 10 });
// Båda tabellerna hämtades i ett enda anrop var, med flera år
expect(calls).toHaveLength(2);
expect(calls.some((u) => u.includes("BE0001T100"))).toBe(true);
expect(calls.some((u) => u.includes("BE0001F100"))).toBe(true);
});
it("använder det sparade nästa gång utan att fråga SCB igen", async () => {
stub(() => scb({ "2Anna": { 1960: 100 } }));
await getGivenNames("female", 1960);
const before = calls.length;
const again = await getGivenNames("female", 1960);
expect(again.entries).toEqual([["Anna", 100]]);
expect(calls).toHaveLength(before);
});
it("hämtar om en lista som byggts på det gamla sättet", async () => {
await prisma.nameStat.create({ data: { kind: "given-female", year: 1960, source: "SCB, födda 1960", entries: [["Gammal", 5]] } });
stub(() => scb({ "2Anna": { 1960: 100 } }));
const result = await getGivenNames("female", 1960);
expect(result.entries).toEqual([["Anna", 100]]);
expect((await prisma.nameStat.findUniqueOrThrow({ where: { kind_year: { kind: "given-female", year: 1960 } } })).source).toContain(OLD_YEARS_MARKER);
});
it("behåller en gammal lista när SCB inte svarar", async () => {
await prisma.nameStat.create({ data: { kind: "given-female", year: 1960, source: "SCB, födda 1960", entries: [["Gammal", 5]] } });
stub(() => {
throw new Error("ingen kontakt");
});
expect((await getGivenNames("female", 1960)).entries).toEqual([["Gammal", 5]]);
});
it("kastar när SCB inte svarar och inget finns sparat", async () => {
stub(() => {
throw new Error("ingen kontakt");
});
await expect(getGivenNames("female", 1960)).rejects.toThrow("ingen kontakt");
});
it("frågar bara efter år som finns i statistiken", async () => {
stub(() => scb({ "1Karl": { 1922: 10, 1923: 12, 1924: 9 } }));
await getGivenNames("male", 1922);
const body = (init: RequestInit | undefined) => JSON.parse(String(init?.body)) as { query: { code: string; selection: { values: string[] } }[] };
const fetchMock = fetch as unknown as ReturnType<typeof vi.fn>;
const years = body(fetchMock.mock.calls[0][1]).query.find((q) => q.code === "Tid")!.selection.values;
expect(years).toEqual(["1922", "1923", "1924"]);
});
it("årtal efter 1997 hämtas som förut, från nyfödda", async () => {
stub(() => scb({ "Olivia": { 2005: 700 } }));
const result = await getGivenNames("female", 2005);
expect(result.source).toBe("SCB, nyfödda 2005");
expect(calls).toHaveLength(1);
expect(calls[0]).toContain("BE0001Nyfodda");
});
});
+239
View File
@@ -0,0 +1,239 @@
import { beforeEach, describe, expect, it } from "vitest";
import { nextMapCode, nextMarkerCode, nextScheduleCode } from "@/lib/ids";
import { commitWordImport, previewWordFiles, type CommitMap } from "@/lib/word-import-db";
import { makeDocx, para, table } from "../helpers/docx";
import { describeDb, makeBook, makeEntity, makeUser, prisma, resetAll } from "../helpers/db";
const bytes = (doc: Uint8Array) => ({ name: "doc.docx", bytes: doc });
describeDb("import från Word: scheman och kartregister", () => {
let ownerId: string;
let bookId: string;
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser()).id;
bookId = (await makeBook(ownerId)).id;
});
describe("scheman", () => {
const grid = (cells: [number, number, string][], code = "Schema: Schema ID: SCI-0009") => {
const days = ["Tid:", "Måndag:", "Tisdag:", "Onsdag:", "Torsdag:", "Fredag:", "Lördag:", "Söndag:"];
const rows = ["06:00", "07:00", "08:00", "09:00", "10:00", "11:00", "12:00"].map((t) => [t, "", "", "", "", "", "", ""]);
for (const [r, c, v] of cells) rows[r][c] = v;
return makeDocx([para(code), table(days, ...rows)]);
};
const register = (rows: string[][]) => makeDocx([table(["Schema ID:", "Karaktärs ID:", "Företags/utbildnings ID:", "Dag/natt:"], ...rows, ["", "", "", ""])]);
const shiftsOf = () => prisma.shift.findMany({ where: { bookId }, orderBy: [{ weekday: "asc" }, { startTime: "asc" }] });
const commit = (schedules: Parameters<typeof commitWordImport>[3]["schedules"]) => commitWordImport(bookId, ownerId, [], { appendUnmatched: false, schedules });
it("schemaregistret i samma uppladdning ger scheman person och arbetsplats", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const firma = await makeEntity(bookId, "COMPANY", "Firma");
const docs = await previewWordFiles(bookId, [
bytes(grid([[2, 1, "Arbete"], [3, 1, "Arbete"]])),
bytes(register([["SCI-0009", anna.code!, firma.code!, "Dag: X Natt:"]])),
]);
expect(docs[0].kind).toBe("SCHEDULE");
expect(docs[0].schedule).toMatchObject({ code: "SCI-0009", personId: anna.id, workplaceId: firma.id, source: "register", existing: 0 });
expect(docs[0].schedule?.shifts).toEqual([{ weekday: 0, startTime: "08:00", endTime: "10:00", label: "Arbete" }]);
expect(docs[1].scheduleRows[0]).toMatchObject({ code: "SCI-0009", personId: anna.id, workplaceId: firma.id });
});
it("ett schema med ett Schema-ID som redan finns i boken får samma person och arbetsplats, och antal befintliga pass", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const firma = await makeEntity(bookId, "COMPANY", "Firma");
await prisma.shift.create({ data: { bookId, personId: anna.id, workplaceId: firma.id, weekday: 2, startTime: "08:00", endTime: "16:00", scheduleCode: "SCI-0009" } });
const [doc] = await previewWordFiles(bookId, [bytes(grid([[2, 1, "X"]]))]);
expect(doc.schedule).toMatchObject({ personId: anna.id, workplaceId: firma.id, source: "existing", existing: 1 });
});
it("utan känt Schema-ID får personen väljas, och inget är förvalt", async () => {
const [doc] = await previewWordFiles(bookId, [bytes(grid([[2, 1, "X"]], "Schema: Schema ID:____"))]);
expect(doc.schedule).toMatchObject({ code: null, personId: null, workplaceId: null, source: null });
});
it("sparar pass för vald person och arbetsplats med dokumentets Schema-ID", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const firma = await makeEntity(bookId, "COMPANY", "Firma");
const result = await commit([
{
include: true,
code: "SCI-0009",
personId: anna.id,
workplaceId: firma.id,
replace: false,
shifts: [
{ weekday: 0, startTime: "08:00", endTime: "16:00", label: "Arbete" },
{ weekday: 1, startTime: "18:00", endTime: "06:00", label: null },
],
},
]);
expect(result).toMatchObject({ shifts: 2 });
expect((await shiftsOf()).map((s) => [s.weekday, s.startTime, s.endTime, s.label, s.scheduleCode, s.weeks])).toEqual([
[0, "08:00", "16:00", "Arbete", "SCI-0009", "ALL"],
[1, "18:00", "06:00", null, "SCI-0009", "ALL"],
]);
// Räknaren har flyttats förbi det importerade ID:t
expect(await nextScheduleCode(bookId)).toBe("SCI-0010");
});
it("samma person och arbetsplats behåller sitt Schema-ID, och pass som redan finns läggs inte till igen", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
await prisma.shift.create({ data: { bookId, personId: anna.id, workplaceId: null, weekday: 0, startTime: "08:00", endTime: "16:00", scheduleCode: "SCI-0003" } });
const result = await commit([
{
include: true,
code: "SCI-0099",
personId: anna.id,
workplaceId: null,
replace: false,
shifts: [
{ weekday: 0, startTime: "08:00", endTime: "16:00", label: null },
{ weekday: 3, startTime: "09:00", endTime: "12:00", label: null },
],
},
]);
expect(result.shifts).toBe(1);
expect((await shiftsOf()).map((s) => [s.weekday, s.scheduleCode])).toEqual([[0, "SCI-0003"], [3, "SCI-0003"]]);
});
it("kan ersätta personens befintliga pass hos arbetsplatsen, men bara hos den", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const firma = await makeEntity(bookId, "COMPANY", "Firma");
const annat = await makeEntity(bookId, "COMPANY", "Annat");
await prisma.shift.createMany({
data: [
{ bookId, personId: anna.id, workplaceId: firma.id, weekday: 0, startTime: "08:00", endTime: "16:00", scheduleCode: "SCI-0001" },
{ bookId, personId: anna.id, workplaceId: annat.id, weekday: 1, startTime: "08:00", endTime: "16:00", scheduleCode: "SCI-0002" },
],
});
await commit([{ include: true, code: null, personId: anna.id, workplaceId: firma.id, replace: true, shifts: [{ weekday: 4, startTime: "10:00", endTime: "14:00", label: null }] }]);
expect((await shiftsOf()).map((s) => [s.weekday, s.workplaceId === firma.id ? "firma" : "annat"])).toEqual([
[1, "annat"],
[4, "firma"],
]);
});
it("avvisar ogiltiga personer, arbetsplatser och pass", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const sketch = await makeEntity(bookId, "SKETCH", "Skiss");
const other = await makeBook(ownerId, "Annan");
const foreign = await makeEntity(other.id, "CHARACTER", "Främling");
const ok = { weekday: 0, startTime: "08:00", endTime: "16:00", label: null };
const result = await commit([
{ include: true, code: null, personId: foreign.id, workplaceId: null, replace: false, shifts: [ok] }, // person i en annan bok
{ include: true, code: null, personId: null, workplaceId: null, replace: false, shifts: [ok] }, // ingen person
{ include: true, code: null, personId: anna.id, workplaceId: null, replace: false, shifts: [{ ...ok, weekday: 7 }, { ...ok, startTime: "25:00" }, { ...ok, endTime: "08:00" }] }, // bara ogiltiga pass
{ include: false, code: null, personId: anna.id, workplaceId: null, replace: false, shifts: [ok] }, // bortvald
{ include: true, code: null, personId: anna.id, workplaceId: sketch.id, replace: false, shifts: [{ ...ok, weekday: 2 }] }, // arbetsplats av fel typ: pass utan arbetsplats
]);
expect(result.shifts).toBe(1);
expect(result.skipped).toBe(3);
const [only] = await shiftsOf();
expect(only).toMatchObject({ weekday: 2, workplaceId: null });
});
it("ett Schema-ID som används av en annan får personen ett nytt", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const bo = await makeEntity(bookId, "CHARACTER", "Bo");
await prisma.shift.create({ data: { bookId, personId: bo.id, workplaceId: null, weekday: 0, startTime: "08:00", endTime: "09:00", scheduleCode: "SCI-0005" } });
await commit([{ include: true, code: "SCI-0005", personId: anna.id, workplaceId: null, replace: false, shifts: [{ weekday: 1, startTime: "08:00", endTime: "09:00", label: null }] }]);
const codes = (await prisma.shift.findMany({ where: { personId: anna.id } })).map((s) => s.scheduleCode);
expect(codes).toHaveLength(1);
expect(codes[0]).not.toBe("SCI-0005");
});
});
describe("kartregister", () => {
const map = (overrides: Partial<CommitMap> = {}): CommitMap => ({
include: true,
code: "KD-R_0005",
name: "Lund",
kind: "GEO",
markers: [
{ code: "PI-0007", label: "Kaféet", note: "Vid torget" },
{ code: null, label: "Biblioteket", note: null },
],
...overrides,
});
const commitMaps = (maps: CommitMap[]) => commitWordImport(bookId, ownerId, [], { appendUnmatched: false, maps });
it("skapar kartor med markeringar i kartans mitt, och behåller lediga ID", async () => {
expect(await commitMaps([map()])).toMatchObject({ maps: 1, markers: 2 });
const created = await prisma.bookMap.findFirstOrThrow({ where: { bookId }, include: { markers: { orderBy: { code: "asc" } } } });
expect(created).toMatchObject({ name: "Lund", kind: "GEO", code: "KD-R_0005", zoom: 11 });
expect(created.centerLat).toBeCloseTo(59.3293);
expect(created.markers.map((m) => [m.code, m.label, m.note])).toEqual([
["PI-0007", "Kaféet", "Vid torget"],
["PI-0008", "Biblioteket", null],
]);
// Markeringarna ligger på olika ställen så att de går att dra isär
expect(new Set(created.markers.map((m) => `${m.lat},${m.lng}`)).size).toBe(2);
expect(created.markers.every((m) => m.updatedById === ownerId)).toBe(true);
});
it("räknarna fortsätter efter de importerade ID:na", async () => {
await commitMaps([map()]);
expect(await nextMapCode(bookId, "GEO")).toBe("KD-R_0006");
expect(await nextMarkerCode(bookId)).toBe("PI-0009");
});
it("ett ID som redan används ger ett nytt, och bildkartor och namnlösa kartor hoppas över", async () => {
await commitMaps([map()]);
const result = await commitMaps([map(), map({ kind: "IMAGE", code: "KD-E_0001" }), map({ name: " " }), map({ include: false })]);
expect(result).toMatchObject({ maps: 1, skipped: 2 });
const codes = (await prisma.bookMap.findMany({ where: { bookId } })).map((m) => m.code);
expect(new Set(codes).size).toBe(2);
const markerCodes = (await prisma.marker.findMany({ where: { map: { bookId } } })).map((m) => m.code);
expect(new Set(markerCodes).size).toBe(markerCodes.length);
});
it("hoppar över ID som redan används även när räknaren ligger efter", async () => {
// Poster som lagts in utan räknaren (för hand eller av en äldre version)
const existing = await prisma.bookMap.create({ data: { bookId, name: "Befintlig", kind: "GEO", code: "KD-R_0001" } });
await prisma.marker.create({ data: { mapId: existing.id, label: "Gammal", code: "PI-0001", lat: 1, lng: 1 } });
await prisma.entity.create({ data: { bookId, kind: "CHARACTER", name: "Gammal", code: "KI-0001" } });
await prisma.shift.create({ data: { bookId, personId: (await prisma.entity.findFirstOrThrow({ where: { bookId } })).id, weekday: 0, startTime: "08:00", endTime: "09:00", scheduleCode: "SCI-0001" } });
const result = await commitWordImport(
bookId,
ownerId,
[{ include: true, entityKind: "CHARACTER", name: "Ny", code: null, data: {}, links: [], unmatched: [] }],
{ appendUnmatched: false, maps: [map({ code: null, markers: [{ code: null, label: "Ny markering", note: null }] })] },
);
expect(result).toMatchObject({ created: 1, maps: 1, markers: 1 });
expect((await prisma.bookMap.findMany({ where: { bookId }, orderBy: { code: "asc" } })).map((m) => m.code)).toEqual(["KD-R_0001", "KD-R_0002"]);
expect((await prisma.marker.findMany({ where: { map: { bookId } }, orderBy: { code: "asc" } })).map((m) => m.code)).toEqual(["PI-0001", "PI-0002"]);
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Ny" } })).code).toBe("KI-0002");
// Och samma för ett nytt schema
const bo = await prisma.entity.create({ data: { bookId, kind: "CHARACTER", name: "Bo", code: "KI-0003" } });
await commitWordImport(bookId, ownerId, [], {
appendUnmatched: false,
schedules: [{ include: true, code: null, personId: bo.id, workplaceId: null, replace: false, shifts: [{ weekday: 1, startTime: "08:00", endTime: "09:00", label: null }] }],
});
expect((await prisma.shift.findFirstOrThrow({ where: { personId: bo.id } })).scheduleCode).toBe("SCI-0002");
});
it("hoppar över markeringar utan etikett och kortar för långa texter", async () => {
await commitMaps([map({ markers: [{ code: null, label: "", note: null }, { code: null, label: "x".repeat(500), note: "y".repeat(9000) }] })]);
const [marker] = await prisma.marker.findMany({ where: { map: { bookId } } });
expect(marker.label).toHaveLength(200);
expect(marker.note).toHaveLength(5000);
});
it("förhandsgranskningen visar vilka kartor som redan finns", async () => {
await prisma.bookMap.create({ data: { bookId, name: "Befintlig", kind: "GEO", code: "KD-R_0001" } });
const doc = makeDocx([
table(["Kart ID:", "Placerings ID:", "Stad/Område:", "Beskrivning:", "Övrigt:"], ["KD-R_0001", "PI-0001", "Lund", "Kaféet", ""], ["KD-R_0002", "", "Malmö", "", ""], ["", "", "", "", ""]),
]);
const [preview] = await previewWordFiles(bookId, [bytes(doc)]);
expect(preview.kind).toBe("MAP_REGISTER");
expect(preview.maps.map((m) => [m.code, m.exists])).toEqual([
["KD-R_0001", true],
["KD-R_0002", false],
]);
});
});
});
+9
View File
@@ -191,6 +191,15 @@ describeDb("import från Word", () => {
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Firma" } })).data).toEqual({ industry: "Kaffe", hasSketches: true });
});
it("flera lokaler sparas som en lista, bara de som finns i boken", async () => {
const a = await makeEntity(bookId, "PREMISES", "A");
const b = await makeEntity(bookId, "PREMISES", "B");
const other = await makeBook(ownerId, "Annan");
const foreign = await makeEntity(other.id, "PREMISES", "Främmande");
await commit([item({ entityKind: "COMPANY", name: "Firma", code: null, data: { premises: [a.id, b.id, foreign.id, "finns-inte"] } })]);
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Firma" } })).data).toEqual({ premises: [a.id, b.id] });
});
it("okända dokumenttyper och trasiga poster hoppas över utan att stoppa resten", async () => {
const result = await commit([item({ entityKind: "FINNS_INTE" }), null as unknown as CommitItem, item({ name: "Ok", code: null })]);
expect(result.created).toBe(1);
+42
View File
@@ -0,0 +1,42 @@
import { describe, expect, it } from "vitest";
import { blendOldYear } from "@/lib/name-stats";
const table = (data: Record<number, Record<string, number>>) => new Map(Object.entries(data).map(([year, names]) => [Number(year), new Map(Object.entries(names))]));
describe("blendOldYear", () => {
it("tar tilltalsnamn i första hand och förnamn för namn som bara finns där", () => {
const tilltal = table({ 1960: { Anna: 100, Eva: 50 } });
const fornamn = table({ 1960: { Anna: 180, Märta: 40, Eva: 90 } });
expect(blendOldYear(1960, tilltal, fornamn)).toEqual([
["Anna", 100],
["Eva", 50],
["Märta", 40],
]);
});
it("namn utan bärare det året får en liten andel av grannåren", () => {
const tilltal = table({ 1958: { Rune: 40 }, 1959: { Rune: 60 }, 1960: { Rune: 0, Anna: 10 }, 1961: { Rune: 20 }, 1962: {} });
const result = Object.fromEntries(blendOldYear(1960, tilltal, new Map()));
// (40 + 60 + 20) * 0,25 = 30
expect(result).toEqual({ Rune: 30, Anna: 10 });
});
it("ger minst 1 till ett namn som finns i något grannår", () => {
const tilltal = table({ 1959: { Sällsynt: 1 }, 1960: { Anna: 10 } });
expect(Object.fromEntries(blendOldYear(1960, tilltal, new Map())).Sällsynt).toBe(1);
});
it("grannår längre bort än två år räknas inte", () => {
const tilltal = table({ 1956: { Gammal: 500 }, 1960: { Anna: 10 }, 1964: { Ung: 500 } });
expect(Object.fromEntries(blendOldYear(1960, tilltal, new Map()))).toEqual({ Anna: 10 });
});
it("namn som aldrig förekommer tas inte med, och listan sorteras på antal", () => {
const tilltal = table({ 1960: { B: 5, A: 5, C: 9, D: 0 } });
expect(blendOldYear(1960, tilltal, new Map()).map(([name]) => name)).toEqual(["C", "A", "B"]);
});
it("tomma tabeller ger en tom lista", () => {
expect(blendOldYear(1960, new Map(), new Map())).toEqual([]);
});
});
+1 -1
View File
@@ -101,7 +101,7 @@ describe.skipIf(!available)("ifyllda riktiga mallar", () => {
const { doc, item } = analyze(blocks, "foretag.docx");
expect(doc.kind).toBe("COMPANY");
expect(item).toMatchObject({ name: "Lunds Kaffe", code: "FI-0003" });
expect(item.data).toMatchObject({ industry: "Kaffe", premises: "l1", hasSketches: true, alcohol: true, satisfaction: "Bra", workEnvironment: "Trevlig." });
expect(item.data).toMatchObject({ industry: "Kaffe", premises: ["l1"], hasSketches: true, alcohol: true, satisfaction: "Bra", workEnvironment: "Trevlig." });
expect(item.links).toEqual([{ type: "Jobbar på", toDocument: true, entityId: "k1", text: "Anna Lind KI-0001", note: "Barista" }]);
});
+45 -11
View File
@@ -385,7 +385,7 @@ describe("företag", () => {
expect(item.data).toEqual({
industry: "Kaffe",
hasSketches: true,
premises: "l1",
premises: ["l1"],
workplaceForCharacters: true,
socialPlace: false,
bossCares: true,
@@ -397,6 +397,35 @@ describe("företag", () => {
});
});
describe("flera lokaler i ett kopplingsfält", () => {
const more: KnownEntity[] = [...known, { id: "l2", name: "Torget 3", code: "LI-0002", kind: "PREMISES" }];
const company = (value: string) => analyzeDocument([table(["Företags ID:", ""], ["Företagets namn:", "Kaffe AB"], ["Lokal ID:", value])], "f.docx", more).items[0];
it("ger en lista med alla som hittas", () => {
const item = company("Café Lund LI-0001, Torget 3 LI-0002");
expect(item.data.premises).toEqual(["l1", "l2"]);
expect(item.display.premises).toBe("LI-0001 · Café Lund, LI-0002 · Torget 3");
expect(item.unmatched).toEqual([]);
});
it("rapporterar de som inte hittas och behåller resten", () => {
const item = company("LI-0001, Okänd lokal");
expect(item.data.premises).toEqual(["l1"]);
expect(item.unmatched).toEqual([{ label: "Lokal ID", value: "Okänd lokal" }]);
});
it("inget hittat ger ingen koppling och hamnar bland det som inte tolkats", () => {
const item = company("Okänd lokal");
expect(item.data.premises).toBeUndefined();
expect(item.unmatched).toEqual([{ label: "Lokal ID", value: "Okänd lokal" }]);
});
it("ett fält med ett val tar bara en post", () => {
const item = analyzeDocument([table(["Fordons ID:", ""], ["Märke och modell:", "Volvo"], ["Ägare:", "Anna Lind KI-0001"])], "v.docx", more).items[0];
expect(item.data.owner).toBe("k1");
});
});
describe("lokal och utbildning", () => {
it("lokalens eget ID är dess ID, inte en koppling", () => {
const doc = analyze([table(["Lokal ID:", "LI-0005", "Adress:", "Torget 3"], ["Placerings ID:", "PI-0001", "Branschanpassning:", "Café"], ["Antal rum:", "2", "Yta:", "40", "Ägande:", "Hyr: X Äga:"], ["Kyl och Frys:", "Ja: X Nej:", "Hiss:", "Ja: Nej: X"])]);
@@ -541,13 +570,15 @@ describe("register", () => {
expect(only(sites)).toMatchObject({ name: "Lunds kommun", data: { description: "Kommunens sida" } });
});
it("scheman och kartregister importeras inte", () => {
const schedule = analyze([para("Schema: Schema ID:___"), table(["Tid:", "Måndag:", "Tisdag:"], ["06:00", "", ""], ["07:00", "", ""])]);
expect(schedule).toMatchObject({ kind: null, warnings: ["unsupported"] });
it("scheman, schemaregister och kartregister känns igen, och är tomma när inget är ifyllt", () => {
const days = ["Tid:", "Måndag:", "Tisdag:", "Onsdag:", "Torsdag:", "Fredag:", "Lördag:", "Söndag:"];
const blank = (time: string) => [time, "", "", "", "", "", "", ""];
const schedule = analyze([para("Schema: Schema ID:___"), table(days, blank("06:00"), blank("07:00"))]);
expect(schedule).toMatchObject({ kind: "SCHEDULE", warnings: ["empty"] });
const scheduleRegister = analyze([table(["Schema ID:", "Karaktärs ID:", "Dag/natt:"], ["", "", "Dag: Natt:"], ["", "", "Dag: Natt:"])]);
expect(scheduleRegister).toMatchObject({ kind: null, warnings: ["unsupported"] });
expect(scheduleRegister).toMatchObject({ kind: "SCHEDULE_REGISTER", warnings: ["empty"] });
const maps = analyze([table(["Kart ID:", "Placerings ID:", "Stad/Område:"], ["", "", ""], ["", "", ""])]);
expect(maps).toMatchObject({ kind: null, warnings: ["unsupported"] });
expect(maps).toMatchObject({ kind: "MAP_REGISTER", warnings: ["empty"] });
});
});
@@ -615,15 +646,15 @@ describe("riktiga Word-filer", () => {
["Mall/Utbildningsmall.docx", "EDUCATION"],
["Mall/Scenariomall.docx", "SCENARIO"],
["Mall/Relationsmall.docx", "RELATION"],
["Mall/Schema dag.docx", null],
["Mall/Schema natt.docx", null],
["Mall/Schema dag.docx", "SCHEDULE"],
["Mall/Schema natt.docx", "SCHEDULE"],
["Register/Fordonsregister.docx", "VEHICLE"],
["Register/Referensregister.docx", "REFERENCE"],
["Register/Researchregister.docx", "RESEARCH"],
["Register/Appregister.docx", "APP"],
["Register/hemsideregister.docx", "WEBSITE"],
["Register/Kartregister.docx", null],
["Register/Schemaregister.docx", null],
["Register/Kartregister.docx", "MAP_REGISTER"],
["Register/Schemaregister.docx", "SCHEDULE_REGISTER"],
];
it.skipIf(!available).each(expected)("%s känns igen som %s", (path, kind) => {
@@ -631,6 +662,9 @@ describe("riktiga Word-filer", () => {
expect(doc.kind).toBe(kind);
// En blank mall ger inga poster med innehåll: mallens egna etiketter och frågor får inte tolkas som värden
expect(doc.items.filter((i) => Object.keys(i.data).length > 0 || i.unmatched.length > 0 || i.links.length > 0)).toEqual([]);
expect(doc.schedule?.shifts ?? []).toEqual([]);
expect(doc.scheduleRows).toEqual([]);
expect(doc.maps).toEqual([]);
});
it.skipIf(!available)("alla mallar går att läsa och tolka utan fel", () => {
@@ -662,7 +696,7 @@ describe("cleanData", () => {
},
entities as never,
);
expect(clean).toEqual({ industry: "Kaffe", premises: "l1", hasSketches: true, satisfaction: "Bra", hotelRooms: 10 });
expect(clean).toEqual({ industry: "Kaffe", premises: ["l1"], hasSketches: true, satisfaction: "Bra", hotelRooms: 10 });
});
it("avvisar fel sorts värden och kopplingar till fel typ eller okända poster", () => {
+286
View File
@@ -0,0 +1,286 @@
import { existsSync, readFileSync } from "node:fs";
import { describe, expect, it } from "vitest";
import { readDocx, type DocBlock } from "@/lib/word-docx";
import { analyzeDocument, type KnownEntity, type RegisterTable } from "@/lib/word-import";
import { findScheduleCode, isScheduleGrid, normalizeTime, parseMapRegister, parseScheduleGrid, parseScheduleRegister, weekdayOf } from "@/lib/word-schedule";
import { table } from "../helpers/docx";
const DAYS = ["Tid", "Måndag", "Tisdag", "Onsdag", "Torsdag", "Fredag", "Lördag", "Söndag"];
const grid = (rows: string[][]): RegisterTable => ({ header: DAYS, rows });
/** En rad i schemat: tiden och sju rutor, där `cells` fyller i de första. */
const row = (time: string, ...cells: string[]) => [time, ...Array.from({ length: 7 }, (_, i) => cells[i] ?? "")];
const known: KnownEntity[] = [
{ id: "k1", name: "Anna Lind", code: "KI-0001", kind: "CHARACTER" },
{ id: "c1", name: "Lunds Kaffe", code: "FI-0001", kind: "COMPANY" },
{ id: "u1", name: "Lunds skola", code: "UI-0001", kind: "EDUCATION" },
];
describe("weekdayOf och normalizeTime", () => {
it("känner igen veckodagar, hela och förkortade", () => {
expect(["Måndag:", "tis", "ONSDAG", "Tors", "Fre", "Lördag", "Sön"].map(weekdayOf)).toEqual([0, 1, 2, 3, 4, 5, 6]);
expect(weekdayOf("Tid")).toBeNull();
expect(weekdayOf("Ma")).toBeNull();
expect(weekdayOf("")).toBeNull();
});
it("skriver tider som HH:MM", () => {
expect(normalizeTime("6")).toBe("06:00");
expect(normalizeTime("6:30")).toBe("06:30");
expect(normalizeTime("06.00")).toBe("06:00");
expect(normalizeTime(" 23:59 ")).toBe("23:59");
expect(normalizeTime("24:00")).toBeNull();
expect(normalizeTime("12:60")).toBeNull();
expect(normalizeTime("lunch")).toBeNull();
expect(normalizeTime("")).toBeNull();
});
});
describe("isScheduleGrid", () => {
it("kräver Tid och minst fem veckodagar", () => {
expect(isScheduleGrid(grid([]))).toBe(true);
expect(isScheduleGrid({ header: ["Tid", "Måndag", "Tisdag"], rows: [] })).toBe(false);
expect(isScheduleGrid({ header: ["Datum", ...DAYS.slice(1)], rows: [] })).toBe(false);
});
});
describe("parseScheduleGrid", () => {
const times = ["06:00", "07:00", "08:00", "09:00", "10:00", "11:00", "12:00", "13:00", "14:00", "15:00", "16:00", "17:00", "18:00"];
it("följande timmar med innehåll blir ett pass", () => {
const rows = times.map((t) => row(t, t >= "08:00" && t < "16:00" ? "Arbete" : ""));
expect(parseScheduleGrid(grid(rows))).toEqual([{ weekday: 0, startTime: "08:00", endTime: "16:00", label: "Arbete" }]);
});
it("flera dagar och flera pass per dag", () => {
const rows = [
row("06:00", "X", "", "", "", "X"),
row("07:00", "X", "", "", "", "X"),
row("08:00", "", "", "", "", ""),
row("09:00", "Möte", "Möte", "", "", ""),
row("10:00", "Möte", "Möte", "", "", ""),
];
expect(parseScheduleGrid(grid(rows))).toEqual([
{ weekday: 0, startTime: "06:00", endTime: "08:00", label: null },
{ weekday: 0, startTime: "09:00", endTime: "11:00", label: "Möte" },
{ weekday: 1, startTime: "09:00", endTime: "11:00", label: "Möte" },
{ weekday: 4, startTime: "06:00", endTime: "08:00", label: null },
]);
});
it("olika innehåll i följd ger olika pass, oavsett stora och små bokstäver", () => {
const rows = [row("08:00", "Kassa"), row("09:00", "kassa"), row("10:00", "Lager"), row("11:00", "Lager")];
expect(parseScheduleGrid(grid(rows))).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "10:00", label: "Kassa" },
{ weekday: 0, startTime: "10:00", endTime: "12:00", label: "Lager" },
]);
});
it("ett nattschema som går över midnatt blir ett pass som går över midnatt", () => {
const hours = ["18:00", "19:00", "20:00", "21:00", "22:00", "23:00", "00:00", "01:00", "02:00", "03:00", "04:00", "05:00"];
const rows = hours.map((t) => row(t, "X", "", "", "", "", "", ""));
expect(parseScheduleGrid(grid(rows))).toEqual([{ weekday: 0, startTime: "18:00", endTime: "06:00", label: null }]);
});
it("ett uppehåll i tiderna delar passet", () => {
const rows = [row("08:00", "X"), row("09:00", "X"), row("13:00", "X"), row("14:00", "X")];
expect(parseScheduleGrid(grid(rows))).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "10:00", label: null },
{ weekday: 0, startTime: "13:00", endTime: "15:00", label: null },
]);
});
it("halvtimmar och ensamma rader", () => {
const rows = [row("08:00", "X"), row("08:30", "X"), row("09:00", ""), row("12:00", "", "Lunch")];
expect(parseScheduleGrid(grid(rows))).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "09:00", label: null },
{ weekday: 1, startTime: "12:00", endTime: "13:00", label: "Lunch" },
]);
});
it("ignorerar rader utan tid och ett tomt eller trasigt schema", () => {
expect(parseScheduleGrid(grid([]))).toEqual([]);
expect(parseScheduleGrid(grid([row("lunch", "X"), row("", "X")]))).toEqual([]);
expect(parseScheduleGrid({ header: ["Tid", "Foo", "Bar"], rows: [["08:00", "X", "X"]] })).toEqual([]);
});
it("ett helt dygn kan inte skrivas som ett pass (start och slut vore samma tid) och hoppas över", () => {
const rows = Array.from({ length: 24 }, (_, h) => row(`${String(h).padStart(2, "0")}:00`, "X"));
expect(parseScheduleGrid(grid(rows))).toEqual([]);
});
it("långa texter kortas till 100 tecken", () => {
const [shift] = parseScheduleGrid(grid([row("08:00", "x".repeat(300))]));
expect(shift.label).toHaveLength(100);
});
});
describe("findScheduleCode", () => {
it("hittar Schema-ID i texten", () => {
expect(findScheduleCode(["Schema: Schema ID: SCI-0003"])).toBe("SCI-0003");
expect(findScheduleCode(["Schema: Schema ID:___________"])).toBeNull();
expect(findScheduleCode(["x", "SCI-12"])).toBe("SCI-12");
expect(findScheduleCode([])).toBeNull();
});
});
describe("parseScheduleRegister", () => {
const resolve = (text: string, kinds?: string[]) => known.find((e) => text.includes(e.code ?? "§") && (!kinds || kinds.includes(e.kind))) ?? null;
const register: RegisterTable = {
header: ["Schema ID", "Karaktärs ID", "Företags/utbildnings ID", "Dag/natt"],
rows: [
["SCI-0001", "Anna Lind KI-0001", "FI-0001", "Dag: X Natt:"],
["SCI-0002", "KI-9999", "UI-0001", "Dag: Natt: X"],
["", "KI-0001", "", ""],
["SCI-0003", "", "", "Dag: Natt:"],
],
};
it("kopplar Schema-ID till person och arbetsplats", () => {
expect(parseScheduleRegister(register, resolve)).toEqual([
{ code: "SCI-0001", personText: "Anna Lind KI-0001", workplaceText: "FI-0001", personId: "k1", workplaceId: "c1", dayNight: "Dag" },
{ code: "SCI-0002", personText: "KI-9999", workplaceText: "UI-0001", personId: null, workplaceId: "u1", dayNight: "Natt" },
{ code: "SCI-0003", personText: "", workplaceText: "", personId: null, workplaceId: null, dayNight: "" },
]);
});
});
describe("parseMapRegister", () => {
const header = ["Kart ID", "Placerings ID", "Stad/Område", "Beskrivning", "Övrigt"];
it("rader med samma Kart-ID blir en karta med flera markeringar", () => {
const maps = parseMapRegister({
header,
rows: [
["KD-R_0001", "PI-0001", "Lund", "Kaféet", "Vid torget"],
["KD-R_0001", "PI-0002", "", "Biblioteket", ""],
["KD-R_0002", "", "Malmö", "", ""],
],
});
expect(maps).toEqual([
{
code: "KD-R_0001",
name: "Lund",
kind: "GEO",
markers: [
{ code: "PI-0001", label: "Kaféet", note: "Vid torget" },
{ code: "PI-0002", label: "Biblioteket", note: null },
],
},
{ code: "KD-R_0002", name: "Malmö", kind: "GEO", markers: [] },
]);
});
it("utan Kart-ID hör rader med samma område ihop, och bildkartor känns igen", () => {
const maps = parseMapRegister({
header,
rows: [
["", "", "Lund", "Hus A", ""],
["", "", "lund", "Hus B", ""],
["KD-E_0001", "", "Egen karta", "Ruta", ""],
["", "", "", "", ""],
],
});
expect(maps.map((m) => [m.code, m.name, m.kind, m.markers.length])).toEqual([
[null, "Lund", "GEO", 2],
["KD-E_0001", "Egen karta", "IMAGE", 1],
]);
});
it("en markering utan beskrivning får områdets namn", () => {
const [map] = parseMapRegister({ header, rows: [["KD-R_0001", "PI-0009", "Lund", "", ""]] });
expect(map.markers).toEqual([{ code: "PI-0009", label: "Lund", note: null }]);
});
it("namnlös karta får Kart-ID som namn", () => {
expect(parseMapRegister({ header, rows: [["KD-R_0004", "", "", "", ""]] })[0].name).toBe("KD-R_0004");
});
});
describe("hela dokument", () => {
const analyze = (blocks: DocBlock[], file = "x.docx") => analyzeDocument(blocks, file, known);
it("ett ifyllt schema med Schema-ID", () => {
const rows = [row("08:00", "Arbete", "Arbete"), row("09:00", "Arbete", "Arbete"), row("10:00", "", "")];
const doc = analyze([{ type: "paragraph", text: "Schema: Schema ID: SCI-0007" }, table(DAYS.map((d) => `${d}:`), ...rows)]);
expect(doc.kind).toBe("SCHEDULE");
expect(doc.schedule).toMatchObject({ code: "SCI-0007", personId: null, source: null });
expect(doc.schedule?.shifts).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "10:00", label: "Arbete" },
{ weekday: 1, startTime: "08:00", endTime: "10:00", label: "Arbete" },
]);
});
it("schemaregistret slår upp personer och arbetsplatser i boken", () => {
const doc = analyze([table(["Schema ID:", "Karaktärs ID:", "Företags/utbildnings ID:", "Dag/natt:"], ["SCI-0001", "KI-0001", "FI-0001", "Dag: X Natt:"], ["", "", "", ""], ["", "", "", ""])]);
expect(doc.kind).toBe("SCHEDULE_REGISTER");
expect(doc.scheduleRows).toEqual([{ code: "SCI-0001", personText: "KI-0001", workplaceText: "FI-0001", personId: "k1", workplaceId: "c1", dayNight: "Dag" }]);
});
it("kartregistret ger kartor", () => {
const doc = analyze([table(["Kart ID:", "Placerings ID:", "Stad/Område:", "Beskrivning:", "Övrigt:"], ["KD-R_0001", "PI-0001", "Lund", "Kaféet", ""], ["", "", "", "", ""], ["", "", "", "", ""])]);
expect(doc.kind).toBe("MAP_REGISTER");
expect(doc.maps).toHaveLength(1);
expect(doc.maps[0].markers).toHaveLength(1);
});
it("användaren kan byta ett dokument till schema, och en tom mall ger varning", () => {
const doc = analyzeDocument([table(["Namn:", "x"])], "x.docx", known, { kind: "SCHEDULE" });
expect(doc).toMatchObject({ kind: "SCHEDULE", warnings: ["empty"] });
});
});
const root = new URL("../../", import.meta.url);
const available = existsSync(new URL("Mall/Schema dag.docx", root));
const load = (path: string): DocBlock[] => readDocx(new Uint8Array(readFileSync(new URL(path, root))));
describe.skipIf(!available)("riktiga scheman och register, ifyllda", () => {
const fillGrid = (blocks: DocBlock[], cells: [number, number, string][]) => {
const copy: DocBlock[] = JSON.parse(JSON.stringify(blocks));
const tbl = copy.find((b) => b.type === "table");
if (tbl?.type !== "table") throw new Error("Väntade en tabell");
for (const [r, c, text] of cells) tbl.rows[r][c] = text;
return copy;
};
it("dagschemat: rutnätet läses och Schema-ID hittas i rubrikraden", () => {
const blocks = load("Mall/Schema dag.docx");
const first = blocks.find((b) => b.type === "paragraph");
if (first?.type !== "paragraph") throw new Error("Väntade ett stycke");
const filled = blocks.map((b) => (b === first ? { ...b, text: "Schema:Schema ID: SCI-0042" } : b));
// Rad 1 är 06:00, rad 3 08:00 ... kolumn 1 är måndag, 2 tisdag
const doc = analyzeDocument(fillGrid(filled, [[3, 1, "Arbete"], [4, 1, "Arbete"], [5, 1, "Arbete"], [3, 5, "X"], [4, 5, "X"]]), "dag.docx", known);
expect(doc.kind).toBe("SCHEDULE");
expect(doc.schedule?.code).toBe("SCI-0042");
expect(doc.schedule?.shifts).toEqual([
{ weekday: 0, startTime: "08:00", endTime: "11:00", label: "Arbete" },
{ weekday: 4, startTime: "08:00", endTime: "10:00", label: null },
]);
});
it("nattschemat: kvällens och nattens timmar blir ett pass över midnatt", () => {
const blocks = load("Mall/Schema natt.docx");
const tbl = blocks.find((b) => b.type === "table");
if (tbl?.type !== "table") throw new Error("Väntade en tabell");
const times = tbl.rows.slice(1).map((r) => r[0]);
expect(times[0]).toBe("18:00");
expect(times).toContain("00:00");
const all = tbl.rows.slice(1).map((_, i) => [i + 1, 3, "Natt"] as [number, number, string]);
const doc = analyzeDocument(fillGrid(blocks, all), "natt.docx", known);
expect(doc.schedule?.shifts).toHaveLength(1);
expect(doc.schedule?.shifts[0]).toMatchObject({ weekday: 2, startTime: "18:00", label: "Natt" });
expect(doc.schedule!.shifts[0].endTime < doc.schedule!.shifts[0].startTime).toBe(true);
});
it("schemaregistret och kartregistret med ifyllda rader", () => {
const register = load("Register/Schemaregister.docx");
const filled = fillGrid(register, [[1, 0, "SCI-0001"], [1, 1, "KI-0001"], [1, 2, "FI-0001"], [1, 3, "Dag: X Natt:"]]);
const doc = analyzeDocument(filled, "reg.docx", known);
expect(doc.kind).toBe("SCHEDULE_REGISTER");
expect(doc.scheduleRows).toEqual([{ code: "SCI-0001", personText: "KI-0001", workplaceText: "FI-0001", personId: "k1", workplaceId: "c1", dayNight: "Dag" }]);
const maps = analyzeDocument(fillGrid(load("Register/Kartregister.docx"), [[1, 0, "KD-R_0001"], [1, 1, "PI-0001"], [1, 2, "Lund"], [1, 3, "Kaféet"]]), "karta.docx", known);
expect(maps.kind).toBe("MAP_REGISTER");
expect(maps.maps).toEqual([{ code: "KD-R_0001", name: "Lund", kind: "GEO", markers: [{ code: "PI-0001", label: "Kaféet", note: null }] }]);
});
});