Delning av böcker, skydd mot kolliderande ändringar och import från Word
Böcker kan delas med roller (läsare, redaktör, administratör), och behörigheten kontrolleras på servern. Formulär för poster, relationer och händelser skickar med version, och en krock visar vad som skiljer och låter användaren spara ändå eller ladda om. Ifyllda Word-mallar kan importeras med förhandsgranskning. Importerade ID flyttar nu räknaren. Migrering 0007. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
bd269d70a5
commit
86fd435438
64 files changed
+4683
-122
No files matched your search
@@ -137,6 +137,36 @@ Generationerna räknas ut automatiskt, partner ritas bredvid varandra och barn m
|
||||
|
||||
Händelser och relationer med slutdatum visas dessutom som staplar under *Perioder*. Du kan filtrera på person och på typ av händelse.
|
||||
|
||||
## Delning av böcker
|
||||
|
||||
En bok kan delas med andra som har loggat in i appen. Under *Bokinställningar → Delning* skriver du e-postadressen som personen loggar in med (samma som i Authentik) och väljer en roll. Personen måste ha loggat in minst en gång. Den delade boken syns under *Mina böcker* med ägarens namn och rollen.
|
||||
|
||||
| Roll | Får |
|
||||
| --- | --- |
|
||||
| Läsare | Läsa allt, söka och exportera. Ser ingen redigeringsknapp. |
|
||||
| Redaktör | Allt en läsare får, och skriva: poster, relationer, släktband, scheman, kartor, händelser, namngeneratorn, Word-import, och flytta till och återställa ur papperskorgen. |
|
||||
| Administratör | Allt en redaktör får, och dela boken, ändra bokens uppgifter och mallar, och tömma papperskorgen. Kan ge och ta bort redaktörer och läsare. |
|
||||
| Ägare | Allt, och dessutom ta bort boken och ge och ta bort administratörer. |
|
||||
|
||||
Behörigheten kontrolleras på servern vid varje ändring, så en dold knapp är inte det enda skyddet. Den som inte har tillgång till en bok får 404. Poster som tas bort hamnar i ägarens papperskorg (det är ägaren som har lagringskvoten) men kan återställas av redaktörer. Bilder som en redaktör laddar upp räknas mot ägarens kvot. Ändringshistoriken visar vem som gjorde ändringen. En medlem kan lämna en delad bok under *Bokinställningar*, och ägaren kan dela den igen.
|
||||
|
||||
## 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.
|
||||
|
||||
## 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.
|
||||
- **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.
|
||||
- **Det som inte tolkades** visas under *Ej tolkat* och kan läggas i fältet *Övrigt* eller *Beskrivning* (en ruta, på som standard), så att inget försvinner.
|
||||
- **Dubbletter.** Finns redan en post av samma typ med samma namn är den avmarkerad. Markera den för att skapa en till.
|
||||
- **Register** (fordon, referenser, research) ger en post per ifylld rad, och appar och hemsidor en post per *Namn*.
|
||||
- Gränser: 20 filer åt gången, 8 MB per fil och 500 poster. Bara huvuddokumentet i filen packas upp. Allt kontrolleras igen på servern innan det sparas.
|
||||
|
||||
## Export och import
|
||||
|
||||
Under *Bokinställningar* exporterar du hela boken:
|
||||
@@ -218,10 +248,10 @@ 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 240 tester:
|
||||
Testerna körs med Vitest (`npm test`). Det finns cirka 430 tester:
|
||||
|
||||
- **Enhetstester utan databas** (`tests/unit`): 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, 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.
|
||||
- **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.
|
||||
|
||||
Databastesterna behöver en PostgreSQL-databas och använder alltid en **egen testdatabas** vars namn slutar på `_test`. De tömmer den mellan testerna och vägrar köra mot en databas med något annat namn, så din riktiga data berörs aldrig. Databasen skapas och migreras automatiskt första gången.
|
||||
|
||||
|
||||
@@ -110,6 +110,9 @@ Samma `act_runner` som för publiceringen räcker. Tjänstecontainern nås som `
|
||||
|
||||
## Verifiera
|
||||
|
||||
- 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.
|
||||
|
||||
- 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.
|
||||
- Bygg imagen med den mindre Dockerfile och jämför storleken mot den gamla.
|
||||
@@ -122,5 +125,10 @@ 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.
|
||||
- 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,36 @@
|
||||
-- CreateEnum
|
||||
CREATE TYPE "BookRole" AS ENUM ('ADMIN', 'EDITOR', 'VIEWER');
|
||||
|
||||
-- AlterTable
|
||||
ALTER TABLE "Entity" ADD COLUMN "updatedById" TEXT;
|
||||
|
||||
-- AlterTable
|
||||
ALTER TABLE "Relation" ADD COLUMN "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
ADD COLUMN "updatedById" TEXT;
|
||||
|
||||
-- AlterTable
|
||||
ALTER TABLE "StoryEvent" ADD COLUMN "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
ADD COLUMN "updatedById" TEXT;
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "BookMember" (
|
||||
"id" TEXT NOT NULL,
|
||||
"bookId" TEXT NOT NULL,
|
||||
"userId" TEXT NOT NULL,
|
||||
"role" "BookRole" NOT NULL DEFAULT 'EDITOR',
|
||||
"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
|
||||
CONSTRAINT "BookMember_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "BookMember_userId_idx" ON "BookMember"("userId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "BookMember_bookId_userId_key" ON "BookMember"("bookId", "userId");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "BookMember" ADD CONSTRAINT "BookMember_bookId_fkey" FOREIGN KEY ("bookId") REFERENCES "Book"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "BookMember" ADD CONSTRAINT "BookMember_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -44,6 +44,13 @@ enum FamilyBond {
|
||||
SIBLING
|
||||
}
|
||||
|
||||
// Roll i en delad bok. Ägaren (Book.ownerId) har alltid full behörighet och står inte i BookMember.
|
||||
enum BookRole {
|
||||
ADMIN
|
||||
EDITOR
|
||||
VIEWER
|
||||
}
|
||||
|
||||
model User {
|
||||
id String @id @default(cuid())
|
||||
// "<provider>:<subject>", t.ex. "authentik:abc123"
|
||||
@@ -53,6 +60,7 @@ model User {
|
||||
createdAt DateTime @default(now())
|
||||
books Book[]
|
||||
trash TrashItem[]
|
||||
memberships BookMember[]
|
||||
}
|
||||
|
||||
model Book {
|
||||
@@ -74,6 +82,7 @@ model Book {
|
||||
counters IdCounter[]
|
||||
versions EntityVersion[]
|
||||
events StoryEvent[]
|
||||
members BookMember[]
|
||||
|
||||
@@index([ownerId])
|
||||
}
|
||||
@@ -87,6 +96,8 @@ model Entity {
|
||||
name String
|
||||
summary String? @db.Text
|
||||
imageFile String?
|
||||
// Vem som senast ändrade posten (användar-id, utan främmande nyckel så att historiken överlever en borttagen användare)
|
||||
updatedById String?
|
||||
// Skapas automatiskt, t.ex. KI-0001 (se src/lib/ids.ts)
|
||||
code String?
|
||||
tags String[]
|
||||
@@ -122,6 +133,8 @@ model Relation {
|
||||
startDate String?
|
||||
endDate String?
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @default(now()) @updatedAt
|
||||
updatedById String?
|
||||
|
||||
book Book @relation(fields: [bookId], references: [id], onDelete: Cascade)
|
||||
from Entity @relation("RelationFrom", fields: [fromId], references: [id], onDelete: Cascade)
|
||||
@@ -225,6 +238,21 @@ model RelationMember {
|
||||
@@index([entityId])
|
||||
}
|
||||
|
||||
// Delning av en bok med en annan användare.
|
||||
model BookMember {
|
||||
id String @id @default(cuid())
|
||||
bookId String
|
||||
userId String
|
||||
role BookRole @default(EDITOR)
|
||||
createdAt DateTime @default(now())
|
||||
|
||||
book Book @relation(fields: [bookId], references: [id], onDelete: Cascade)
|
||||
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
|
||||
|
||||
@@unique([bookId, userId])
|
||||
@@index([userId])
|
||||
}
|
||||
|
||||
// Händelse på tidslinjen. Datum skrivs som "ÅÅÅÅ", "ÅÅÅÅ-MM" eller "ÅÅÅÅ-MM-DD".
|
||||
model StoryEvent {
|
||||
id String @id @default(cuid())
|
||||
@@ -234,6 +262,8 @@ model StoryEvent {
|
||||
endDate String?
|
||||
description String? @db.Text
|
||||
createdAt DateTime @default(now())
|
||||
updatedAt DateTime @default(now()) @updatedAt
|
||||
updatedById String?
|
||||
|
||||
book Book @relation(fields: [bookId], references: [id], onDelete: Cascade)
|
||||
participants EventParticipant[]
|
||||
|
||||
@@ -25,7 +25,7 @@ export async function createBook(formData: FormData) {
|
||||
}
|
||||
|
||||
export async function updateBook(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "ADMIN");
|
||||
const title = str(formData, "title", 200);
|
||||
if (!title) return;
|
||||
await prisma.book.update({
|
||||
@@ -42,7 +42,7 @@ export async function updateBook(formData: FormData) {
|
||||
}
|
||||
|
||||
export async function deleteBook(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "OWNER");
|
||||
// Boken flyttas till papperskorgen (som zip med bilder) och kan återställas i 30 dagar
|
||||
await trashBook(book.ownerId, book.id);
|
||||
revalidatePath("/");
|
||||
|
||||
+51
-28
@@ -1,10 +1,11 @@
|
||||
"use server";
|
||||
|
||||
import type { Prisma } from "@prisma/client";
|
||||
import { Prisma } from "@prisma/client";
|
||||
import { redirect } from "next/navigation";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { conflictInfo, isStale, type SaveResult } from "@/lib/conflict";
|
||||
import { deleteImage, isUpload, saveImage } from "@/lib/files";
|
||||
import { recordVersion, sameSnapshot, snapshotOf } from "@/lib/history";
|
||||
import { diffSnapshots, recordVersion, sameSnapshot, snapshotOf } from "@/lib/history";
|
||||
import { optStr, parseTags, revalidateBook, str } from "@/lib/form";
|
||||
import { collectFieldData } from "@/lib/field-values";
|
||||
import { KIND_INFO, parseKind } from "@/lib/kinds";
|
||||
@@ -13,12 +14,12 @@ import { requireBook, requireEntity } from "@/lib/session";
|
||||
import { withinQuota } from "@/lib/storage";
|
||||
import { trashEntity } from "@/lib/trash";
|
||||
import { getTemplate } from "@/lib/templates";
|
||||
import { getLocale } from "@/i18n/server";
|
||||
import { getLocale, getT } from "@/i18n/server";
|
||||
|
||||
export async function saveEntity(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
export async function saveEntity(formData: FormData): Promise<SaveResult> {
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const id = str(formData, "id");
|
||||
const existing = id ? await requireEntity(book.id, id) : null;
|
||||
const existing = id ? await requireEntity(book.id, id, "EDITOR") : null;
|
||||
const kind = existing?.kind ?? parseKind(str(formData, "kind"));
|
||||
if (!kind) throw new Error("Invalid kind");
|
||||
|
||||
@@ -27,49 +28,71 @@ export async function saveEntity(formData: FormData) {
|
||||
|
||||
const { fields } = await getTemplate(book.id, kind, await getLocale());
|
||||
const data = await collectFieldData(book.id, fields, formData, (existing?.data as Record<string, unknown> | null) ?? null);
|
||||
|
||||
let imageFile = existing?.imageFile ?? null;
|
||||
const upload = formData.get("image");
|
||||
if (isUpload(upload)) {
|
||||
if (!(await withinQuota(book.ownerId, upload.size))) {
|
||||
redirect(existing ? `/books/${book.id}/entity/${existing.id}/edit?error=quota` : `/books/${book.id}/e/${KIND_INFO[kind].slug}/new?error=quota`);
|
||||
}
|
||||
const saved = await saveImage(upload);
|
||||
await deleteImage(imageFile);
|
||||
imageFile = saved;
|
||||
} else if (formData.has("removeImage")) {
|
||||
await deleteImage(imageFile);
|
||||
imageFile = null;
|
||||
}
|
||||
|
||||
const values = {
|
||||
name,
|
||||
summary: optStr(formData, "summary"),
|
||||
tags: parseTags(str(formData, "tags", 1000)),
|
||||
data: data as Prisma.InputJsonObject,
|
||||
imageFile,
|
||||
};
|
||||
|
||||
// Har någon annan sparat posten sedan formuläret öppnades? Då sparas ingenting förrän användaren väljer det.
|
||||
const conflict = async (current: NonNullable<typeof existing>): Promise<SaveResult> => {
|
||||
const { t } = await getT();
|
||||
const changes = diffSnapshots(snapshotOf(current), snapshotOf(values), fields, {
|
||||
name: t("common.name"),
|
||||
summary: t("common.summary"),
|
||||
tags: t("common.tags"),
|
||||
});
|
||||
return { conflict: await conflictInfo(current, changes) };
|
||||
};
|
||||
if (existing && isStale(str(formData, "version", 30), existing.updatedAt)) return conflict(existing);
|
||||
|
||||
let imageFile = existing?.imageFile ?? null;
|
||||
let replaced: string | null = null; // den gamla bilden, som tas bort först när posten har sparats
|
||||
const upload = formData.get("image");
|
||||
if (isUpload(upload)) {
|
||||
if (!(await withinQuota(book.ownerId, upload.size))) {
|
||||
redirect(existing ? `/books/${book.id}/entity/${existing.id}/edit?error=quota` : `/books/${book.id}/e/${KIND_INFO[kind].slug}/new?error=quota`);
|
||||
}
|
||||
replaced = imageFile;
|
||||
imageFile = await saveImage(upload);
|
||||
} else if (formData.has("removeImage")) {
|
||||
replaced = imageFile;
|
||||
imageFile = null;
|
||||
}
|
||||
|
||||
// ID skapas automatiskt vid första sparningen och ändras aldrig därefter
|
||||
const saved = await prisma.$transaction(async (tx) => {
|
||||
let saved: { id: string };
|
||||
try {
|
||||
saved = await prisma.$transaction(async (tx) => {
|
||||
if (existing) {
|
||||
// Den tidigare versionen sparas bara om något faktiskt ändrats
|
||||
const before = snapshotOf(existing);
|
||||
if (!sameSnapshot(before, snapshotOf(values))) await recordVersion(tx, book.id, existing.id, book.ownerId, before);
|
||||
if (!sameSnapshot(before, snapshotOf(values))) await recordVersion(tx, book.id, existing.id, book.userId, before);
|
||||
const code = existing.code ?? (await nextEntityCode(book.id, kind, tx));
|
||||
return tx.entity.update({ where: { id: existing.id }, data: { ...values, code } });
|
||||
// Villkoret på updatedAt gör att en samtidig sparning av någon annan ger ett fel i stället för att skrivas över
|
||||
return tx.entity.update({ where: { id: existing.id, updatedAt: existing.updatedAt }, data: { ...values, imageFile, code, updatedById: book.userId } });
|
||||
}
|
||||
const code = await nextEntityCode(book.id, kind, tx);
|
||||
return tx.entity.create({ data: { ...values, code, bookId: book.id, kind } });
|
||||
return tx.entity.create({ data: { ...values, imageFile, code, bookId: book.id, kind, updatedById: book.userId } });
|
||||
});
|
||||
} catch (error) {
|
||||
if (existing && error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2025") {
|
||||
if (imageFile !== existing.imageFile) await deleteImage(imageFile);
|
||||
const current = await prisma.entity.findUnique({ where: { id: existing.id } });
|
||||
if (current) return conflict(current);
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
if (replaced) await deleteImage(replaced);
|
||||
|
||||
revalidateBook(book.id);
|
||||
redirect(`/books/${book.id}/entity/${saved.id}`);
|
||||
}
|
||||
|
||||
export async function deleteEntity(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const entity = await requireEntity(book.id, str(formData, "id"));
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const entity = await requireEntity(book.id, str(formData, "id"), "EDITOR");
|
||||
// Posten flyttas till papperskorgen och kan återställas i 30 dagar
|
||||
await trashEntity(book.ownerId, book.id, entity.id);
|
||||
revalidateBook(book.id);
|
||||
|
||||
+20
-6
@@ -1,6 +1,8 @@
|
||||
"use server";
|
||||
|
||||
import { Prisma } from "@prisma/client";
|
||||
import { redirect } from "next/navigation";
|
||||
import { conflictInfo, isStale, type SaveResult } from "@/lib/conflict";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { optStr, revalidateBook, str } from "@/lib/form";
|
||||
import { requireBook } from "@/lib/session";
|
||||
@@ -28,7 +30,7 @@ async function readEvent(bookId: string, formData: FormData) {
|
||||
}
|
||||
|
||||
export async function addEvent(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const event = await readEvent(book.id, formData);
|
||||
if (!event.title) return;
|
||||
if (event.badDate) redirect(`/books/${book.id}/timeline?error=date`);
|
||||
@@ -40,6 +42,7 @@ export async function addEvent(formData: FormData) {
|
||||
date: event.date,
|
||||
endDate: event.endDate,
|
||||
description: event.description,
|
||||
updatedById: book.userId,
|
||||
participants: { create: event.participantIds.map((entityId) => ({ entityId })) },
|
||||
},
|
||||
});
|
||||
@@ -47,35 +50,46 @@ export async function addEvent(formData: FormData) {
|
||||
redirect(`/books/${book.id}/timeline`);
|
||||
}
|
||||
|
||||
export async function saveEvent(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
export async function saveEvent(formData: FormData): Promise<SaveResult> {
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const id = str(formData, "id");
|
||||
const existing = await prisma.storyEvent.findFirst({ where: { id, bookId: book.id }, select: { id: true } });
|
||||
const existing = await prisma.storyEvent.findFirst({ where: { id, bookId: book.id } });
|
||||
if (!existing) throw new Error("Event not found");
|
||||
if (isStale(str(formData, "version", 30), existing.updatedAt)) return { conflict: await conflictInfo(existing) };
|
||||
|
||||
const event = await readEvent(book.id, formData);
|
||||
if (!event.title) return;
|
||||
if (event.badDate) redirect(`/books/${book.id}/timeline/${id}?error=date`);
|
||||
|
||||
try {
|
||||
await prisma.$transaction([
|
||||
prisma.eventParticipant.deleteMany({ where: { eventId: id } }),
|
||||
prisma.storyEvent.update({
|
||||
where: { id },
|
||||
// Villkoret på updatedAt gör att en samtidig sparning av någon annan ger ett fel i stället för att skrivas över
|
||||
where: { id, updatedAt: existing.updatedAt },
|
||||
data: {
|
||||
title: event.title,
|
||||
date: event.date,
|
||||
endDate: event.endDate,
|
||||
description: event.description,
|
||||
updatedById: book.userId,
|
||||
participants: { create: event.participantIds.map((entityId) => ({ entityId })) },
|
||||
},
|
||||
}),
|
||||
]);
|
||||
} catch (error) {
|
||||
if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2025") {
|
||||
const current = await prisma.storyEvent.findUnique({ where: { id } });
|
||||
if (current) return { conflict: await conflictInfo(current) };
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
revalidateBook(book.id);
|
||||
redirect(`/books/${book.id}/timeline/${id}?saved=1`);
|
||||
}
|
||||
|
||||
export async function deleteEvent(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
await prisma.storyEvent.deleteMany({ where: { id: str(formData, "id"), bookId: book.id } });
|
||||
revalidateBook(book.id);
|
||||
redirect(`/books/${book.id}/timeline`);
|
||||
|
||||
@@ -10,15 +10,15 @@ import { requireBook, requireEntity } from "@/lib/session";
|
||||
/** Återställer en tidigare version. Den nuvarande versionen sparas först i historiken, så åtgärden kan ångras. */
|
||||
export async function restoreVersion(formData: FormData) {
|
||||
const bookId = str(formData, "bookId");
|
||||
const book = await requireBook(bookId);
|
||||
const entity = await requireEntity(bookId, str(formData, "entityId"));
|
||||
const book = await requireBook(bookId, "EDITOR");
|
||||
const entity = await requireEntity(bookId, str(formData, "entityId"), "EDITOR");
|
||||
const version = await prisma.entityVersion.findFirst({ where: { id: str(formData, "versionId"), entityId: entity.id, bookId } });
|
||||
if (!version) redirect(`/books/${bookId}/entity/${entity.id}/history`);
|
||||
|
||||
const target = version.snapshot as unknown as Snapshot;
|
||||
const current = snapshotOf(entity);
|
||||
await prisma.$transaction(async (tx) => {
|
||||
if (!sameSnapshot(current, target)) await recordVersion(tx, bookId, entity.id, book.ownerId, current);
|
||||
if (!sameSnapshot(current, target)) await recordVersion(tx, bookId, entity.id, book.userId, current);
|
||||
await tx.entity.update({
|
||||
where: { id: entity.id },
|
||||
data: { name: target.name, summary: target.summary, tags: target.tags, data: (target.data ?? {}) as Prisma.InputJsonObject },
|
||||
|
||||
+2
-2
@@ -10,14 +10,14 @@ import { requireBook } from "@/lib/session";
|
||||
import { withinQuota } from "@/lib/storage";
|
||||
|
||||
async function requireMap(bookId: string, mapId: string) {
|
||||
const book = await requireBook(bookId);
|
||||
const book = await requireBook(bookId, "EDITOR");
|
||||
const map = await prisma.bookMap.findFirst({ where: { id: mapId, bookId: book.id } });
|
||||
if (!map) throw new Error("Map not found");
|
||||
return { book, map };
|
||||
}
|
||||
|
||||
export async function createMap(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const name = str(formData, "name", 200);
|
||||
const kind = str(formData, "kind") === "IMAGE" ? "IMAGE" : "GEO";
|
||||
if (!name) return;
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
"use server";
|
||||
|
||||
import type { Prisma } from "@prisma/client";
|
||||
import { Prisma } from "@prisma/client";
|
||||
import { redirect } from "next/navigation";
|
||||
import { conflictInfo, isStale, type SaveResult } from "@/lib/conflict";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { parseBond } from "@/lib/family";
|
||||
import { optStr, revalidateBook, str } from "@/lib/form";
|
||||
@@ -35,7 +36,7 @@ async function bondAndDates(formData: FormData) {
|
||||
}
|
||||
|
||||
export async function addRelation(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const fromId = str(formData, "fromId");
|
||||
const toId = str(formData, "toId");
|
||||
const { ok, bond, startDate, endDate, type } = await bondAndDates(formData);
|
||||
@@ -65,10 +66,11 @@ export async function addRelation(formData: FormData) {
|
||||
revalidateBook(book.id);
|
||||
}
|
||||
|
||||
export async function saveRelation(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
export async function saveRelation(formData: FormData): Promise<SaveResult> {
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const relation = await prisma.relation.findFirst({ where: { id: str(formData, "id"), bookId: book.id } });
|
||||
if (!relation) throw new Error("Relation not found");
|
||||
if (isStale(str(formData, "version", 30), relation.updatedAt)) return { conflict: await conflictInfo(relation) };
|
||||
const { ok, bond, startDate, endDate, type } = await bondAndDates(formData);
|
||||
if (!type || !ok) return;
|
||||
|
||||
@@ -76,10 +78,12 @@ export async function saveRelation(formData: FormData) {
|
||||
const data = await collectFieldData(book.id, fields, formData, (relation.data as Record<string, unknown> | null) ?? null);
|
||||
|
||||
const memberIds = await cleanMemberIds(book.id, formData, [relation.fromId, relation.toId]);
|
||||
try {
|
||||
await prisma.$transaction([
|
||||
prisma.relationMember.deleteMany({ where: { relationId: relation.id } }),
|
||||
prisma.relation.update({
|
||||
where: { id: relation.id },
|
||||
// Villkoret på updatedAt gör att en samtidig sparning av någon annan ger ett fel i stället för att skrivas över
|
||||
where: { id: relation.id, updatedAt: relation.updatedAt },
|
||||
data: {
|
||||
type,
|
||||
bond,
|
||||
@@ -87,16 +91,24 @@ export async function saveRelation(formData: FormData) {
|
||||
endDate,
|
||||
description: optStr(formData, "description", 2000),
|
||||
data: data as Prisma.InputJsonObject,
|
||||
updatedById: book.userId,
|
||||
members: { create: memberIds.map((entityId) => ({ entityId })) },
|
||||
},
|
||||
}),
|
||||
]);
|
||||
} catch (error) {
|
||||
if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2025") {
|
||||
const current = await prisma.relation.findUnique({ where: { id: relation.id } });
|
||||
if (current) return { conflict: await conflictInfo(current) };
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
revalidateBook(book.id);
|
||||
redirect(`/books/${book.id}/relations/${relation.id}?saved=1`);
|
||||
}
|
||||
|
||||
export async function deleteRelation(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
await prisma.relation.deleteMany({ where: { id: str(formData, "id"), bookId: book.id } });
|
||||
revalidateBook(book.id);
|
||||
if (formData.get("redirect") === "list") redirect(`/books/${book.id}/relations`);
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
"use server";
|
||||
|
||||
import { redirect } from "next/navigation";
|
||||
import { revalidatePath } from "next/cache";
|
||||
import { parseMemberRole } from "@/lib/access";
|
||||
import { str } from "@/lib/form";
|
||||
import { requireBook, requireUser } from "@/lib/session";
|
||||
import { addMember, leaveBook, removeMember, setMemberRole, type ShareResult } from "@/lib/sharing";
|
||||
|
||||
const back = (bookId: string, result: ShareResult) => redirect(`/books/${bookId}/settings?share=${result}`);
|
||||
|
||||
export async function shareBook(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"), "ADMIN");
|
||||
const role = parseMemberRole(str(formData, "role"));
|
||||
if (!role) return back(book.id, "invalid");
|
||||
const result = await addMember(book.id, book.role, str(formData, "email", 200), role);
|
||||
revalidatePath(`/books/${book.id}/settings`);
|
||||
back(book.id, result);
|
||||
}
|
||||
|
||||
export async function changeMemberRole(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"), "ADMIN");
|
||||
const role = parseMemberRole(str(formData, "role"));
|
||||
if (!role) return back(book.id, "invalid");
|
||||
const result = await setMemberRole(book.id, book.role, str(formData, "userId"), role);
|
||||
revalidatePath(`/books/${book.id}/settings`);
|
||||
back(book.id, result);
|
||||
}
|
||||
|
||||
export async function removeBookMember(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"), "ADMIN");
|
||||
const result = await removeMember(book.id, book.role, str(formData, "userId"));
|
||||
revalidatePath(`/books/${book.id}/settings`);
|
||||
back(book.id, result);
|
||||
}
|
||||
|
||||
/** Den inloggade lämnar en bok som någon annan delat med hen. */
|
||||
export async function leaveSharedBook(formData: FormData) {
|
||||
const user = await requireUser();
|
||||
await leaveBook(str(formData, "bookId"), user.id);
|
||||
revalidatePath("/");
|
||||
redirect("/");
|
||||
}
|
||||
@@ -9,7 +9,7 @@ import { requireBook } from "@/lib/session";
|
||||
const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
|
||||
|
||||
export async function addShifts(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const personId = str(formData, "personId");
|
||||
const workplaceId = str(formData, "workplaceId") || null;
|
||||
const startTime = str(formData, "startTime");
|
||||
@@ -51,7 +51,7 @@ export async function addShifts(formData: FormData) {
|
||||
}
|
||||
|
||||
export async function deleteShift(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
await prisma.shift.deleteMany({ where: { id: str(formData, "id"), bookId: book.id } });
|
||||
revalidateBook(book.id);
|
||||
}
|
||||
@@ -9,7 +9,7 @@ import { requireBook } from "@/lib/session";
|
||||
import { validateFields } from "@/lib/templates";
|
||||
|
||||
export async function saveTemplate(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
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)}`;
|
||||
@@ -32,7 +32,7 @@ export async function saveTemplate(formData: FormData) {
|
||||
}
|
||||
|
||||
export async function resetTemplate(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "ADMIN");
|
||||
const kind = parseTemplateKind(str(formData, "kind"));
|
||||
if (!kind) throw new Error("Invalid kind");
|
||||
await prisma.template.deleteMany({ where: { bookId: book.id, kind } });
|
||||
|
||||
+19
-7
@@ -2,14 +2,20 @@
|
||||
|
||||
import { redirect } from "next/navigation";
|
||||
import { revalidatePath } from "next/cache";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { str } from "@/lib/form";
|
||||
import { emptyBookTrash, purgeTrashItem, restoreBook, restoreEntity } from "@/lib/trash";
|
||||
import { requireBook, requireUser } from "@/lib/session";
|
||||
|
||||
// Borttagna poster ligger i papperskorgen under bokens ägare, men återställs och rensas av bokens medlemmar:
|
||||
// redaktörer återställer, administratörer rensar. Borttagna böcker tillhör bara den som äger dem.
|
||||
|
||||
export async function restoreTrashEntity(formData: FormData) {
|
||||
const user = await requireUser();
|
||||
const restored = await restoreEntity(user.id, str(formData, "id"));
|
||||
if (!restored) redirect(`/books/${str(formData, "bookId")}/trash?restore=failed`);
|
||||
const bookId = str(formData, "bookId");
|
||||
const book = await requireBook(bookId, "EDITOR");
|
||||
const item = await prisma.trashItem.findFirst({ where: { id: str(formData, "id"), bookId: book.id, kind: "entity" }, select: { id: true } });
|
||||
const restored = item ? await restoreEntity(book.ownerId, item.id) : null;
|
||||
if (!restored) redirect(`/books/${book.id}/trash?restore=failed`);
|
||||
revalidatePath(`/books/${restored.bookId}`, "layout");
|
||||
redirect(`/books/${restored.bookId}/entity/${restored.entityId}`);
|
||||
}
|
||||
@@ -24,14 +30,20 @@ export async function restoreTrashBook(formData: FormData) {
|
||||
|
||||
export async function purgeTrash(formData: FormData) {
|
||||
const user = await requireUser();
|
||||
await purgeTrashItem(user.id, str(formData, "id"));
|
||||
const item = await prisma.trashItem.findUnique({ where: { id: str(formData, "id") } });
|
||||
if (!item) return;
|
||||
if (item.kind === "entity" && item.bookId) {
|
||||
await requireBook(item.bookId, "ADMIN");
|
||||
} else if (item.ownerId !== user.id) {
|
||||
return;
|
||||
}
|
||||
await purgeTrashItem(item.ownerId, item.id);
|
||||
revalidatePath("/");
|
||||
const bookId = str(formData, "bookId");
|
||||
if (bookId) revalidatePath(`/books/${bookId}/trash`);
|
||||
if (item.bookId) revalidatePath(`/books/${item.bookId}/trash`);
|
||||
}
|
||||
|
||||
export async function emptyTrash(formData: FormData) {
|
||||
const book = await requireBook(str(formData, "bookId"));
|
||||
const book = await requireBook(str(formData, "bookId"), "ADMIN");
|
||||
await emptyBookTrash(book.ownerId, book.id);
|
||||
revalidatePath(`/books/${book.id}/trash`);
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
"use server";
|
||||
|
||||
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";
|
||||
|
||||
export type PreviewResponse = { docs: PreviewDocument[] } | { error: "no-files" | "limit" };
|
||||
|
||||
/** Läser uppladdade Word-filer och visar vad som hittades. Ingenting sparas. */
|
||||
export async function previewWordImport(formData: FormData): Promise<PreviewResponse> {
|
||||
const book = await requireBook(str(formData, "bookId"), "EDITOR");
|
||||
const uploads = formData.getAll("files").filter((f): f is File => typeof f !== "string" && f.size > 0);
|
||||
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 files = await Promise.all(
|
||||
uploads.map(async (file) => ({
|
||||
name: file.name.slice(0, 200),
|
||||
// Stora filer läses inte alls, de rapporteras som för stora
|
||||
bytes: file.size > MAX_DOCX_BYTES ? new Uint8Array(4) : new Uint8Array(await file.arrayBuffer()),
|
||||
tooLarge: file.size > MAX_DOCX_BYTES,
|
||||
})),
|
||||
);
|
||||
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)) };
|
||||
}
|
||||
|
||||
/** 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> {
|
||||
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 });
|
||||
revalidateBook(book.id);
|
||||
return result;
|
||||
}
|
||||
+11
-2
@@ -22,9 +22,13 @@ export default async function BooksPage({
|
||||
const user = await requireUser();
|
||||
const { t } = await getT();
|
||||
const books = await prisma.book.findMany({
|
||||
where: { ownerId: user.id },
|
||||
where: { OR: [{ ownerId: user.id }, { members: { some: { userId: user.id } } }] },
|
||||
orderBy: { updatedAt: "desc" },
|
||||
include: { _count: { select: { entities: true } } },
|
||||
include: {
|
||||
_count: { select: { entities: true } },
|
||||
owner: { select: { name: true, email: true } },
|
||||
members: { where: { userId: user.id }, select: { role: true } },
|
||||
},
|
||||
});
|
||||
const trashedBooks = await prisma.trashItem.findMany({ where: { ownerId: user.id, kind: "book" }, orderBy: { deletedAt: "desc" } });
|
||||
|
||||
@@ -64,6 +68,11 @@ export default async function BooksPage({
|
||||
<div className="d-flex gap-2">
|
||||
{book.genre ? <span className="badge bg-azure-lt">{book.genre}</span> : null}
|
||||
<span className="badge">{t("books.items", { n: book._count.entities })}</span>
|
||||
{book.ownerId === user.id ? null : (
|
||||
<span className="badge bg-purple-lt" title={t("share.sharedBy", { name: book.owner.name ?? book.owner.email ?? "?" })}>
|
||||
{t("share.sharedBy", { name: book.owner.name ?? book.owner.email ?? "?" })} · {t("share.role." + (book.members[0]?.role ?? "VIEWER"))}
|
||||
</span>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
</Link>
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { strToU8, zipSync, type Zippable } from "fflate";
|
||||
import { buildExport } from "@/lib/book-transfer";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { bookAccess } from "@/lib/book-access";
|
||||
import { limitRequest } from "@/lib/rate-limit";
|
||||
import { getCurrentUser } from "@/lib/session";
|
||||
|
||||
@@ -15,7 +15,8 @@ export async function GET(req: Request, { params }: { params: Promise<{ bookId:
|
||||
if (limited) return limited;
|
||||
|
||||
const { bookId } = await params;
|
||||
const book = await prisma.book.findFirst({ where: { id: bookId, ownerId: user.id }, select: { title: true } });
|
||||
// Alla med tillgång till boken får exportera den, även läsare
|
||||
const book = await bookAccess(bookId, user.id);
|
||||
if (!book) return new Response("Not found", { status: 404 });
|
||||
|
||||
const asJson = new URL(req.url).searchParams.get("format") === "json";
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { bookAccess } from "@/lib/book-access";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { limitRequest } from "@/lib/rate-limit";
|
||||
import { getCurrentUser } from "@/lib/session";
|
||||
@@ -14,7 +15,7 @@ export async function GET(req: Request, { params }: { params: Promise<{ bookId:
|
||||
if (limited) return limited;
|
||||
|
||||
const { bookId } = await params;
|
||||
const book = await prisma.book.findFirst({ where: { id: bookId, ownerId: user.id }, select: { id: true } });
|
||||
const book = await bookAccess(bookId, user.id);
|
||||
if (!book) return new Response("Not found", { status: 404 });
|
||||
|
||||
const q = (new URL(req.url).searchParams.get("q") ?? "").trim().slice(0, 100);
|
||||
|
||||
@@ -17,7 +17,7 @@ export default async function NewEntityPage({
|
||||
}) {
|
||||
const { bookId, kind: slug } = await params;
|
||||
const { name, error } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
await requireBook(bookId, "EDITOR");
|
||||
const info = KIND_BY_SLUG.get(slug);
|
||||
if (!info) notFound();
|
||||
const { t, locale } = await getT();
|
||||
|
||||
@@ -7,6 +7,7 @@ import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { fileUrl } from "@/lib/files";
|
||||
import { KIND_BY_SLUG } from "@/lib/kinds";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
|
||||
export default async function EntityListPage({
|
||||
@@ -18,7 +19,7 @@ export default async function EntityListPage({
|
||||
}) {
|
||||
const { bookId, kind: slug } = await params;
|
||||
const { q, tag } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
const book = await requireBook(bookId);
|
||||
const info = KIND_BY_SLUG.get(slug);
|
||||
if (!info) notFound();
|
||||
const { t } = await getT();
|
||||
@@ -49,7 +50,7 @@ export default async function EntityListPage({
|
||||
<PageHeader
|
||||
title={t(`kind.${info.kind}.other`)}
|
||||
actions={
|
||||
<Link href={`${base}/new`} className="btn btn-primary">
|
||||
<Link href={`${base}/new`} className="btn btn-primary" hidden={!hasRole(book.role, "EDITOR")}>
|
||||
<IconPlus size={18} className="me-1" />
|
||||
{t(`kind.${info.kind}.new`)}
|
||||
</Link>
|
||||
@@ -124,7 +125,7 @@ export default async function EntityListPage({
|
||||
))}
|
||||
</td>
|
||||
<td className="text-end w-1">
|
||||
<Link href={`/books/${bookId}/entity/${entity.id}/edit`} className="btn btn-sm">
|
||||
<Link href={`/books/${bookId}/entity/${entity.id}/edit`} className="btn btn-sm" hidden={!hasRole(book.role, "EDITOR")}>
|
||||
{t("common.edit")}
|
||||
</Link>
|
||||
</td>
|
||||
|
||||
@@ -15,7 +15,7 @@ export default async function EditEntityPage({
|
||||
}) {
|
||||
const { bookId, entityId } = await params;
|
||||
const { error } = await searchParams;
|
||||
const entity = await requireEntity(bookId, entityId);
|
||||
const entity = await requireEntity(bookId, entityId, "EDITOR");
|
||||
const { t, locale } = await getT();
|
||||
const { fields } = await getTemplate(bookId, entity.kind, locale);
|
||||
const refEntities = await prisma.entity.findMany({
|
||||
|
||||
@@ -6,7 +6,8 @@ import { EmptyState, PageBody, PageHeader } from "@/components/page";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { diffSnapshots, MAX_VERSIONS, snapshotOf, type Snapshot } from "@/lib/history";
|
||||
import { requireEntity } from "@/lib/session";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook, requireEntity } from "@/lib/session";
|
||||
import { getTemplate } from "@/lib/templates";
|
||||
|
||||
export const metadata = { title: "Historik" };
|
||||
@@ -14,6 +15,7 @@ export const metadata = { title: "Historik" };
|
||||
export default async function HistoryPage({ params }: { params: Promise<{ bookId: string; entityId: string }> }) {
|
||||
const { bookId, entityId } = await params;
|
||||
const entity = await requireEntity(bookId, entityId);
|
||||
const canEdit = hasRole((await requireBook(bookId)).role, "EDITOR");
|
||||
const { t, locale } = await getT();
|
||||
const { fields } = await getTemplate(bookId, entity.kind, locale);
|
||||
|
||||
@@ -63,6 +65,7 @@ export default async function HistoryPage({ params }: { params: Promise<{ bookId
|
||||
) : null}
|
||||
</h3>
|
||||
<div className="card-actions">
|
||||
{canEdit ? (
|
||||
<form action={restoreVersion}>
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<input type="hidden" name="entityId" value={entityId} />
|
||||
@@ -72,6 +75,7 @@ export default async function HistoryPage({ params }: { params: Promise<{ bookId
|
||||
{t("history.restore")}
|
||||
</ConfirmSubmit>
|
||||
</form>
|
||||
) : null}
|
||||
</div>
|
||||
</div>
|
||||
<div className="list-group list-group-flush">
|
||||
|
||||
@@ -10,7 +10,8 @@ import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { fileUrl } from "@/lib/files";
|
||||
import { KIND_INFO, WORKPLACE_KINDS } from "@/lib/kinds";
|
||||
import { requireEntity } from "@/lib/session";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook, requireEntity } from "@/lib/session";
|
||||
import { formatFieldValue, getTemplate, type FieldDef } from "@/lib/templates";
|
||||
|
||||
type RefTarget = { id: string; name: string; code: string | null };
|
||||
@@ -39,6 +40,7 @@ function groupFields(fields: FieldDef[], data: Record<string, unknown>, byId: Ma
|
||||
export default async function EntityPage({ params }: { params: Promise<{ bookId: string; entityId: string }> }) {
|
||||
const { bookId, entityId } = await params;
|
||||
const base = await requireEntity(bookId, entityId);
|
||||
const canEdit = hasRole((await requireBook(bookId)).role, "EDITOR");
|
||||
const { t, locale } = await getT();
|
||||
|
||||
const [entity, template, bookEntities, maps] = await Promise.all([
|
||||
@@ -152,16 +154,19 @@ export default async function EntityPage({ params }: { params: Promise<{ bookId:
|
||||
}
|
||||
actions={
|
||||
<>
|
||||
{canEdit ? (
|
||||
<Link href={`${entityHref(entity.id)}/edit`} className="btn">
|
||||
<IconPencil size={18} className="me-1" />
|
||||
{t("common.edit")}
|
||||
</Link>
|
||||
) : null}
|
||||
{versionCount > 0 ? (
|
||||
<Link href={`${entityHref(entity.id)}/history`} className="btn">
|
||||
<IconHistory size={18} className="me-1" />
|
||||
{t("history.button", { n: versionCount })}
|
||||
</Link>
|
||||
) : null}
|
||||
{canEdit ? (
|
||||
<form action={deleteEntity}>
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<input type="hidden" name="id" value={entity.id} />
|
||||
@@ -170,6 +175,7 @@ export default async function EntityPage({ params }: { params: Promise<{ bookId:
|
||||
{t("common.delete")}
|
||||
</ConfirmSubmit>
|
||||
</form>
|
||||
) : null}
|
||||
</>
|
||||
}
|
||||
/>
|
||||
@@ -297,13 +303,15 @@ export default async function EntityPage({ params }: { params: Promise<{ bookId:
|
||||
)}
|
||||
{item.description ? <div className="text-secondary small">{item.description}</div> : null}
|
||||
</div>
|
||||
<RemoveRelation bookId={bookId} id={item.id} label={t("common.delete")} />
|
||||
{canEdit ? <RemoveRelation bookId={bookId} id={item.id} label={t("common.delete")} /> : null}
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
{canEdit ? (
|
||||
<div className="card-body border-top">
|
||||
<RelationForm bookId={bookId} entities={allEntities} fixedFromId={entity.id} t={t} />
|
||||
</div>
|
||||
) : null}
|
||||
</div>
|
||||
|
||||
{entity.kind === "CHARACTER" ? (
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
import { PageBody, PageHeader } from "@/components/page";
|
||||
import { WordImport } from "@/components/word-import";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { requireBook } from "@/lib/session";
|
||||
|
||||
export const metadata = { title: "Importera från Word" };
|
||||
|
||||
export default async function ImportWordPage({ params }: { params: Promise<{ bookId: string }> }) {
|
||||
const { bookId } = await params;
|
||||
await requireBook(bookId, "EDITOR");
|
||||
const { t } = await getT();
|
||||
|
||||
return (
|
||||
<>
|
||||
<PageHeader title={t("wordimport.title")} />
|
||||
<PageBody>
|
||||
<WordImport bookId={bookId} />
|
||||
</PageBody>
|
||||
</>
|
||||
);
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
import { Shell } from "@/components/shell";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { requireBook, requireUser } from "@/lib/session";
|
||||
|
||||
export default async function BookLayout({
|
||||
@@ -11,8 +12,16 @@ export default async function BookLayout({
|
||||
const { bookId } = await params;
|
||||
const user = await requireUser();
|
||||
const book = await requireBook(bookId);
|
||||
const { t } = await getT();
|
||||
return (
|
||||
<Shell user={user} book={{ id: book.id, title: book.title }}>
|
||||
<Shell user={user} book={{ id: book.id, title: book.title, role: book.role }}>
|
||||
{book.role === "VIEWER" ? (
|
||||
<div className="page-body pb-0 mt-3 d-print-none">
|
||||
<div className="container-xl">
|
||||
<div className="alert alert-info mb-0">{t("share.viewerNotice")}</div>
|
||||
</div>
|
||||
</div>
|
||||
) : null}
|
||||
{children}
|
||||
</Shell>
|
||||
);
|
||||
|
||||
@@ -6,6 +6,7 @@ import { PageBody, PageHeader } from "@/components/page";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { fileUrl } from "@/lib/files";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
|
||||
// Standard är OpenStreetMaps publika tjänster. Byt via miljövariabler vid tyngre användning.
|
||||
@@ -22,7 +23,7 @@ export default async function MapPage({
|
||||
}) {
|
||||
const { bookId, mapId } = await params;
|
||||
const { place, marker } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
const canEdit = hasRole((await requireBook(bookId)).role, "EDITOR");
|
||||
const { t } = await getT();
|
||||
|
||||
const [map, entities] = await Promise.all([
|
||||
@@ -47,6 +48,7 @@ export default async function MapPage({
|
||||
/>
|
||||
<PageBody>
|
||||
<MapLoader
|
||||
readOnly={!canEdit}
|
||||
bookId={bookId}
|
||||
mapId={map.id}
|
||||
kind={map.kind}
|
||||
@@ -71,7 +73,7 @@ export default async function MapPage({
|
||||
initialMarkerId={marker ?? null}
|
||||
/>
|
||||
|
||||
<div className="card mt-4">
|
||||
<div className="card mt-4" hidden={!canEdit}>
|
||||
<div className="card-header">
|
||||
<h3 className="card-title">{t("map.settings")}</h3>
|
||||
</div>
|
||||
|
||||
@@ -4,6 +4,7 @@ import { createMap } from "@/actions/maps";
|
||||
import { EmptyState, PageBody, PageHeader } from "@/components/page";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
|
||||
export const metadata = { title: "Kartor" };
|
||||
@@ -17,7 +18,7 @@ export default async function MapsPage({
|
||||
}) {
|
||||
const { bookId } = await params;
|
||||
const { error } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
const canEdit = hasRole((await requireBook(bookId)).role, "EDITOR");
|
||||
const { t } = await getT();
|
||||
const maps = await prisma.bookMap.findMany({
|
||||
where: { bookId },
|
||||
@@ -60,7 +61,7 @@ export default async function MapsPage({
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="col-lg-4">
|
||||
<div className="col-lg-4" hidden={!canEdit}>
|
||||
<form action={createMap} className="card">
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<div className="card-header">
|
||||
|
||||
@@ -5,6 +5,7 @@ import { EmptyState, PageBody, PageHeader } from "@/components/page";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { KIND_INFO, KINDS } from "@/lib/kinds";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
|
||||
export default async function BookDashboard({
|
||||
@@ -59,7 +60,7 @@ export default async function BookDashboard({
|
||||
</Link>
|
||||
<div className="text-secondary">{countOf[kind] ?? 0}</div>
|
||||
</div>
|
||||
<div className="col-auto position-relative" style={{ zIndex: 2 }}>
|
||||
<div className="col-auto position-relative" style={{ zIndex: 2 }} hidden={!hasRole(book.role, "EDITOR")}>
|
||||
<Link
|
||||
href={`/books/${bookId}/e/${slug}/new`}
|
||||
className="btn btn-icon btn-sm btn-ghost-secondary"
|
||||
@@ -97,7 +98,7 @@ export default async function BookDashboard({
|
||||
</Link>
|
||||
<div className="text-secondary">{countOf[kind] ?? 0}</div>
|
||||
</div>
|
||||
<div className="col-auto position-relative" style={{ zIndex: 2 }}>
|
||||
<div className="col-auto position-relative" style={{ zIndex: 2 }} hidden={!hasRole(book.role, "EDITOR")}>
|
||||
<Link
|
||||
href={`/books/${bookId}/e/${slug}/new`}
|
||||
className="btn btn-icon btn-sm btn-ghost-secondary"
|
||||
|
||||
@@ -4,11 +4,13 @@ import { Fragment } from "react";
|
||||
import { IconTrash } from "@tabler/icons-react";
|
||||
import { deleteRelation, saveRelation } from "@/actions/relations";
|
||||
import { ConfirmSubmit } from "@/components/confirm-submit";
|
||||
import { ConflictForm } from "@/components/conflict-form";
|
||||
import { EntitySelect } from "@/components/entity-select";
|
||||
import { FieldInput } from "@/components/entity-form";
|
||||
import { RelationBondFields } from "@/components/relation-bond-fields";
|
||||
import { PageBody, PageHeader } from "@/components/page";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { versionOf } from "@/lib/conflict";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { requireBook } from "@/lib/session";
|
||||
import { getTemplate } from "@/lib/templates";
|
||||
@@ -22,7 +24,7 @@ export default async function RelationPage({
|
||||
}) {
|
||||
const { bookId, relationId } = await params;
|
||||
const { saved } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
await requireBook(bookId, "EDITOR");
|
||||
const { t, locale } = await getT();
|
||||
|
||||
const relation = await prisma.relation.findFirst({
|
||||
@@ -95,7 +97,7 @@ export default async function RelationPage({
|
||||
/>
|
||||
<PageBody>
|
||||
{saved ? <div className="alert alert-success">{t("common.saved")}</div> : null}
|
||||
<form action={saveRelation}>
|
||||
<ConflictForm 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">
|
||||
@@ -163,7 +165,7 @@ export default async function RelationPage({
|
||||
{t("common.save")}
|
||||
</button>
|
||||
</div>
|
||||
</form>
|
||||
</ConflictForm>
|
||||
</PageBody>
|
||||
</>
|
||||
);
|
||||
|
||||
@@ -7,6 +7,7 @@ import { RelationForm } from "@/components/relation-form";
|
||||
import { RelationGraph } from "@/components/relation-graph";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
|
||||
export const metadata = { title: "Relationer" };
|
||||
@@ -20,7 +21,7 @@ export default async function RelationsPage({
|
||||
}) {
|
||||
const { bookId } = await params;
|
||||
const { entity: entityFilter } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
const canEdit = hasRole((await requireBook(bookId)).role, "EDITOR");
|
||||
const { t } = await getT();
|
||||
|
||||
const [entities, relations] = await Promise.all([
|
||||
@@ -124,7 +125,7 @@ export default async function RelationsPage({
|
||||
))}
|
||||
</td>
|
||||
<td className="text-secondary">{r.description}</td>
|
||||
<td className="w-1">
|
||||
<td className="w-1" hidden={!canEdit}>
|
||||
<form action={deleteRelation}>
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<input type="hidden" name="id" value={r.id} />
|
||||
@@ -142,7 +143,7 @@ export default async function RelationsPage({
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div className="col-lg-4">
|
||||
<div className="col-lg-4" hidden={!canEdit}>
|
||||
<div className="card">
|
||||
<div className="card-header">
|
||||
<h3 className="card-title">{t("relation.add")}</h3>
|
||||
|
||||
@@ -7,6 +7,7 @@ import type { TFunction } from "@/i18n/core";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { WORKPLACE_KINDS } from "@/lib/kinds";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
|
||||
export const metadata = { title: "Scheman" };
|
||||
@@ -28,11 +29,13 @@ function ShiftChip({
|
||||
shift,
|
||||
bookId,
|
||||
t,
|
||||
canEdit,
|
||||
showPerson,
|
||||
}: {
|
||||
shift: ShiftRow;
|
||||
bookId: string;
|
||||
t: TFunction;
|
||||
canEdit: boolean;
|
||||
showPerson?: boolean;
|
||||
}) {
|
||||
return (
|
||||
@@ -65,6 +68,7 @@ function ShiftChip({
|
||||
))}
|
||||
</div>
|
||||
</div>
|
||||
{canEdit ? (
|
||||
<form action={deleteShift}>
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<input type="hidden" name="id" value={shift.id} />
|
||||
@@ -72,6 +76,7 @@ function ShiftChip({
|
||||
<IconX size={14} />
|
||||
</button>
|
||||
</form>
|
||||
) : null}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -86,7 +91,7 @@ export default async function SchedulesPage({
|
||||
const { bookId } = await params;
|
||||
const { view = "person", range: rangeParam, person, workplace } = await searchParams;
|
||||
const range = rangeParam === "night" ? "night" : "day";
|
||||
await requireBook(bookId);
|
||||
const canEdit = hasRole((await requireBook(bookId)).role, "EDITOR");
|
||||
const { t } = await getT();
|
||||
|
||||
const [people, workplaces, shifts] = await Promise.all([
|
||||
@@ -275,7 +280,7 @@ export default async function SchedulesPage({
|
||||
{shifts
|
||||
.filter((s) => s.weekday === d)
|
||||
.map((s) => (
|
||||
<ShiftChip key={s.id} shift={s} bookId={bookId} t={t} showPerson />
|
||||
<ShiftChip key={s.id} shift={s} bookId={bookId} t={t} canEdit={canEdit} showPerson />
|
||||
))}
|
||||
</td>
|
||||
))}
|
||||
@@ -314,7 +319,7 @@ export default async function SchedulesPage({
|
||||
{rowShifts
|
||||
.filter((s) => s.weekday === d)
|
||||
.map((s) => (
|
||||
<ShiftChip key={s.id} shift={s} bookId={bookId} t={t} />
|
||||
<ShiftChip key={s.id} shift={s} bookId={bookId} t={t} canEdit={canEdit} />
|
||||
))}
|
||||
</td>
|
||||
))}
|
||||
@@ -332,7 +337,7 @@ export default async function SchedulesPage({
|
||||
<div className="card-header">
|
||||
<h3 className="card-title">{t("schedule.add")}</h3>
|
||||
</div>
|
||||
{people.length === 0 ? (
|
||||
{!canEdit ? null : people.length === 0 ? (
|
||||
<div className="card-body text-secondary">{t("schedule.noPeople")}</div>
|
||||
) : (
|
||||
<form action={addShifts}>
|
||||
|
||||
@@ -1,16 +1,32 @@
|
||||
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 { PageBody, PageHeader } from "@/components/page";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { MEMBER_ROLES, canChangeMember, hasRole, manageableRoles } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
import { SHARE_RESULTS, listMembers, type ShareResult } from "@/lib/sharing";
|
||||
|
||||
export const metadata = { title: "Bokinställningar" };
|
||||
|
||||
export default async function SettingsPage({ params }: { params: Promise<{ bookId: string }> }) {
|
||||
export default async function SettingsPage({
|
||||
params,
|
||||
searchParams,
|
||||
}: {
|
||||
params: Promise<{ bookId: string }>;
|
||||
searchParams: Promise<{ share?: string }>;
|
||||
}) {
|
||||
const { bookId } = await params;
|
||||
const { share } = await searchParams;
|
||||
const book = await requireBook(bookId);
|
||||
const { t } = await getT();
|
||||
const isAdmin = hasRole(book.role, "ADMIN");
|
||||
const isOwner = book.role === "OWNER";
|
||||
const { owner, members } = await listMembers(book.id);
|
||||
const result = SHARE_RESULTS.includes(share as ShareResult) ? (share as ShareResult) : null;
|
||||
const grantable = manageableRoles(book.role);
|
||||
const person = (u: { name: string | null; email: string | null }) => u.name ?? u.email ?? "?";
|
||||
|
||||
return (
|
||||
<>
|
||||
@@ -18,9 +34,11 @@ export default async function SettingsPage({ params }: { params: Promise<{ bookI
|
||||
<PageBody>
|
||||
<div className="row row-cards">
|
||||
<div className="col-lg-8">
|
||||
<form action={updateBook} className="card">
|
||||
<form action={updateBook} className="card mb-3">
|
||||
<input type="hidden" name="bookId" value={book.id} />
|
||||
<fieldset disabled={!isAdmin}>
|
||||
<div className="card-body">
|
||||
{isAdmin ? null : <p className="text-secondary">{t("settings.readOnly")}</p>}
|
||||
<div className="row g-3">
|
||||
<div className="col-md-6">
|
||||
<label className="form-label required">{t("common.title")}</label>
|
||||
@@ -40,12 +58,121 @@ export default async function SettingsPage({ params }: { params: Promise<{ bookI
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
{isAdmin ? (
|
||||
<div className="card-footer text-end">
|
||||
<button type="submit" className="btn btn-primary">
|
||||
{t("common.save")}
|
||||
</button>
|
||||
</div>
|
||||
) : null}
|
||||
</fieldset>
|
||||
</form>
|
||||
|
||||
<div className="card">
|
||||
<div className="card-header">
|
||||
<h3 className="card-title">{t("share.title")}</h3>
|
||||
</div>
|
||||
<div className="card-body">
|
||||
<p className="text-secondary">{t("share.help")}</p>
|
||||
<p className="text-secondary small">{t("share.roles")}</p>
|
||||
{result ? <div className={`alert alert-${result === "ok" ? "success" : "warning"}`}>{t(`share.result.${result}`)}</div> : null}
|
||||
</div>
|
||||
<div className="table-responsive">
|
||||
<table className="table table-vcenter card-table">
|
||||
<tbody>
|
||||
<tr>
|
||||
<td>
|
||||
<div className="fw-bold">{person(owner)}</div>
|
||||
{owner.email && owner.name ? <div className="text-secondary small">{owner.email}</div> : null}
|
||||
</td>
|
||||
<td>
|
||||
<span className="badge bg-primary-lt">{t("share.role.OWNER")}</span>
|
||||
</td>
|
||||
<td className="w-1" />
|
||||
</tr>
|
||||
{members.map((m) => {
|
||||
const manageable = isAdmin && canChangeMember(book.role, m.role, null);
|
||||
return (
|
||||
<tr key={m.id}>
|
||||
<td>
|
||||
<div className="fw-bold">
|
||||
{person(m.user)}
|
||||
{m.userId === book.userId ? <span className="text-secondary fw-normal"> ({t("share.you")})</span> : null}
|
||||
</div>
|
||||
{m.user.email && m.user.name ? <div className="text-secondary small">{m.user.email}</div> : null}
|
||||
</td>
|
||||
<td>
|
||||
{manageable ? (
|
||||
<form action={changeMemberRole} className="d-flex gap-2">
|
||||
<input type="hidden" name="bookId" value={book.id} />
|
||||
<input type="hidden" name="userId" value={m.userId} />
|
||||
<select name="role" className="form-select form-select-sm" defaultValue={m.role}>
|
||||
{MEMBER_ROLES.filter((r) => grantable.includes(r)).map((r) => (
|
||||
<option key={r} value={r}>
|
||||
{t(`share.role.${r}`)}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
<button type="submit" className="btn btn-sm">
|
||||
{t("common.save")}
|
||||
</button>
|
||||
</form>
|
||||
) : (
|
||||
<span className="badge">{t(`share.role.${m.role}`)}</span>
|
||||
)}
|
||||
</td>
|
||||
<td className="w-1">
|
||||
{manageable ? (
|
||||
<form action={removeBookMember}>
|
||||
<input type="hidden" name="bookId" value={book.id} />
|
||||
<input type="hidden" name="userId" value={m.userId} />
|
||||
<ConfirmSubmit className="btn btn-sm btn-outline-danger" message={t("share.removeConfirm")}>
|
||||
{t("share.remove")}
|
||||
</ConfirmSubmit>
|
||||
</form>
|
||||
) : null}
|
||||
</td>
|
||||
</tr>
|
||||
);
|
||||
})}
|
||||
{members.length === 0 ? (
|
||||
<tr>
|
||||
<td colSpan={3} className="text-secondary">
|
||||
{t("share.nobody")}
|
||||
</td>
|
||||
</tr>
|
||||
) : null}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
{isAdmin ? (
|
||||
<form action={shareBook} className="card-body border-top">
|
||||
<input type="hidden" name="bookId" value={book.id} />
|
||||
<div className="row g-2 align-items-end">
|
||||
<div className="col-md-6">
|
||||
<label className="form-label">{t("share.email")}</label>
|
||||
<input type="email" name="email" className="form-control" required maxLength={200} />
|
||||
<div className="form-hint">{t("share.emailHelp")}</div>
|
||||
</div>
|
||||
<div className="col-md-4">
|
||||
<label className="form-label">{t("share.role")}</label>
|
||||
<select name="role" className="form-select" defaultValue="EDITOR">
|
||||
{MEMBER_ROLES.filter((r) => grantable.includes(r)).map((r) => (
|
||||
<option key={r} value={r}>
|
||||
{t(`share.role.${r}`)}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</div>
|
||||
<div className="col-md-2 text-end">
|
||||
<button type="submit" className="btn btn-primary w-100">
|
||||
{t("share.add")}
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</form>
|
||||
) : null}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div className="col-lg-4">
|
||||
@@ -64,6 +191,7 @@ export default async function SettingsPage({ params }: { params: Promise<{ bookI
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
{isOwner ? (
|
||||
<div className="card border-danger">
|
||||
<div className="card-header">
|
||||
<h3 className="card-title text-danger">{t("settings.danger")}</h3>
|
||||
@@ -74,6 +202,17 @@ export default async function SettingsPage({ params }: { params: Promise<{ bookI
|
||||
<ConfirmSubmit>{t("settings.deleteBook")}</ConfirmSubmit>
|
||||
</form>
|
||||
</div>
|
||||
) : (
|
||||
<div className="card">
|
||||
<form action={leaveSharedBook} className="card-body">
|
||||
<input type="hidden" name="bookId" value={book.id} />
|
||||
<p className="text-secondary">{t("share.leaveHelp", { owner: person(owner) })}</p>
|
||||
<ConfirmSubmit className="btn btn-outline-danger" message={t("share.leaveConfirm")}>
|
||||
{t("share.leave")}
|
||||
</ConfirmSubmit>
|
||||
</form>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
</div>
|
||||
</PageBody>
|
||||
|
||||
@@ -15,7 +15,7 @@ export default async function TemplateEditPage({
|
||||
}) {
|
||||
const { bookId, kind: slug } = await params;
|
||||
const { error, saved } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
await requireBook(bookId, "ADMIN");
|
||||
const kind = templateKindFromSlug(slug);
|
||||
if (!kind) notFound();
|
||||
const { t, locale } = await getT();
|
||||
|
||||
@@ -11,7 +11,7 @@ export const metadata = { title: "Mallar" };
|
||||
|
||||
export default async function TemplatesPage({ params }: { params: Promise<{ bookId: string }> }) {
|
||||
const { bookId } = await params;
|
||||
await requireBook(bookId);
|
||||
await requireBook(bookId, "ADMIN");
|
||||
const { t, locale } = await getT();
|
||||
|
||||
const kinds: { kind: TemplateKind; color: string }[] = [
|
||||
|
||||
@@ -3,10 +3,12 @@ import { notFound } from "next/navigation";
|
||||
import { IconTrash } from "@tabler/icons-react";
|
||||
import { deleteEvent, saveEvent } from "@/actions/events";
|
||||
import { ConfirmSubmit } from "@/components/confirm-submit";
|
||||
import { ConflictForm } from "@/components/conflict-form";
|
||||
import { EntitySelect } from "@/components/entity-select";
|
||||
import { PageBody, PageHeader } from "@/components/page";
|
||||
import { StoryDateInput } from "@/components/story-date-input";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { versionOf } from "@/lib/conflict";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { requireBook } from "@/lib/session";
|
||||
|
||||
@@ -19,7 +21,7 @@ export default async function EventPage({
|
||||
}) {
|
||||
const { bookId, eventId } = await params;
|
||||
const { saved, error } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
await requireBook(bookId, "EDITOR");
|
||||
const { t } = await getT();
|
||||
|
||||
const event = await prisma.storyEvent.findFirst({ where: { id: eventId, bookId }, include: { participants: true } });
|
||||
@@ -49,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}
|
||||
<form action={saveEvent}>
|
||||
<ConflictForm 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">
|
||||
@@ -88,7 +90,7 @@ export default async function EventPage({
|
||||
{t("common.save")}
|
||||
</button>
|
||||
</div>
|
||||
</form>
|
||||
</ConflictForm>
|
||||
</PageBody>
|
||||
</>
|
||||
);
|
||||
|
||||
@@ -5,6 +5,7 @@ import { EmptyState, PageBody, PageHeader } from "@/components/page";
|
||||
import { StoryDateInput } from "@/components/story-date-input";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
import { storyYear } from "@/lib/story-date";
|
||||
import { loadTimeline, TIMELINE_KINDS, type TimelineItem, type TimelineKind } from "@/lib/timeline";
|
||||
@@ -28,7 +29,7 @@ export default async function TimelinePage({
|
||||
}) {
|
||||
const { bookId } = await params;
|
||||
const { person, kind, error } = await searchParams;
|
||||
await requireBook(bookId);
|
||||
const canEdit = hasRole((await requireBook(bookId)).role, "EDITOR");
|
||||
const { t } = await getT();
|
||||
|
||||
const wanted = (Array.isArray(kind) ? kind : kind ? [kind] : []).filter((k): k is TimelineKind => (TIMELINE_KINDS as string[]).includes(k));
|
||||
@@ -184,7 +185,7 @@ export default async function TimelinePage({
|
||||
) : null}
|
||||
</div>
|
||||
|
||||
<div className="col-lg-4">
|
||||
<div className="col-lg-4" hidden={!canEdit}>
|
||||
<div className="card">
|
||||
<div className="card-header">
|
||||
<h3 className="card-title">{t("timeline.addEvent")}</h3>
|
||||
|
||||
@@ -7,6 +7,7 @@ import { EmptyState, PageBody, PageHeader } from "@/components/page";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { KIND_INFO, parseKind } from "@/lib/kinds";
|
||||
import { hasRole } from "@/lib/access";
|
||||
import { requireBook } from "@/lib/session";
|
||||
import { TRASH_DAYS } from "@/lib/trash";
|
||||
|
||||
@@ -22,6 +23,8 @@ export default async function TrashPage({
|
||||
const { bookId } = await params;
|
||||
const { restore } = await searchParams;
|
||||
const book = await requireBook(bookId);
|
||||
const canRestore = hasRole(book.role, "EDITOR");
|
||||
const canPurge = hasRole(book.role, "ADMIN");
|
||||
const { t } = await getT();
|
||||
const items = await prisma.trashItem.findMany({
|
||||
where: { ownerId: book.ownerId, bookId, kind: "entity" },
|
||||
@@ -33,7 +36,7 @@ export default async function TrashPage({
|
||||
<PageHeader
|
||||
title={t("trash.title")}
|
||||
actions={
|
||||
items.length > 0 ? (
|
||||
items.length > 0 && canPurge ? (
|
||||
<form action={emptyTrash}>
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<ConfirmSubmit className="btn btn-outline-danger" message={t("trash.emptyConfirm")}>
|
||||
@@ -72,7 +75,7 @@ export default async function TrashPage({
|
||||
{t("trash.daysLeft", { n: daysLeft })}
|
||||
</div>
|
||||
</div>
|
||||
<form action={restoreTrashEntity}>
|
||||
<form action={restoreTrashEntity} hidden={!canRestore}>
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<input type="hidden" name="id" value={item.id} />
|
||||
<button type="submit" className="btn btn-sm">
|
||||
@@ -80,7 +83,7 @@ export default async function TrashPage({
|
||||
{t("trash.restore")}
|
||||
</button>
|
||||
</form>
|
||||
<form action={purgeTrash}>
|
||||
<form action={purgeTrash} hidden={!canPurge}>
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<input type="hidden" name="id" value={item.id} />
|
||||
<ConfirmSubmit className="btn btn-sm btn-outline-danger" message={t("trash.purgeConfirm")}>
|
||||
|
||||
@@ -0,0 +1,98 @@
|
||||
"use client";
|
||||
|
||||
import { useRef, useState, useTransition, type ReactNode } from "react";
|
||||
import { useT } from "@/i18n/client";
|
||||
import type { ConflictInfo, SaveResult } from "@/lib/conflict";
|
||||
|
||||
/**
|
||||
* Formulär som skickas med en sparåtgärd och klarar att någon annan hunnit ändra samma sak.
|
||||
* Formuläret skickas med versionen det öppnades med. Om åtgärden svarar med en krock visas en ruta ovanför
|
||||
* formuläret, och det användaren skrivit finns kvar tills hen väljer att spara ändå eller ladda om.
|
||||
*/
|
||||
export function ConflictForm({
|
||||
action,
|
||||
version,
|
||||
children,
|
||||
className,
|
||||
}: {
|
||||
action: (formData: FormData) => Promise<SaveResult | void>;
|
||||
/** Versionen av det som redigeras, tom för nya poster */
|
||||
version: string;
|
||||
children: ReactNode;
|
||||
className?: string;
|
||||
}) {
|
||||
const t = useT();
|
||||
const formRef = useRef<HTMLFormElement>(null);
|
||||
const [conflict, setConflict] = useState<ConflictInfo | null>(null);
|
||||
const [pending, startTransition] = useTransition();
|
||||
|
||||
// Skickas för hand i stället för via form action, eftersom React annars tömmer formuläret efter åtgärden
|
||||
function submit(overrideVersion?: string) {
|
||||
const form = formRef.current;
|
||||
if (!form) return;
|
||||
const data = new FormData(form);
|
||||
if (overrideVersion) data.set("version", overrideVersion);
|
||||
startTransition(async () => {
|
||||
const result = await action(data);
|
||||
setConflict(result && "conflict" in result ? result.conflict : null);
|
||||
});
|
||||
}
|
||||
|
||||
const time = conflict ? new Date(conflict.at).toLocaleString() : "";
|
||||
|
||||
return (
|
||||
<form
|
||||
ref={formRef}
|
||||
className={className}
|
||||
onSubmit={(event) => {
|
||||
event.preventDefault();
|
||||
if (!pending) submit();
|
||||
}}
|
||||
>
|
||||
<input type="hidden" name="version" defaultValue={version} />
|
||||
{conflict ? (
|
||||
<div className="alert alert-warning" role="alert">
|
||||
<h4 className="alert-title">{t("conflict.title")}</h4>
|
||||
<div className="mb-2">{conflict.by ? t("conflict.by", { name: conflict.by, time }) : t("conflict.byUnknown", { time })}</div>
|
||||
{conflict.changes.length > 0 ? (
|
||||
<>
|
||||
<div className="mb-1">{t("conflict.diff")}</div>
|
||||
<div className="table-responsive bg-body rounded mb-2">
|
||||
<table className="table table-sm mb-0">
|
||||
<thead>
|
||||
<tr>
|
||||
<th />
|
||||
<th>{t("conflict.saved")}</th>
|
||||
<th>{t("conflict.yours")}</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{conflict.changes.slice(0, 12).map((c) => (
|
||||
<tr key={c.label}>
|
||||
<td className="fw-bold">{c.label}</td>
|
||||
<td className="text-break">{c.before || <span className="text-secondary">{t("conflict.empty")}</span>}</td>
|
||||
<td className="text-break">{c.after || <span className="text-secondary">{t("conflict.empty")}</span>}</td>
|
||||
</tr>
|
||||
))}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
</>
|
||||
) : null}
|
||||
<div className="d-flex flex-wrap gap-2 align-items-center">
|
||||
<button type="button" className="btn btn-warning" disabled={pending} onClick={() => submit(conflict.version)}>
|
||||
{t("conflict.overwrite")}
|
||||
</button>
|
||||
<button type="button" className="btn" onClick={() => window.location.reload()}>
|
||||
{t("conflict.reload")}
|
||||
</button>
|
||||
</div>
|
||||
<div className="text-secondary small mt-2">
|
||||
{t("conflict.overwriteHelp")} {t("conflict.reloadHelp")}
|
||||
</div>
|
||||
</div>
|
||||
) : null}
|
||||
{children}
|
||||
</form>
|
||||
);
|
||||
}
|
||||
@@ -2,6 +2,8 @@ import { Fragment } from "react";
|
||||
import Link from "next/link";
|
||||
import type { Entity, EntityKind } from "@prisma/client";
|
||||
import type { TFunction } from "@/i18n/core";
|
||||
import { versionOf, type SaveResult } from "@/lib/conflict";
|
||||
import { ConflictForm } from "./conflict-form";
|
||||
import { NameFill } from "./name-fill";
|
||||
import { StoryDateInput } from "./story-date-input";
|
||||
import { fileUrl } from "@/lib/files";
|
||||
@@ -99,7 +101,7 @@ export function EntityForm({
|
||||
refEntities,
|
||||
t,
|
||||
}: {
|
||||
action: (formData: FormData) => Promise<void>;
|
||||
action: (formData: FormData) => Promise<SaveResult | void>;
|
||||
bookId: string;
|
||||
kind: EntityKind;
|
||||
entity?: Entity;
|
||||
@@ -113,7 +115,7 @@ export function EntityForm({
|
||||
const image = fileUrl(entity?.imageFile, "thumb");
|
||||
|
||||
return (
|
||||
<form action={action}>
|
||||
<ConflictForm action={action} version={entity ? versionOf(entity.updatedAt) : ""}>
|
||||
<input type="hidden" name="bookId" value={bookId} />
|
||||
<input type="hidden" name="kind" value={kind} />
|
||||
{entity ? <input type="hidden" name="id" value={entity.id} /> : null}
|
||||
@@ -205,6 +207,6 @@ export function EntityForm({
|
||||
{t("common.save")}
|
||||
</button>
|
||||
</div>
|
||||
</form>
|
||||
</ConflictForm>
|
||||
);
|
||||
}
|
||||
@@ -37,6 +37,8 @@ export type MapViewProps = {
|
||||
geocoderUrl: string;
|
||||
preselectEntityId: string | null;
|
||||
initialMarkerId: string | null;
|
||||
/** Läsare ser kartan och markeringarna men kan inte ändra något */
|
||||
readOnly?: boolean;
|
||||
};
|
||||
|
||||
type Draft = {
|
||||
@@ -65,6 +67,7 @@ function pinIcon(color: string, highlight = false) {
|
||||
|
||||
export default function MapView(props: MapViewProps) {
|
||||
const { bookId, mapId, kind, imageUrl, markers, entities } = props;
|
||||
const readOnly = props.readOnly ?? false;
|
||||
const t = useT();
|
||||
const router = useRouter();
|
||||
const [pending, startTransition] = useTransition();
|
||||
@@ -93,7 +96,7 @@ export default function MapView(props: MapViewProps) {
|
||||
const entityName = (id: string) => entities.find((e) => e.id === id)?.name ?? "";
|
||||
|
||||
handlers.current.mapClick = (lat, lng) => {
|
||||
if (!adding) return;
|
||||
if (readOnly || !adding) return;
|
||||
const pre = initial.current.place ?? "";
|
||||
setDraft({ id: null, label: pre ? entityName(pre) : "", note: "", color: "blue", entityId: pre, lat, lng });
|
||||
setAdding(false);
|
||||
@@ -171,7 +174,7 @@ export default function MapView(props: MapViewProps) {
|
||||
const icon = pinIcon(m.color, m.id === draftId);
|
||||
let lm = layers.get(m.id);
|
||||
if (!lm) {
|
||||
const created = L.marker([m.lat, m.lng], { icon, draggable: true, autoPan: true }).addTo(map);
|
||||
const created = L.marker([m.lat, m.lng], { icon, draggable: !readOnly, autoPan: true }).addTo(map);
|
||||
created.on("click", () => handlers.current.openMarker(m.id));
|
||||
created.on("dragend", () => {
|
||||
const p = created.getLatLng();
|
||||
@@ -319,6 +322,7 @@ export default function MapView(props: MapViewProps) {
|
||||
<div className="col-lg-4">
|
||||
<div className="card mb-3">
|
||||
<div className="card-body d-flex flex-wrap gap-2 align-items-center">
|
||||
{readOnly ? null : (
|
||||
<button
|
||||
type="button"
|
||||
className={`btn ${adding ? "btn-warning" : "btn-primary"}`}
|
||||
@@ -330,13 +334,14 @@ export default function MapView(props: MapViewProps) {
|
||||
{adding ? <IconX size={18} className="me-1" /> : <IconPlus size={18} className="me-1" />}
|
||||
{adding ? t("map.cancelAdd") : t("map.addMarker")}
|
||||
</button>
|
||||
{kind === "GEO" ? (
|
||||
)}
|
||||
{kind === "GEO" && !readOnly ? (
|
||||
<button type="button" className="btn" onClick={persistView} disabled={pending}>
|
||||
<IconCurrentLocation size={18} className="me-1" />
|
||||
{viewSaved ? t("map.viewSaved") : t("map.saveView")}
|
||||
</button>
|
||||
) : null}
|
||||
<div className="w-100 text-secondary small">{adding ? t("map.addHint") : t("map.dragHint")}</div>
|
||||
{readOnly ? null : <div className="w-100 text-secondary small">{adding ? t("map.addHint") : t("map.dragHint")}</div>}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -379,6 +384,7 @@ export default function MapView(props: MapViewProps) {
|
||||
</div>
|
||||
) : null}
|
||||
</div>
|
||||
<fieldset disabled={readOnly}>
|
||||
<div className="card-body">
|
||||
<div className="mb-3">
|
||||
<label className="form-label required">{t("map.markerLabel")}</label>
|
||||
@@ -448,18 +454,21 @@ export default function MapView(props: MapViewProps) {
|
||||
</div>
|
||||
) : null}
|
||||
</div>
|
||||
</fieldset>
|
||||
<div className="card-footer d-flex gap-2">
|
||||
{draft.id ? (
|
||||
{draft.id && !readOnly ? (
|
||||
<button type="button" className="btn btn-outline-danger" onClick={removeDraft} disabled={pending}>
|
||||
{t("common.delete")}
|
||||
</button>
|
||||
) : null}
|
||||
<button type="button" className="btn ms-auto" onClick={() => setDraft(null)}>
|
||||
{t("common.cancel")}
|
||||
{readOnly ? t("common.back") : t("common.cancel")}
|
||||
</button>
|
||||
{readOnly ? null : (
|
||||
<button type="submit" className="btn btn-primary" disabled={pending}>
|
||||
{t("common.save")}
|
||||
</button>
|
||||
)}
|
||||
</div>
|
||||
</form>
|
||||
) : null}
|
||||
|
||||
@@ -4,6 +4,7 @@ import {
|
||||
IconBook2,
|
||||
IconCalendarWeek,
|
||||
IconDice5,
|
||||
IconFileImport,
|
||||
IconChartDots3,
|
||||
IconLayoutDashboard,
|
||||
IconListDetails,
|
||||
@@ -21,6 +22,7 @@ import type { ReactNode } from "react";
|
||||
import { signOut } from "@/auth";
|
||||
import { setLocale } from "@/actions/settings";
|
||||
import { getT } from "@/i18n/server";
|
||||
import { hasRole, type BookRole } from "@/lib/access";
|
||||
import { isAdminUser } from "@/lib/admin";
|
||||
import { APP_VERSION_LABEL } from "@/lib/version";
|
||||
import { LOCALES } from "@/i18n/core";
|
||||
@@ -32,7 +34,7 @@ import { ThemeToggle } from "./theme-toggle";
|
||||
|
||||
type ShellProps = {
|
||||
user: { id: string; name?: string | null; email?: string | null };
|
||||
book?: { id: string; title: string };
|
||||
book?: { id: string; title: string; role?: BookRole };
|
||||
children: ReactNode;
|
||||
};
|
||||
|
||||
@@ -40,6 +42,8 @@ export async function Shell({ user, book, children }: ShellProps) {
|
||||
const { t, locale } = await getT();
|
||||
const base = book ? `/books/${book.id}` : "";
|
||||
const admin = await isAdminUser(user.id, user.email ?? null);
|
||||
const canEdit = !book || hasRole(book.role ?? "VIEWER", "EDITOR");
|
||||
const bookAdmin = !book || hasRole(book.role ?? "VIEWER", "ADMIN");
|
||||
|
||||
// Sidor och "skapa ny" för kommandopaletten (Ctrl+K)
|
||||
const pages = [
|
||||
@@ -54,15 +58,16 @@ export async function Shell({ user, book, children }: ShellProps) {
|
||||
{ label: t("nav.schedules"), href: `${base}/schedules` },
|
||||
{ label: t("nav.maps"), href: `${base}/maps` },
|
||||
{ label: t("nav.names"), href: `${base}/names` },
|
||||
...(canEdit ? [{ label: t("nav.importWord"), href: `${base}/import-word` }] : []),
|
||||
{ label: t("nav.idRegister"), href: `${base}/register` },
|
||||
{ label: t("nav.templates"), href: `${base}/templates` },
|
||||
...(bookAdmin ? [{ label: t("nav.templates"), href: `${base}/templates` }] : []),
|
||||
{ label: t("nav.trash"), href: `${base}/trash` },
|
||||
{ label: t("nav.settings"), href: `${base}/settings` },
|
||||
]
|
||||
: [{ label: t("nav.books"), href: "/" }]),
|
||||
...(admin ? [{ label: t("nav.admin"), href: "/admin" }] : []),
|
||||
];
|
||||
const creates = book ? KINDS.map((k) => ({ label: t(`kind.${k.kind}.new`), href: `${base}/e/${k.slug}/new` })) : [];
|
||||
const creates = book && canEdit ? KINDS.map((k) => ({ label: t(`kind.${k.kind}.new`), href: `${base}/e/${k.slug}/new` })) : [];
|
||||
|
||||
return (
|
||||
<div className="page">
|
||||
@@ -161,9 +166,16 @@ export async function Shell({ user, book, children }: ShellProps) {
|
||||
<NavLink href={`${base}/names`} icon={<IconDice5 size={20} />}>
|
||||
{t("nav.names")}
|
||||
</NavLink>
|
||||
{canEdit ? (
|
||||
<NavLink href={`${base}/import-word`} icon={<IconFileImport size={20} />}>
|
||||
{t("nav.importWord")}
|
||||
</NavLink>
|
||||
) : null}
|
||||
{bookAdmin ? (
|
||||
<NavLink href={`${base}/templates`} icon={<IconTemplate size={20} />}>
|
||||
{t("nav.templates")}
|
||||
</NavLink>
|
||||
) : null}
|
||||
<NavLink href={`${base}/trash`} icon={<IconTrash size={20} />}>
|
||||
{t("nav.trash")}
|
||||
</NavLink>
|
||||
|
||||
@@ -0,0 +1,263 @@
|
||||
"use client";
|
||||
|
||||
import Link from "next/link";
|
||||
import { useState, useTransition } from "react";
|
||||
import { previewWordImport, saveWordImport } from "@/actions/word-import";
|
||||
import { useT } from "@/i18n/client";
|
||||
import type { ImportKind } 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 SHOWN_ITEMS = 40;
|
||||
|
||||
type Decision = { include: boolean; name: string };
|
||||
|
||||
/** Importerar ifyllda Word-mallar: ladda upp, granska vad som hittades, bekräfta. Inget sparas före bekräftelsen. */
|
||||
export function WordImport({ bookId }: { bookId: string }) {
|
||||
const t = useT();
|
||||
const [files, setFiles] = useState<File[]>([]);
|
||||
const [kinds, setKinds] = useState<string[]>([]);
|
||||
const [docs, setDocs] = useState<PreviewDocument[] | null>(null);
|
||||
const [decisions, setDecisions] = useState<Decision[][]>([]);
|
||||
const [append, setAppend] = useState(true);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [result, setResult] = useState<CommitResult | null>(null);
|
||||
const [pending, startTransition] = useTransition();
|
||||
|
||||
function review(selected: File[], chosenKinds: string[]) {
|
||||
setError(null);
|
||||
setResult(null);
|
||||
const data = new FormData();
|
||||
data.set("bookId", bookId);
|
||||
selected.forEach((file, i) => {
|
||||
data.append("files", file);
|
||||
data.append("kinds", chosenKinds[i] ?? "");
|
||||
});
|
||||
startTransition(async () => {
|
||||
const response = await previewWordImport(data);
|
||||
if ("error" in response) {
|
||||
setError(t(`wordimport.error.${response.error}`));
|
||||
setDocs(null);
|
||||
return;
|
||||
}
|
||||
setDocs(response.docs);
|
||||
// Poster som redan finns är avmarkerade, och relationer utan två kända deltagare går inte att importera
|
||||
setDecisions(
|
||||
response.docs.map((doc) =>
|
||||
doc.items.map((item) => ({
|
||||
include: !doc.error && item.name !== "" && item.duplicates.length === 0 && (item.entityKind !== "RELATION" || (doc.relation?.participants.filter((p) => p.entityId).length ?? 0) >= 2),
|
||||
name: item.name,
|
||||
})),
|
||||
),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function update(doc: number, item: number, change: Partial<Decision>) {
|
||||
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 commit() {
|
||||
if (!docs) return;
|
||||
const items = docs.flatMap((doc, d) =>
|
||||
doc.items.map((item, i) => ({
|
||||
include: decisions[d]?.[i]?.include ?? false,
|
||||
entityKind: item.entityKind,
|
||||
name: decisions[d]?.[i]?.name ?? item.name,
|
||||
code: item.code,
|
||||
data: item.data,
|
||||
links: item.links,
|
||||
unmatched: item.unmatched,
|
||||
participants: item.entityKind === "RELATION" ? (doc.relation?.participants.map((p) => p.entityId).filter((id): id is string => !!id) ?? []) : undefined,
|
||||
})),
|
||||
);
|
||||
startTransition(async () => {
|
||||
setResult(await saveWordImport({ bookId, items, appendUnmatched: append }));
|
||||
setDocs(null);
|
||||
setFiles([]);
|
||||
setKinds([]);
|
||||
});
|
||||
}
|
||||
|
||||
return (
|
||||
<div>
|
||||
<div className="card mb-3">
|
||||
<div className="card-body">
|
||||
<p className="text-secondary">{t("wordimport.help")}</p>
|
||||
<p className="text-secondary small">{t("wordimport.helpFormat")}</p>
|
||||
<div className="row g-2 align-items-end">
|
||||
<div className="col-md-8">
|
||||
<label className="form-label">{t("wordimport.choose")}</label>
|
||||
<input
|
||||
type="file"
|
||||
className="form-control"
|
||||
multiple
|
||||
accept=".docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document"
|
||||
onChange={(e) => {
|
||||
setFiles(Array.from(e.target.files ?? []));
|
||||
setKinds([]);
|
||||
setDocs(null);
|
||||
setResult(null);
|
||||
}}
|
||||
/>
|
||||
</div>
|
||||
<div className="col-md-4">
|
||||
<button type="button" className="btn btn-primary w-100" disabled={pending || files.length === 0} onClick={() => review(files, kinds)}>
|
||||
{pending && !docs ? t("wordimport.reading") : t("wordimport.review")}
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
{error ? <div className="alert alert-danger mt-3 mb-0">{error}</div> : null}
|
||||
</div>
|
||||
</div>
|
||||
|
||||
{result ? (
|
||||
<div className="alert alert-success">
|
||||
{t("wordimport.done", { created: result.created, relations: result.relations, skipped: result.skipped })}{" "}
|
||||
<Link href={`/books/${bookId}`}>{t("common.back")}</Link>
|
||||
</div>
|
||||
) : null}
|
||||
|
||||
{docs?.map((doc, d) => (
|
||||
<div className="card mb-3" key={`${doc.file}-${d}`}>
|
||||
<div className="card-header">
|
||||
<h3 className="card-title text-truncate">{doc.file}</h3>
|
||||
{doc.error ? null : (
|
||||
<div className="card-actions d-flex align-items-center gap-2">
|
||||
<label className="form-label mb-0 text-secondary small">{t("wordimport.docType")}</label>
|
||||
<select
|
||||
className="form-select form-select-sm w-auto"
|
||||
value={doc.kind ?? ""}
|
||||
disabled={pending}
|
||||
onChange={(e) => {
|
||||
const next = [...kinds];
|
||||
next[d] = e.target.value;
|
||||
setKinds(next);
|
||||
review(files, next);
|
||||
}}
|
||||
>
|
||||
{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`)}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
<div className="card-body">
|
||||
{doc.error ? <div className="text-danger">{t(`wordimport.error.${doc.error}`)}</div> : null}
|
||||
{doc.warnings.map((w) => (
|
||||
<div key={w} className="alert alert-warning py-2">
|
||||
{t(`wordimport.warning.${w}`)}
|
||||
</div>
|
||||
))}
|
||||
{doc.items.length > 0 ? <div className="text-secondary mb-2">{t("wordimport.items", { n: doc.items.length })}</div> : null}
|
||||
|
||||
{doc.relation ? (
|
||||
<div className="mb-3">
|
||||
<div className="fw-bold">{t("wordimport.participants")}</div>
|
||||
<ul className="mb-1">
|
||||
{doc.relation.participants.map((p, i) => (
|
||||
<li key={i} className={p.entityId ? "" : "text-warning"}>
|
||||
{p.entityId ? p.text : t("wordimport.notFound", { name: p.text })}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
{doc.relation.participants.filter((p) => p.entityId).length < 2 ? <div className="text-warning">{t("wordimport.tooFew")}</div> : null}
|
||||
</div>
|
||||
) : null}
|
||||
|
||||
{doc.items.slice(0, SHOWN_ITEMS).map((item, i) => {
|
||||
const decision = decisions[d]?.[i];
|
||||
if (!decision) return null;
|
||||
const fieldCount = Object.keys(item.data).length;
|
||||
const relation = item.entityKind === "RELATION";
|
||||
const blocked = relation && (doc.relation?.participants.filter((p) => p.entityId).length ?? 0) < 2;
|
||||
return (
|
||||
<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={decision.include} disabled={blocked} onChange={(e) => update(d, i, { include: e.target.checked })} />
|
||||
{relation ? (
|
||||
<span className="fw-bold">{item.name}</span>
|
||||
) : (
|
||||
<input
|
||||
className="form-control form-control-sm w-auto flex-fill"
|
||||
style={{ minWidth: "12rem" }}
|
||||
aria-label={t("wordimport.name")}
|
||||
value={decision.name}
|
||||
maxLength={200}
|
||||
onChange={(e) => update(d, i, { name: e.target.value })}
|
||||
/>
|
||||
)}
|
||||
{item.code ? <span className="badge">{item.code}</span> : null}
|
||||
<span className="badge bg-blue-lt">{t("wordimport.fields", { n: fieldCount })}</span>
|
||||
{item.links.length > 0 ? <span className="badge bg-azure-lt">{t("wordimport.links", { n: item.links.length })}</span> : null}
|
||||
{item.duplicates.length > 0 ? (
|
||||
<span className="badge bg-yellow-lt" title={t("wordimport.existsHelp")}>
|
||||
{t("wordimport.exists", { name: item.duplicates[0].code ?? item.duplicates[0].name })}
|
||||
</span>
|
||||
) : null}
|
||||
</div>
|
||||
<details className="mt-1">
|
||||
<summary className="text-secondary small">{t("wordimport.details")}</summary>
|
||||
<div className="row mt-2">
|
||||
<div className="col-md-6">
|
||||
<div className="fw-bold small">{t("wordimport.matched")}</div>
|
||||
<ul className="small mb-2">
|
||||
{Object.entries(item.data).map(([key, value]) => (
|
||||
<li key={key}>
|
||||
<span className="text-secondary">{key}:</span> {item.display[key] ?? String(value).slice(0, 120)}
|
||||
</li>
|
||||
))}
|
||||
{item.links.map((link, k) => (
|
||||
<li key={`l${k}`} className={link.entityId ? "" : "text-warning"}>
|
||||
{link.entityId ? t("wordimport.linkTo", { type: link.type, name: link.text }) : t("wordimport.notFound", { name: link.text })}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</div>
|
||||
<div className="col-md-6">
|
||||
{item.unmatched.length > 0 ? (
|
||||
<>
|
||||
<div className="fw-bold small">{t("wordimport.unmatched")}</div>
|
||||
<ul className="small mb-0">
|
||||
{item.unmatched.map((p, k) => (
|
||||
<li key={k}>
|
||||
<span className="text-secondary">{p.label}:</span> {p.value.slice(0, 160)}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</>
|
||||
) : null}
|
||||
</div>
|
||||
</div>
|
||||
</details>
|
||||
</div>
|
||||
);
|
||||
})}
|
||||
{doc.items.length > SHOWN_ITEMS ? <div className="text-secondary">{t("wordimport.more", { n: doc.items.length - SHOWN_ITEMS })}</div> : null}
|
||||
</div>
|
||||
</div>
|
||||
))}
|
||||
|
||||
{docs ? (
|
||||
<div className="card">
|
||||
<div className="card-body d-flex flex-wrap gap-3 align-items-center">
|
||||
<label className="form-check mb-0">
|
||||
<input type="checkbox" className="form-check-input" checked={append} onChange={(e) => setAppend(e.target.checked)} />
|
||||
<span className="form-check-label">{t("wordimport.append")}</span>
|
||||
</label>
|
||||
<button type="button" className="btn btn-primary ms-auto" disabled={pending || selectedCount === 0} onClick={commit}>
|
||||
{pending ? t("wordimport.importing") : t("wordimport.import", { n: selectedCount })}
|
||||
</button>
|
||||
{selectedCount === 0 ? <span className="text-secondary">{t("wordimport.noneSelected")}</span> : null}
|
||||
</div>
|
||||
</div>
|
||||
) : null}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -453,4 +453,86 @@ export const en: Record<keyof typeof sv, string> = {
|
||||
"import.done": "The book was imported: {entities} items, {relations} relationships and {maps} maps.",
|
||||
"import.skipped": "{n} images or links were missing from the file and were skipped.",
|
||||
"settings.exportHelp": "Downloads the whole book: items, relationships, schedules, maps, templates and images. The zip file can be imported as a new book here or in another installation. The JSON variant contains data only, without images.",
|
||||
|
||||
"share.title": "Sharing",
|
||||
"share.help": "Share the book with others who have logged in to the app. They see it under My books.",
|
||||
"share.roles": "Viewers see everything and can export. Editors change the content. Administrators share the book and change settings and templates. Only the owner deletes the book and manages administrators.",
|
||||
"share.email": "Email address",
|
||||
"share.emailHelp": "The address the person logs in with.",
|
||||
"share.role": "Role",
|
||||
"share.add": "Share",
|
||||
"share.owner": "Owner",
|
||||
"share.you": "you",
|
||||
"share.remove": "Remove",
|
||||
"share.removeConfirm": "Remove this person's access to the book?",
|
||||
"share.nobody": "The book is not shared with anyone.",
|
||||
"share.leave": "Leave the book",
|
||||
"share.leaveHelp": "The book is shared by {owner}. You can leave it, and the owner can share it with you again.",
|
||||
"share.leaveConfirm": "Leave the book? You lose access until the owner shares it again.",
|
||||
"share.sharedBy": "Shared by {name}",
|
||||
"share.viewerNotice": "You have read-only access to this book and cannot change anything.",
|
||||
"share.role.ADMIN": "Administrator",
|
||||
"share.role.EDITOR": "Editor",
|
||||
"share.role.VIEWER": "Viewer",
|
||||
"share.role.OWNER": "Owner",
|
||||
"share.result.ok": "Done.",
|
||||
"share.result.not-found": "No user with that email address has logged in to the app yet. Ask the person to log in once first.",
|
||||
"share.result.owner": "That person already owns the book.",
|
||||
"share.result.already": "The book is already shared with that person.",
|
||||
"share.result.forbidden": "You are not allowed to make that change.",
|
||||
"share.result.invalid": "Invalid email address or role.",
|
||||
"settings.readOnly": "Only administrators can change the book's details.",
|
||||
|
||||
"conflict.title": "Someone else has saved changes since you opened the page",
|
||||
"conflict.by": "Last saved by {name} {time}.",
|
||||
"conflict.byUnknown": "Last saved {time}.",
|
||||
"conflict.diff": "This is how your form differs from the saved version:",
|
||||
"conflict.saved": "Saved",
|
||||
"conflict.yours": "Yours",
|
||||
"conflict.empty": "(empty)",
|
||||
"conflict.overwrite": "Save my changes anyway",
|
||||
"conflict.overwriteHelp": "The saved version is overwritten. For items it stays in the history.",
|
||||
"conflict.reload": "Reload the page",
|
||||
"conflict.reloadHelp": "You then see the saved version, and your unsaved changes are lost.",
|
||||
|
||||
"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.choose": "Word files",
|
||||
"wordimport.review": "Review",
|
||||
"wordimport.reading": "Reading…",
|
||||
"wordimport.docType": "Document type",
|
||||
"wordimport.unknownType": "Unknown type, choose",
|
||||
"wordimport.error.not-docx": "Not a Word document (.docx).",
|
||||
"wordimport.error.too-large": "The file is too large (8 MB at most).",
|
||||
"wordimport.error.invalid": "The file could not be read.",
|
||||
"wordimport.error.no-files": "Choose at least one file.",
|
||||
"wordimport.error.limit": "Too many files (20 at most).",
|
||||
"wordimport.items": "{n} items found",
|
||||
"wordimport.name": "Name",
|
||||
"wordimport.code": "ID",
|
||||
"wordimport.fields": "{n} fields",
|
||||
"wordimport.links": "{n} links",
|
||||
"wordimport.exists": "Already exists: {name}",
|
||||
"wordimport.existsHelp": "An item with the same name already exists, so it is unchecked. Check it to create another one anyway.",
|
||||
"wordimport.details": "Details",
|
||||
"wordimport.matched": "Interpreted",
|
||||
"wordimport.unmatched": "Not interpreted",
|
||||
"wordimport.linkTo": "{type}: {name}",
|
||||
"wordimport.notFound": "{name} (not in the book, skipped)",
|
||||
"wordimport.participants": "Participants",
|
||||
"wordimport.tooFew": "The relationship needs at least two participants that exist in the book.",
|
||||
"wordimport.append": "Put what could not be interpreted in the Other or Description field",
|
||||
"wordimport.import": "Import {n}",
|
||||
"wordimport.importing": "Saving…",
|
||||
"wordimport.done": "{created} items and {relations} links were created. {skipped} were skipped.",
|
||||
"wordimport.noneSelected": "Nothing selected to import.",
|
||||
"wordimport.warning.unknown-kind": "The document type could not be determined. Choose the type above.",
|
||||
"wordimport.warning.empty": "Nothing filled in was found in the document.",
|
||||
"wordimport.warning.few-participants": "Fewer than two participants were found.",
|
||||
"wordimport.more": "…and {n} more",
|
||||
"wordimport.another": "Import more",
|
||||
|
||||
"wordimport.warning.unsupported": "Schedules and the map register are not imported here. Add schedules under Schedules and maps under Maps.",
|
||||
};
|
||||
@@ -451,4 +451,86 @@ export const sv = {
|
||||
"import.done": "Boken importerades: {entities} poster, {relations} relationer och {maps} kartor.",
|
||||
"import.skipped": "{n} bilder eller kopplingar saknades i filen och hoppades över.",
|
||||
"settings.exportHelp": "Laddar ner hela boken: poster, relationer, scheman, kartor, mallar och bilder. Zip-filen kan importeras som en ny bok här eller i en annan installation. JSON-varianten innehåller bara data, utan bilder.",
|
||||
|
||||
"share.title": "Delning",
|
||||
"share.help": "Dela boken med andra som har loggat in i appen. De ser boken under Mina böcker.",
|
||||
"share.roles": "Läsare ser allt och kan exportera. Redaktörer ändrar innehållet. Administratörer delar boken och ändrar inställningar och mallar. Bara ägaren tar bort boken och hanterar administratörer.",
|
||||
"share.email": "E-postadress",
|
||||
"share.emailHelp": "Samma adress som personen loggar in med.",
|
||||
"share.role": "Roll",
|
||||
"share.add": "Dela",
|
||||
"share.owner": "Ägare",
|
||||
"share.you": "du",
|
||||
"share.remove": "Ta bort",
|
||||
"share.removeConfirm": "Ta bort personens tillgång till boken?",
|
||||
"share.nobody": "Boken är inte delad med någon.",
|
||||
"share.leave": "Lämna boken",
|
||||
"share.leaveHelp": "Boken delas av {owner}. Du kan lämna den, och ägaren kan dela den med dig igen.",
|
||||
"share.leaveConfirm": "Lämna boken? Du förlorar tillgången tills ägaren delar den igen.",
|
||||
"share.sharedBy": "Delad av {name}",
|
||||
"share.viewerNotice": "Du har läsrättigheter i den här boken och kan inte ändra något.",
|
||||
"share.role.ADMIN": "Administratör",
|
||||
"share.role.EDITOR": "Redaktör",
|
||||
"share.role.VIEWER": "Läsare",
|
||||
"share.role.OWNER": "Ägare",
|
||||
"share.result.ok": "Klart.",
|
||||
"share.result.not-found": "Ingen användare med den e-postadressen har loggat in i appen än. Be personen logga in en gång först.",
|
||||
"share.result.owner": "Den personen äger redan boken.",
|
||||
"share.result.already": "Boken är redan delad med den personen.",
|
||||
"share.result.forbidden": "Du får inte göra den ändringen.",
|
||||
"share.result.invalid": "Ogiltig e-postadress eller roll.",
|
||||
"settings.readOnly": "Bara administratörer kan ändra bokens uppgifter.",
|
||||
|
||||
"conflict.title": "Någon annan har sparat ändringar sedan du öppnade sidan",
|
||||
"conflict.by": "Senast sparad av {name} {time}.",
|
||||
"conflict.byUnknown": "Senast sparad {time}.",
|
||||
"conflict.diff": "Så här skiljer sig ditt formulär från den sparade versionen:",
|
||||
"conflict.saved": "Sparad",
|
||||
"conflict.yours": "Ditt",
|
||||
"conflict.empty": "(tomt)",
|
||||
"conflict.overwrite": "Spara mina ändringar ändå",
|
||||
"conflict.overwriteHelp": "Den sparade versionen skrivs över. För poster finns den kvar i historiken.",
|
||||
"conflict.reload": "Ladda om sidan",
|
||||
"conflict.reloadHelp": "Du ser då den sparade versionen, och dina osparade ändringar förloras.",
|
||||
|
||||
"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.choose": "Word-filer",
|
||||
"wordimport.review": "Granska",
|
||||
"wordimport.reading": "Läser…",
|
||||
"wordimport.docType": "Dokumenttyp",
|
||||
"wordimport.unknownType": "Okänd typ, välj",
|
||||
"wordimport.error.not-docx": "Inte ett Word-dokument (.docx).",
|
||||
"wordimport.error.too-large": "Filen är för stor (högst 8 MB).",
|
||||
"wordimport.error.invalid": "Filen kunde inte läsas.",
|
||||
"wordimport.error.no-files": "Välj minst en fil.",
|
||||
"wordimport.error.limit": "För många filer (högst 20).",
|
||||
"wordimport.items": "{n} poster hittades",
|
||||
"wordimport.name": "Namn",
|
||||
"wordimport.code": "ID",
|
||||
"wordimport.fields": "{n} fält",
|
||||
"wordimport.links": "{n} kopplingar",
|
||||
"wordimport.exists": "Finns redan: {name}",
|
||||
"wordimport.existsHelp": "En post med samma namn finns redan, så den är avmarkerad. Markera den för att skapa en till ändå.",
|
||||
"wordimport.details": "Detaljer",
|
||||
"wordimport.matched": "Tolkat",
|
||||
"wordimport.unmatched": "Ej tolkat",
|
||||
"wordimport.linkTo": "{type}: {name}",
|
||||
"wordimport.notFound": "{name} (finns inte i boken, hoppas över)",
|
||||
"wordimport.participants": "Deltagare",
|
||||
"wordimport.tooFew": "Relationen behöver minst två deltagare som finns i boken.",
|
||||
"wordimport.append": "Lägg det som inte gick att tolka i fältet Övrigt eller Beskrivning",
|
||||
"wordimport.import": "Importera {n}",
|
||||
"wordimport.importing": "Sparar…",
|
||||
"wordimport.done": "{created} poster och {relations} kopplingar skapades. {skipped} hoppades över.",
|
||||
"wordimport.noneSelected": "Inget valt att importera.",
|
||||
"wordimport.warning.unknown-kind": "Dokumentets typ kunde inte avgöras. Välj typ här ovanför.",
|
||||
"wordimport.warning.empty": "Inget ifyllt hittades i dokumentet.",
|
||||
"wordimport.warning.few-participants": "Färre än två deltagare hittades.",
|
||||
"wordimport.more": "…och {n} till",
|
||||
"wordimport.another": "Importera fler",
|
||||
|
||||
"wordimport.warning.unsupported": "Scheman och kartregister importeras inte här. Lägg in scheman under Scheman och kartor under Kartor.",
|
||||
} as const;
|
||||
@@ -0,0 +1,31 @@
|
||||
// Roller i en bok. Ägaren är den som skapade boken (Book.ownerId), övriga får en roll genom delning.
|
||||
// VIEWER läser allt och kan exportera
|
||||
// EDITOR skriver som ägaren: poster, relationer, scheman, kartor, händelser, återställer ur papperskorgen
|
||||
// ADMIN dessutom delning, bokinställningar, mallar och att tömma papperskorgen
|
||||
// OWNER dessutom att ta bort boken och att ge och ta bort administratörer
|
||||
|
||||
export type BookRole = "OWNER" | "ADMIN" | "EDITOR" | "VIEWER";
|
||||
export type MemberRole = Exclude<BookRole, "OWNER">;
|
||||
|
||||
export const MEMBER_ROLES: MemberRole[] = ["ADMIN", "EDITOR", "VIEWER"];
|
||||
|
||||
const RANK: Record<BookRole, number> = { VIEWER: 1, EDITOR: 2, ADMIN: 3, OWNER: 4 };
|
||||
|
||||
export const hasRole = (role: BookRole, min: BookRole) => RANK[role] >= RANK[min];
|
||||
|
||||
export function parseMemberRole(value: unknown): MemberRole | null {
|
||||
return typeof value === "string" && (MEMBER_ROLES as string[]).includes(value) ? (value as MemberRole) : null;
|
||||
}
|
||||
|
||||
/** Vilka roller en person med rollen `actor` får ge, ändra och ta bort. Bara ägaren hanterar administratörer. */
|
||||
export function manageableRoles(actor: BookRole): MemberRole[] {
|
||||
if (actor === "OWNER") return ["ADMIN", "EDITOR", "VIEWER"];
|
||||
if (actor === "ADMIN") return ["EDITOR", "VIEWER"];
|
||||
return [];
|
||||
}
|
||||
|
||||
/** Får `actor` ändra en medlem som har rollen `current` till rollen `next`, eller ta bort medlemmen (next = null)? */
|
||||
export function canChangeMember(actor: BookRole, current: MemberRole, next: MemberRole | null): boolean {
|
||||
const allowed = manageableRoles(actor);
|
||||
return allowed.includes(current) && (next === null || allowed.includes(next));
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
import type { BookRole } from "./access";
|
||||
import { prisma } from "./db";
|
||||
|
||||
/** En användares roll i en bok (ägare eller delad), eller null om boken inte finns eller inte är delad med användaren. */
|
||||
export async function bookAccess(bookId: string, userId: string) {
|
||||
const book = await prisma.book.findFirst({
|
||||
where: { id: bookId, OR: [{ ownerId: userId }, { members: { some: { userId } } }] },
|
||||
include: { members: { where: { userId }, select: { role: true } } },
|
||||
});
|
||||
if (!book) return null;
|
||||
const { members, ...rest } = book;
|
||||
const role: BookRole = book.ownerId === userId ? "OWNER" : (members[0]?.role ?? "VIEWER");
|
||||
return { ...rest, role, userId };
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
import { prisma } from "./db";
|
||||
|
||||
// Skydd mot att två ändringar krockar. Formuläret skickar med versionen (tidpunkten för senaste ändringen) som det
|
||||
// öppnades med. Har posten ändrats sedan dess sparas ingenting, och användaren får välja att spara ändå
|
||||
// (då hamnar den andras version i historiken) eller ladda om.
|
||||
|
||||
export type ConflictChange = { label: string; /** Sparad version */ before: string; /** Det som skickades in */ after: string };
|
||||
|
||||
export type ConflictInfo = {
|
||||
/** Aktuell version, som skickas med igen när användaren väljer att spara ändå */
|
||||
version: string;
|
||||
/** Vem som senast sparade, om det är känt */
|
||||
by: string | null;
|
||||
/** När, som ISO-tid */
|
||||
at: string;
|
||||
changes: ConflictChange[];
|
||||
};
|
||||
|
||||
/** Svar från en sparåtgärd som inte kunde spara. Lyckad sparning omdirigerar i stället. */
|
||||
export type SaveResult = { conflict: ConflictInfo } | undefined;
|
||||
|
||||
export const versionOf = (updatedAt: Date) => String(updatedAt.getTime());
|
||||
|
||||
/** 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);
|
||||
}
|
||||
|
||||
export async function conflictInfo(current: { updatedAt: Date; updatedById: string | null }, changes: ConflictChange[] = []): Promise<ConflictInfo> {
|
||||
const user = current.updatedById
|
||||
? await prisma.user.findUnique({ where: { id: current.updatedById }, select: { name: true, email: true } })
|
||||
: null;
|
||||
return { version: versionOf(current.updatedAt), by: user?.name ?? user?.email ?? null, at: current.updatedAt.toISOString(), changes };
|
||||
}
|
||||
@@ -42,6 +42,12 @@ async function nextNumber(db: Db, bookId: string, key: string): Promise<number>
|
||||
return row.next;
|
||||
}
|
||||
|
||||
/** Ser till att räknaren minst har nått n, så att nya ID inte krockar med ett ID som tagits in utifrån (import). */
|
||||
export async function reserveNumber(bookId: string, key: string, n: number, db: Db = prisma): Promise<void> {
|
||||
await db.idCounter.upsert({ where: { bookId_key: { bookId, key } }, create: { bookId, key, next: n }, update: {} });
|
||||
await db.idCounter.updateMany({ where: { bookId, key, next: { lt: n } }, data: { next: n } });
|
||||
}
|
||||
|
||||
/** T.ex. KI-0001. Ger null för typer utan ID. */
|
||||
export async function nextEntityCode(bookId: string, kind: EntityKind, db: Db = prisma): Promise<string | null> {
|
||||
const prefix = ENTITY_PREFIX[kind];
|
||||
|
||||
+12
-7
@@ -1,7 +1,9 @@
|
||||
import { cache } from "react";
|
||||
import { notFound, redirect } from "next/navigation";
|
||||
import { auth } from "@/auth";
|
||||
import { hasRole, type BookRole } from "./access";
|
||||
import { isAdminUser } from "./admin";
|
||||
import { bookAccess } from "./book-access";
|
||||
import { prisma } from "./db";
|
||||
|
||||
/**
|
||||
@@ -39,17 +41,20 @@ export async function requireAdmin() {
|
||||
return user;
|
||||
}
|
||||
|
||||
/** Hämtar boken om den tillhör inloggad användare, annars 404. */
|
||||
export async function requireBook(bookId: string) {
|
||||
/**
|
||||
* Hämtar boken om inloggad användare äger den eller har fått den delad, med minst rollen `min`.
|
||||
* Annars 404, så att man inte kan se vilka böcker som finns.
|
||||
*/
|
||||
export async function requireBook(bookId: string, min: BookRole = "VIEWER") {
|
||||
const user = await requireUser();
|
||||
const book = await prisma.book.findFirst({ where: { id: bookId, ownerId: user.id } });
|
||||
if (!book) notFound();
|
||||
return book;
|
||||
const access = await bookAccess(bookId, user.id);
|
||||
if (!access || !hasRole(access.role, min)) notFound();
|
||||
return access;
|
||||
}
|
||||
|
||||
/** Hämtar en post i boken, annars 404. */
|
||||
export async function requireEntity(bookId: string, entityId: string) {
|
||||
await requireBook(bookId);
|
||||
export async function requireEntity(bookId: string, entityId: string, min: BookRole = "VIEWER") {
|
||||
await requireBook(bookId, min);
|
||||
const entity = await prisma.entity.findFirst({ where: { id: entityId, bookId } });
|
||||
if (!entity) notFound();
|
||||
return entity;
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
import { canChangeMember, manageableRoles, type BookRole, type MemberRole } from "./access";
|
||||
import { prisma } from "./db";
|
||||
import { log } from "./log";
|
||||
|
||||
// Delning av böcker. Ägaren står i Book.ownerId, övriga i BookMember. Reglerna för vem som får ändra vem finns i access.ts.
|
||||
|
||||
export type ShareResult = "ok" | "not-found" | "owner" | "already" | "forbidden" | "invalid";
|
||||
export const SHARE_RESULTS: ShareResult[] = ["ok", "not-found", "owner", "already", "forbidden", "invalid"];
|
||||
|
||||
const EMAIL = /^[^\s@]+@[^\s@]+$/;
|
||||
|
||||
export async function listMembers(bookId: string) {
|
||||
const [book, members] = await Promise.all([
|
||||
prisma.book.findUniqueOrThrow({ where: { id: bookId }, select: { owner: { select: { id: true, name: true, email: true } } } }),
|
||||
prisma.bookMember.findMany({ where: { bookId }, include: { user: { select: { id: true, name: true, email: true } } }, orderBy: { createdAt: "asc" } }),
|
||||
]);
|
||||
return { owner: book.owner, members };
|
||||
}
|
||||
|
||||
/** Delar boken med den användare som har loggat in med e-postadressen. Personen måste alltså finnas i appen. */
|
||||
export async function addMember(bookId: string, actor: BookRole, emailRaw: string, role: MemberRole): Promise<ShareResult> {
|
||||
const email = emailRaw.trim().toLowerCase();
|
||||
if (!EMAIL.test(email) || email.length > 200) return "invalid";
|
||||
if (!manageableRoles(actor).includes(role)) return "forbidden";
|
||||
|
||||
const user = await prisma.user.findFirst({ where: { email: { equals: email, mode: "insensitive" } }, orderBy: { createdAt: "asc" } });
|
||||
if (!user) return "not-found";
|
||||
const book = await prisma.book.findUniqueOrThrow({ where: { id: bookId }, select: { ownerId: true } });
|
||||
if (book.ownerId === user.id) return "owner";
|
||||
if (await prisma.bookMember.findUnique({ where: { bookId_userId: { bookId, userId: user.id } }, select: { id: true } })) return "already";
|
||||
|
||||
await prisma.bookMember.create({ data: { bookId, userId: user.id, role } });
|
||||
log.info("Bok delad", { bookId, userId: user.id, role });
|
||||
return "ok";
|
||||
}
|
||||
|
||||
export async function setMemberRole(bookId: string, actor: BookRole, userId: string, role: MemberRole): Promise<ShareResult> {
|
||||
const member = await prisma.bookMember.findUnique({ where: { bookId_userId: { bookId, userId } } });
|
||||
if (!member) return "not-found";
|
||||
if (!canChangeMember(actor, member.role, role)) return "forbidden";
|
||||
await prisma.bookMember.update({ where: { id: member.id }, data: { role } });
|
||||
return "ok";
|
||||
}
|
||||
|
||||
export async function removeMember(bookId: string, actor: BookRole, userId: string): Promise<ShareResult> {
|
||||
const member = await prisma.bookMember.findUnique({ where: { bookId_userId: { bookId, userId } } });
|
||||
if (!member) return "not-found";
|
||||
if (!canChangeMember(actor, member.role, null)) return "forbidden";
|
||||
await prisma.bookMember.delete({ where: { id: member.id } });
|
||||
log.info("Delning borttagen", { bookId, userId });
|
||||
return "ok";
|
||||
}
|
||||
|
||||
/** En medlem lämnar boken. Ägaren kan inte lämna sin egen bok. */
|
||||
export async function leaveBook(bookId: string, userId: string): Promise<boolean> {
|
||||
const { count } = await prisma.bookMember.deleteMany({ where: { bookId, userId } });
|
||||
return count > 0;
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
import { strFromU8, unzipSync } from "fflate";
|
||||
|
||||
// Läser texten ur ett Word-dokument (.docx) som en lista med stycken och tabeller. Allt som inte är text, till exempel
|
||||
// bilder och formatering, hoppas över. Ett .docx är en zip-fil där texten ligger i word/document.xml.
|
||||
|
||||
export const MAX_DOCX_BYTES = 8 * 1024 * 1024;
|
||||
const MAX_XML_BYTES = 30 * 1024 * 1024;
|
||||
|
||||
export type DocBlock = { type: "paragraph"; text: string } | { type: "table"; rows: string[][] };
|
||||
|
||||
export type DocxErrorCode = "not-docx" | "too-large" | "invalid";
|
||||
|
||||
export class DocxError extends Error {
|
||||
constructor(public code: DocxErrorCode) {
|
||||
super(code);
|
||||
}
|
||||
}
|
||||
|
||||
const ENTITIES: Record<string, string> = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
|
||||
|
||||
export function decodeXml(text: string): string {
|
||||
return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (whole, name: string) => {
|
||||
if (name[0] === "#") {
|
||||
const code = name[1].toLowerCase() === "x" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
|
||||
return Number.isFinite(code) && code > 0 && code < 0x110000 ? String.fromCodePoint(code) : "";
|
||||
}
|
||||
return ENTITIES[name.toLowerCase()] ?? whole;
|
||||
});
|
||||
}
|
||||
|
||||
/** Plockar ut innehållet i word/document.xml ur en docx-fil. */
|
||||
export function readDocumentXml(bytes: Uint8Array): string {
|
||||
if (bytes.length > MAX_DOCX_BYTES) throw new DocxError("too-large");
|
||||
if (bytes.length < 4 || bytes[0] !== 0x50 || bytes[1] !== 0x4b) throw new DocxError("not-docx");
|
||||
let entries: Record<string, Uint8Array>;
|
||||
try {
|
||||
// Bara huvuddokumentet packas upp, med gräns mot zip-bomber
|
||||
entries = unzipSync(bytes, { filter: (file) => file.name === "word/document.xml" && file.originalSize <= MAX_XML_BYTES });
|
||||
} catch {
|
||||
throw new DocxError("invalid");
|
||||
}
|
||||
const xml = entries["word/document.xml"];
|
||||
if (!xml) throw new DocxError("not-docx");
|
||||
return strFromU8(xml);
|
||||
}
|
||||
|
||||
const TAG = /<(\/?)w:(tbl|tr|tc|p|t|tab|br|cr|sym)\b([^>]*?)(\/?)>/g;
|
||||
|
||||
/**
|
||||
* Delar upp dokumentets XML i stycken och tabeller. Tabeller i tabeller platt ut: deras text hamnar i den yttre cellen.
|
||||
* Stycken i en cell slås ihop med radbrytning.
|
||||
*/
|
||||
export function parseDocumentXml(xml: string): DocBlock[] {
|
||||
const blocks: DocBlock[] = [];
|
||||
let tableDepth = 0;
|
||||
let rows: string[][] | null = null;
|
||||
let row: string[] | null = null;
|
||||
let cell: string[] | null = null;
|
||||
let paragraph: string | null = null;
|
||||
|
||||
TAG.lastIndex = 0;
|
||||
let match: RegExpExecArray | null;
|
||||
while ((match = TAG.exec(xml))) {
|
||||
const [, closing, name, attrs, selfClosing] = match;
|
||||
const open = !closing && !selfClosing;
|
||||
|
||||
switch (name) {
|
||||
case "tbl":
|
||||
if (open) {
|
||||
tableDepth++;
|
||||
if (tableDepth === 1) rows = [];
|
||||
} else if (closing) {
|
||||
tableDepth--;
|
||||
if (tableDepth === 0 && rows) {
|
||||
blocks.push({ type: "table", rows });
|
||||
rows = null;
|
||||
}
|
||||
if (tableDepth < 0) tableDepth = 0;
|
||||
}
|
||||
break;
|
||||
case "tr":
|
||||
if (tableDepth === 1) {
|
||||
if (open) row = [];
|
||||
else if (closing && row && rows) {
|
||||
rows.push(row);
|
||||
row = null;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "tc":
|
||||
if (tableDepth === 1) {
|
||||
if (open) cell = [];
|
||||
else if (closing && cell && row) {
|
||||
row.push(cell.join("\n"));
|
||||
cell = null;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "p":
|
||||
if (open) {
|
||||
paragraph = "";
|
||||
} else if (closing && paragraph !== null) {
|
||||
const text = paragraph.replace(/ +/g, " ").replace(/[ \t]*\n[ \t]*/g, "\n").trim();
|
||||
if (tableDepth > 0) cell?.push(text);
|
||||
else if (text) blocks.push({ type: "paragraph", text });
|
||||
paragraph = null;
|
||||
}
|
||||
break;
|
||||
case "t":
|
||||
if (open && paragraph !== null) {
|
||||
const end = xml.indexOf("</w:t>", TAG.lastIndex);
|
||||
if (end >= 0) {
|
||||
paragraph += decodeXml(xml.slice(TAG.lastIndex, end));
|
||||
TAG.lastIndex = end + "</w:t>".length;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "tab":
|
||||
if (paragraph !== null) paragraph += "\t";
|
||||
break;
|
||||
case "br":
|
||||
case "cr":
|
||||
if (paragraph !== null) paragraph += "\n";
|
||||
break;
|
||||
case "sym":
|
||||
// En symbol (till exempel en ruta med bock) räknas som ett kryss
|
||||
if (paragraph !== null && /w:char="F0(FE|FD|52|53)"/i.test(attrs)) paragraph += "✓";
|
||||
break;
|
||||
}
|
||||
}
|
||||
return blocks;
|
||||
}
|
||||
|
||||
export function readDocx(bytes: Uint8Array): DocBlock[] {
|
||||
return parseDocumentXml(readDocumentXml(bytes));
|
||||
}
|
||||
@@ -0,0 +1,235 @@
|
||||
import type { EntityKind, Prisma } from "@prisma/client";
|
||||
import { prisma } from "./db";
|
||||
import { ENTITY_PREFIX, nextEntityCode, nextRelationCode, reserveNumber } from "./ids";
|
||||
import { parseKind } from "./kinds";
|
||||
import { normalizeStoryDate } from "./story-date";
|
||||
import { getTemplate, type FieldDef } from "./templates";
|
||||
import { DocxError, readDocx } from "./word-docx";
|
||||
import {
|
||||
IMPORT_KINDS,
|
||||
analyzeDocument,
|
||||
describeUnmatched,
|
||||
overflowField,
|
||||
usableCode,
|
||||
type ImportKind,
|
||||
type ItemLink,
|
||||
type KnownEntity,
|
||||
type Pair,
|
||||
type ParsedDocument,
|
||||
type ParsedItem,
|
||||
} from "./word-import";
|
||||
|
||||
// Förhandsgranskning och sparande av importen från Word. Tolkningen själv ligger i word-import.ts.
|
||||
|
||||
export const MAX_WORD_FILES = 20;
|
||||
export const MAX_WORD_ITEMS = 500;
|
||||
|
||||
export type PreviewItem = ParsedItem & { duplicates: { id: string; name: string; code: string | null }[] };
|
||||
|
||||
export type PreviewDocument = Omit<ParsedDocument, "items"> & {
|
||||
items: PreviewItem[];
|
||||
/** Satt om filen inte gick att läsa */
|
||||
error: "not-docx" | "too-large" | "invalid" | null;
|
||||
};
|
||||
|
||||
async function loadContext(bookId: string) {
|
||||
const entities = await prisma.entity.findMany({ where: { bookId }, select: { id: true, name: true, code: true, kind: true } });
|
||||
const known: KnownEntity[] = entities;
|
||||
const templates: Partial<Record<ImportKind, FieldDef[]>> = {};
|
||||
for (const kind of IMPORT_KINDS) templates[kind] = (await getTemplate(bookId, kind, "sv")).fields;
|
||||
return { known, templates };
|
||||
}
|
||||
|
||||
/** Läser Word-filerna och tolkar dem, utan att spara något. `kinds` låter användaren byta dokumenttyp per fil. */
|
||||
export async function previewWordFiles(
|
||||
bookId: string,
|
||||
files: { name: string; bytes: Uint8Array }[],
|
||||
kinds: (ImportKind | 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 => {
|
||||
try {
|
||||
const blocks = readDocx(file.bytes);
|
||||
const parsed = analyzeDocument(blocks, file.name, known, { kind: kinds[index] ?? null, templates });
|
||||
return {
|
||||
...parsed,
|
||||
error: null,
|
||||
items: parsed.items.map((item) => ({
|
||||
...item,
|
||||
duplicates:
|
||||
item.entityKind === "RELATION" ? [] : (byName.get(`${item.entityKind}|${item.name.toLowerCase()}`) ?? []).map((e) => ({ id: e.id, name: e.name, code: e.code })),
|
||||
})),
|
||||
};
|
||||
} catch (error) {
|
||||
if (error instanceof DocxError) return { file: file.name, kind: null, items: [], relation: null, warnings: [], error: error.code };
|
||||
throw error;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// ─── Spara ──────────────────────────────────────────────────────────────────
|
||||
|
||||
/** Det som webbläsaren skickar tillbaka efter förhandsgranskningen. Allt kontrolleras igen innan något sparas. */
|
||||
export type CommitItem = {
|
||||
include: boolean;
|
||||
entityKind: string;
|
||||
name: string;
|
||||
code: string | null;
|
||||
data: Record<string, unknown>;
|
||||
links: ItemLink[];
|
||||
unmatched: Pair[];
|
||||
/** Deltagare i en relation (post-id) */
|
||||
participants?: string[];
|
||||
};
|
||||
|
||||
export type CommitResult = { created: number; relations: number; skipped: number };
|
||||
|
||||
const text = (value: unknown, max: number): string => (typeof value === "string" ? value.trim().slice(0, max) : "");
|
||||
|
||||
/** Behåller bara de fält som finns i mallen och har ett giltigt värde av rätt sort. */
|
||||
export function cleanData(fields: FieldDef[], data: Record<string, unknown>, entities: Map<string, EntityKind>): Record<string, unknown> {
|
||||
const clean: Record<string, unknown> = {};
|
||||
for (const field of fields) {
|
||||
const value = data[field.key];
|
||||
if (value === undefined || value === null || value === "") continue;
|
||||
switch (field.type) {
|
||||
case "number":
|
||||
if (typeof value === "number" && Number.isFinite(value)) clean[field.key] = value;
|
||||
break;
|
||||
case "checkbox":
|
||||
if (typeof value === "boolean") clean[field.key] = value;
|
||||
break;
|
||||
case "date": {
|
||||
const date = normalizeStoryDate(value);
|
||||
if (date) clean[field.key] = date;
|
||||
break;
|
||||
}
|
||||
case "select":
|
||||
if (typeof value === "string" && (field.options ?? []).includes(value)) clean[field.key] = value;
|
||||
break;
|
||||
case "url":
|
||||
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;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
if (typeof value === "string") clean[field.key] = value.trim().slice(0, 20000);
|
||||
}
|
||||
}
|
||||
return clean;
|
||||
}
|
||||
|
||||
const RELATION_BY_CATEGORY: Record<string, { type: string; bond: "PARTNER" | null }> = {
|
||||
Vännergrupp: { type: "Vänner", bond: null },
|
||||
Partner: { type: "Partner till", bond: "PARTNER" },
|
||||
Familj: { type: "Familj", bond: null },
|
||||
Kollegor: { type: "Kollega till", bond: null },
|
||||
};
|
||||
|
||||
export async function commitWordImport(
|
||||
bookId: string,
|
||||
userId: string,
|
||||
items: CommitItem[],
|
||||
options: { appendUnmatched: boolean },
|
||||
): 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 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]));
|
||||
const takenCodes = new Set(existing.map((e) => e.code).filter((c): c is string => !!c));
|
||||
const templates = new Map<ImportKind, FieldDef[]>();
|
||||
for (const kind of IMPORT_KINDS) templates.set(kind, (await getTemplate(bookId, kind, "sv")).fields);
|
||||
|
||||
await prisma.$transaction(
|
||||
async (tx) => {
|
||||
for (const item of chosen) {
|
||||
const kind = item.entityKind === "RELATION" ? "RELATION" : parseKind(item.entityKind);
|
||||
if (!kind) {
|
||||
result.skipped++;
|
||||
continue;
|
||||
}
|
||||
const fields = templates.get(kind)!;
|
||||
const data = cleanData(fields, item.data ?? {}, kindOf);
|
||||
const unmatched = (Array.isArray(item.unmatched) ? item.unmatched : []).filter((p) => text(p?.label, 200) && text(p?.value, 20000)).slice(0, 100);
|
||||
const overflow = overflowField(fields);
|
||||
if (options.appendUnmatched && unmatched.length > 0 && overflow) {
|
||||
const extra = describeUnmatched(unmatched.map((p) => ({ label: text(p.label, 200), value: text(p.value, 5000) })));
|
||||
const current = typeof data[overflow] === "string" ? `${data[overflow]}\n\n` : "";
|
||||
data[overflow] = `${current}${extra}`.slice(0, 20000);
|
||||
}
|
||||
|
||||
if (kind === "RELATION") {
|
||||
const ids = [...new Set((item.participants ?? []).filter((id) => typeof id === "string" && kindOf.has(id)))];
|
||||
if (ids.length < 2) {
|
||||
result.skipped++;
|
||||
continue;
|
||||
}
|
||||
const mapped = RELATION_BY_CATEGORY[String(data.category ?? "")];
|
||||
await tx.relation.create({
|
||||
data: {
|
||||
bookId,
|
||||
code: await nextRelationCode(bookId, tx),
|
||||
fromId: ids[0],
|
||||
toId: ids[1],
|
||||
type: mapped?.type ?? (text(item.name, 100) || "Relation"),
|
||||
bond: mapped?.bond ?? null,
|
||||
data: data as Prisma.InputJsonObject,
|
||||
updatedById: userId,
|
||||
members: { create: ids.slice(2).map((entityId) => ({ entityId })) },
|
||||
},
|
||||
});
|
||||
result.relations++;
|
||||
continue;
|
||||
}
|
||||
|
||||
const name = text(item.name, 200);
|
||||
if (!name) {
|
||||
result.skipped++;
|
||||
continue;
|
||||
}
|
||||
const wanted = usableCode(kind, text(item.code, 50) || null);
|
||||
let code: string | null;
|
||||
if (wanted && !takenCodes.has(wanted)) {
|
||||
code = wanted;
|
||||
await reserveNumber(bookId, ENTITY_PREFIX[kind]!, Number(wanted.split("-")[1]), tx);
|
||||
} else {
|
||||
code = await nextEntityCode(bookId, kind, tx);
|
||||
}
|
||||
if (code) takenCodes.add(code);
|
||||
const entity = await tx.entity.create({
|
||||
data: { bookId, kind, name, code, tags: [], data: data as Prisma.InputJsonObject, updatedById: userId },
|
||||
});
|
||||
kindOf.set(entity.id, kind);
|
||||
result.created++;
|
||||
|
||||
for (const link of Array.isArray(item.links) ? item.links.slice(0, 200) : []) {
|
||||
const other = typeof link?.entityId === "string" && kindOf.has(link.entityId) ? link.entityId : null;
|
||||
const type = text(link?.type, 100);
|
||||
if (!other || !type || other === entity.id) continue;
|
||||
await tx.relation.create({
|
||||
data: {
|
||||
bookId,
|
||||
code: await nextRelationCode(bookId, tx),
|
||||
fromId: link.toDocument ? other : entity.id,
|
||||
toId: link.toDocument ? entity.id : other,
|
||||
type,
|
||||
description: text(link.note, 2000) || null,
|
||||
updatedById: userId,
|
||||
},
|
||||
});
|
||||
result.relations++;
|
||||
}
|
||||
}
|
||||
},
|
||||
{ timeout: 60_000, maxWait: 10_000 },
|
||||
);
|
||||
return result;
|
||||
}
|
||||
@@ -0,0 +1,767 @@
|
||||
import type { EntityKind } from "@prisma/client";
|
||||
import { ENTITY_PREFIX } from "./ids";
|
||||
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";
|
||||
|
||||
// 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
|
||||
// rapporteras i stället för att försvinna. Allt här är ren beräkning; databasen används först i word-import-db.ts.
|
||||
|
||||
export type ImportKind = EntityKind | "RELATION";
|
||||
|
||||
export const IMPORT_KINDS: ImportKind[] = [
|
||||
"CHARACTER",
|
||||
"PET",
|
||||
"HOME",
|
||||
"COMPANY",
|
||||
"PREMISES",
|
||||
"EDUCATION",
|
||||
"SCENARIO",
|
||||
"RELATION",
|
||||
"VEHICLE",
|
||||
"REFERENCE",
|
||||
"RESEARCH",
|
||||
"APP",
|
||||
"WEBSITE",
|
||||
];
|
||||
|
||||
/** Poster i boken som referenser och deltagarlistor kan peka på. */
|
||||
export type KnownEntity = { id: string; name: string; code: string | null; kind: EntityKind };
|
||||
|
||||
export type Pair = { label: string; value: string };
|
||||
export type ListEntry = { name: string; code: string; role: string; subject: string };
|
||||
export type ListBlock = { heading: string; entries: ListEntry[] };
|
||||
export type RegisterTable = { header: string[]; rows: string[][] };
|
||||
|
||||
export type Extracted = {
|
||||
pairs: Pair[];
|
||||
/** Alla etiketter som fanns i dokumentet, även de som saknar värde. De avgör vilken sorts dokument det är. */
|
||||
labels: string[];
|
||||
lists: ListBlock[];
|
||||
registers: RegisterTable[];
|
||||
/** Rubriker och löpande text, för att känna igen vilken sorts dokument det är */
|
||||
texts: string[];
|
||||
};
|
||||
|
||||
// ─── Hjälpare ───────────────────────────────────────────────────────────────
|
||||
|
||||
const PAREN = /\([^)]*\)/g;
|
||||
const MAX_LABEL = 90;
|
||||
|
||||
/** Delar en cell eller ett stycke i etikett och resten, t.ex. "Anställd hos:(inkludera ID)". Null om det inte är en etikett. */
|
||||
export function splitLabel(text: string): { label: string; rest: string } | null {
|
||||
const firstLine = text.split("\n")[0];
|
||||
const colon = firstLine.indexOf(":");
|
||||
if (colon < 2 || colon > MAX_LABEL) return null;
|
||||
const label = firstLine.slice(0, colon).trim();
|
||||
if (!label || /^https?$/i.test(label) || !/[A-Za-zÅÄÖåäö]/.test(label)) return null;
|
||||
const rest = text.slice(colon + 1);
|
||||
return { label, rest };
|
||||
}
|
||||
|
||||
/** Ifyllt värde i resten av en etikettcell: mallens hjälptext i parentes och avslutande kolon räknas bort. */
|
||||
function filledValue(rest: string): string {
|
||||
return rest.replace(PAREN, " ").replace(/^[\s:]+|[\s:]+$/g, "").replace(/\s*\n\s*/g, "\n").trim();
|
||||
}
|
||||
|
||||
const isLabelCell = (text: string) => {
|
||||
const parts = splitLabel(text);
|
||||
return parts !== null && !isOptionList(text);
|
||||
};
|
||||
|
||||
const isEmptyRow = (cells: string[]) => cells.every((c) => !c.trim());
|
||||
|
||||
/** Har texten någon rad som är en etikett utan värde ("Om lägenheten:")? Då är den en mall-text, inte ett ifyllt värde. */
|
||||
const hasLabelLine = (text: string) =>
|
||||
text.split("\n").some((line) => {
|
||||
const parts = isOptionList(line) ? null : splitLabel(line.trim());
|
||||
return parts !== null && !filledValue(parts.rest);
|
||||
});
|
||||
|
||||
type LabelLine = { label: string; inline: string; lines: number[] };
|
||||
|
||||
/**
|
||||
* En cell kan ha många etiketter, en per rad ("Förnamn:", "Efternamn:" ...), med värdena på motsvarande rader i cellen
|
||||
* bredvid. En etikett som Word brutit över två rader ("Ålder" och "födelsedatum:") slås ihop.
|
||||
*/
|
||||
export function multiLabels(cell: string): LabelLine[] {
|
||||
const entries: LabelLine[] = [];
|
||||
let buffer: { text: string; index: number }[] = [];
|
||||
cell.split("\n").forEach((raw, index) => {
|
||||
const line = raw.trim();
|
||||
if (!line) {
|
||||
buffer = [];
|
||||
return;
|
||||
}
|
||||
const parts = isOptionList(line) ? null : splitLabel(line);
|
||||
if (!parts) {
|
||||
buffer.push({ text: line, index });
|
||||
return;
|
||||
}
|
||||
entries.push({
|
||||
label: [...buffer.map((b) => b.text), parts.label].join(" ").trim(),
|
||||
inline: filledValue(parts.rest),
|
||||
lines: [...buffer.map((b) => b.index), index],
|
||||
});
|
||||
buffer = [];
|
||||
});
|
||||
return entries;
|
||||
}
|
||||
|
||||
const LIST_LABELS = new Set(["namn", "karaktärs", "karaktärsnummer", "karaktärskod", "roll", "ämne"]);
|
||||
|
||||
/**
|
||||
* En lista i en enda cell: kolumnrubrikerna ("Namn:", "Roll:", "Karaktärs ID:") står på egna rader och de som ingår
|
||||
* skrivs på raderna under, en per rad. Kolumner på en rad skiljs åt med tabb. Null om cellen inte är en sådan lista.
|
||||
*/
|
||||
export function parseCellList(text: string): ListEntry[] | null {
|
||||
const lines = text.split("\n").map((l) => l.trim());
|
||||
const isHeaderLine = (line: string) => {
|
||||
const parts = splitLabel(line);
|
||||
return parts !== null && !filledValue(parts.rest) && LIST_LABELS.has(normLabel(parts.label));
|
||||
};
|
||||
const headers: string[] = [];
|
||||
for (const line of lines) if (isHeaderLine(line)) headers.push(normLabel(splitLabel(line)!.label));
|
||||
const columns = [...new Set(headers)];
|
||||
if (!columns.includes("namn") || !columns.some((c) => c.startsWith("karaktärs"))) return null;
|
||||
|
||||
const others = columns.filter((c) => c !== "namn" && !c.startsWith("karaktärs"));
|
||||
const entries: ListEntry[] = [];
|
||||
for (const line of lines) {
|
||||
if (!line || isHeaderLine(line) || /^\(.*\)$/.test(line)) continue;
|
||||
const code = CODE_IN_TEXT.exec(line)?.[0] ?? "";
|
||||
const cols = line.replace(code, "").split("\t").map((c) => c.trim()).filter(Boolean);
|
||||
const entry: ListEntry = { name: cols[0] ?? "", code, role: "", subject: "" };
|
||||
others.forEach((column, i) => {
|
||||
if (column === "roll") entry.role = cols[i + 1] ?? "";
|
||||
if (column === "ämne") entry.subject = cols[i + 1] ?? "";
|
||||
});
|
||||
if (entry.name || entry.code) entries.push(entry);
|
||||
}
|
||||
return entries;
|
||||
}
|
||||
|
||||
/**
|
||||
* En cell med etiketter och värden om vartannat, en sak per rad ("Hyra:", "5000", "Balkong:", "Ja: X Nej:").
|
||||
* Mallens hjälptexter i parentes hoppas över.
|
||||
*/
|
||||
export function parseInlineBlock(text: string, isKnown: (label: string) => boolean): { pairs: Pair[]; labels: string[]; texts: string[] } {
|
||||
const result = { pairs: [] as Pair[], labels: [] as string[], texts: [] as string[] };
|
||||
let current: { label: string; lines: string[] } | null = null;
|
||||
const close = () => {
|
||||
const value = current?.lines.join("\n").trim();
|
||||
if (current && value) result.pairs.push({ label: current.label, value });
|
||||
current = null;
|
||||
};
|
||||
|
||||
for (const raw of text.split("\n")) {
|
||||
const line = raw.trim();
|
||||
if (!line || /^\([^)]*\)$/.test(line)) continue;
|
||||
let parts = isOptionList(line) ? null : splitLabel(line);
|
||||
// En fråga eller rubrik utan kolon som är en känd etikett
|
||||
if (!parts && current !== null && isKnown(line)) parts = { label: line, rest: "" };
|
||||
// Sista alternativet i en lista som bryts över flera rader ("Ja: delvis:" följt av "Nej:")
|
||||
const restValue = parts ? filledValue(parts.rest) : "";
|
||||
const continuesOptions =
|
||||
parts !== null &&
|
||||
(restValue === "" || /^(?:x|✓|✔|☒|☑|■)$/i.test(restValue)) &&
|
||||
current !== null &&
|
||||
isOptionList((current as { lines: string[] }).lines.join("\n")) &&
|
||||
!/\s/.test(parts.label) &&
|
||||
parts.label.length <= 15 &&
|
||||
!isKnown(parts.label);
|
||||
if (parts && !continuesOptions) {
|
||||
// "Ålder" följd av "födelsedatum:" är en etikett som Word delat över två rader
|
||||
const previous: string | undefined = current ? (current as { lines: string[] }).lines.at(-1) : undefined;
|
||||
if (previous && isKnown(`${previous} ${parts.label}`)) {
|
||||
(current as { lines: string[] }).lines.pop();
|
||||
parts = { label: `${previous} ${parts.label}`, rest: parts.rest };
|
||||
}
|
||||
close();
|
||||
result.labels.push(parts.label);
|
||||
current = { label: parts.label, lines: [] };
|
||||
const inline = filledValue(parts.rest);
|
||||
if (inline) current.lines.push(inline);
|
||||
} else if (current) {
|
||||
(current as { lines: string[] }).lines.push(line);
|
||||
} else {
|
||||
result.texts.push(line);
|
||||
}
|
||||
}
|
||||
close();
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Värdet på någon av etikettens rader i värdecellen, den första som är ifylld. */
|
||||
function valueAt(valueCell: string, lines: number[]): string {
|
||||
const rows = valueCell.split("\n");
|
||||
for (const i of lines) if (rows[i]?.trim()) return rows[i].trim();
|
||||
return "";
|
||||
}
|
||||
|
||||
/** Kolumnnamn i en deltagarlista, t.ex. "Namn | Karaktärs ID" eller "Namn | Roll | Karaktärsnummer". */
|
||||
function listHeader(cells: string[]): { name: number; code: number; role: number; subject: number } | null {
|
||||
const norm = cells.map((c) => normLabel(c.replace(/:/g, " ")));
|
||||
const find = (re: RegExp) => norm.findIndex((n) => re.test(n));
|
||||
const name = find(/^namn$/);
|
||||
const code = find(/^karaktärs\s?(nummer|kod|id)?$|^karaktärsnummer$|^karaktärer$/);
|
||||
if (name < 0 || code < 0 || cells.length < 2) return null;
|
||||
return { name, code, role: find(/^roll$/), subject: find(/^ämne$/) };
|
||||
}
|
||||
|
||||
// ─── Läsa ut etiketter och värden ───────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Går igenom dokumentets block och plockar ut etikett/värde-par, deltagarlistor och register.
|
||||
* `isKnown` avgör om en rad som "Etikett: text" i ett stycke ska läsas som en etikett med värde (annars är det löpande text).
|
||||
*/
|
||||
export function extract(blocks: DocBlock[], isKnown: (label: string) => boolean): Extracted {
|
||||
const out: Extracted = { pairs: [], labels: [], lists: [], registers: [], texts: [] };
|
||||
// Ett val där inget är markerat ("Ja: Nej:") är ett tomt värde
|
||||
const addPair = (label: string, value: string) => {
|
||||
const options = parseOptions(value);
|
||||
if (value.trim() && !(options && !options.some((o) => o.marked))) out.pairs.push({ label, value });
|
||||
};
|
||||
let heading = "";
|
||||
let section: { label: string; lines: string[] } | null = null;
|
||||
|
||||
const closeSection = () => {
|
||||
if (section) {
|
||||
const value = section.lines.join("\n").trim();
|
||||
if (value) addPair(section.label, value);
|
||||
}
|
||||
section = null;
|
||||
};
|
||||
|
||||
const readTable = (rows: string[][]) => {
|
||||
// Register: en rubrikrad med minst två etiketter följt av rader med samma antal celler
|
||||
const first = rows[0] ?? [];
|
||||
const labelled = first.filter((c) => c.trim() && isLabelCell(c));
|
||||
const isRegister = rows.length >= 3 && first.length >= 2 && first.every((c) => c.trim()) && labelled.length === first.length && !listHeader(first);
|
||||
if (isRegister) {
|
||||
out.registers.push({
|
||||
header: first.map((c) => (splitLabel(c)?.label ?? c).trim()),
|
||||
rows: rows.slice(1).filter((r) => r.length === first.length && !isEmptyRow(r)),
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
let list: { head: ReturnType<typeof listHeader>; entries: ListEntry[]; heading: string } | null = null;
|
||||
const flushList = () => {
|
||||
if (list && list.entries.length > 0) out.lists.push({ heading: list.heading, entries: list.entries });
|
||||
list = null;
|
||||
};
|
||||
|
||||
let carry: string | null = null; // etikett på en rad som saknar värde, värdet kan stå på nästa rad
|
||||
for (const cells of rows) {
|
||||
const carried: string | null = carry;
|
||||
carry = null;
|
||||
if (list && list.head) {
|
||||
// En rad med etiketter avslutar listan
|
||||
if (cells.length === 0 || cells.some((c) => c.trim() && isLabelCell(c))) {
|
||||
flushList();
|
||||
} else {
|
||||
if (isEmptyRow(cells)) continue;
|
||||
const at = (i: number) => (i >= 0 ? (cells[i] ?? "").trim() : "");
|
||||
list.entries.push({ name: at(list.head.name), code: at(list.head.code), role: at(list.head.role), subject: at(list.head.subject) });
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
const head = listHeader(cells);
|
||||
if (head) {
|
||||
list = { head, entries: [], heading };
|
||||
continue;
|
||||
}
|
||||
if (isEmptyRow(cells)) {
|
||||
carry = carried;
|
||||
continue;
|
||||
}
|
||||
if (carried !== null) {
|
||||
const only = cells.filter((c) => c.trim());
|
||||
if (only.length === 1 && (isOptionList(only[0]) || (!isLabelCell(only[0]) && !hasLabelLine(only[0]) && !isKnown(only[0])))) {
|
||||
addPair(carried, only[0].trim());
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
const filled = cells.filter((c) => c.trim());
|
||||
if (filled.length === 1 && filled[0].includes("\n") && !isOptionList(filled[0])) {
|
||||
const entries = parseCellList(filled[0]);
|
||||
if (entries) {
|
||||
if (entries.length > 0) out.lists.push({ heading, entries });
|
||||
continue;
|
||||
}
|
||||
const block = parseInlineBlock(filled[0], isKnown);
|
||||
out.labels.push(...block.labels);
|
||||
for (const pair of block.pairs) addPair(pair.label, pair.value);
|
||||
out.texts.push(...block.texts);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Etikett/värde-par i raden. Värdet är nästa cell, om den inte själv är en etikett.
|
||||
let pending: string | null = null;
|
||||
const consumed = new Set<number>();
|
||||
for (const [index, cell] of cells.entries()) {
|
||||
if (consumed.has(index)) continue;
|
||||
const text = cell.trim();
|
||||
if (pending === null && text.includes("\n")) {
|
||||
const entries = isOptionList(text) ? [] : multiLabels(text);
|
||||
if (entries.length >= 2) {
|
||||
const valueCell = cells[index + 1] ?? "";
|
||||
consumed.add(index + 1);
|
||||
for (const entry of entries) {
|
||||
out.labels.push(entry.label);
|
||||
const value = entry.inline || valueAt(valueCell, entry.lines);
|
||||
if (value) addPair(entry.label, value);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let parts = text && !isOptionList(text) ? splitLabel(text) : null;
|
||||
// En etikett utan kolon som följs av en alternativlista, t.ex. "Finns skisser | Ja: Nej:"
|
||||
if (!parts && pending === null && text && !isOptionList(text) && isOptionList((cells[index + 1] ?? "").trim())) parts = { label: text, rest: "" };
|
||||
// En fråga eller rubrik utan kolon som är en känd etikett, t.ex. "Hur påverkas karaktärerna under scenariot?"
|
||||
if (!parts && pending === null && text && !text.includes("\n") && isKnown(text)) parts = { label: text, rest: "" };
|
||||
if (pending !== null) {
|
||||
if (!parts) {
|
||||
if (text) addPair(pending, text);
|
||||
pending = null;
|
||||
continue;
|
||||
}
|
||||
pending = null;
|
||||
}
|
||||
if (!text) continue;
|
||||
if (parts) {
|
||||
out.labels.push(parts.label);
|
||||
const value = filledValue(parts.rest);
|
||||
if (value) addPair(parts.label, value);
|
||||
else pending = parts.label;
|
||||
} else {
|
||||
out.texts.push(text);
|
||||
}
|
||||
}
|
||||
// En rad med bara en etikett är en rubrik för en lista som följer
|
||||
if (pending !== null && cells.filter((c) => c.trim()).length === 1) {
|
||||
heading = pending;
|
||||
carry = pending;
|
||||
}
|
||||
}
|
||||
flushList();
|
||||
};
|
||||
|
||||
for (const block of blocks) {
|
||||
if (block.type === "table") {
|
||||
closeSection();
|
||||
readTable(block.rows);
|
||||
continue;
|
||||
}
|
||||
|
||||
const text = block.text;
|
||||
const parts = isOptionList(text) ? null : splitLabel(text);
|
||||
if (parts) {
|
||||
out.labels.push(parts.label);
|
||||
const value = filledValue(parts.rest);
|
||||
if (!value) {
|
||||
// En rubrik: det som följer är värdet
|
||||
closeSection();
|
||||
heading = parts.label;
|
||||
section = { label: parts.label, lines: [] };
|
||||
continue;
|
||||
}
|
||||
if (isKnown(parts.label)) {
|
||||
closeSection();
|
||||
addPair(parts.label, value);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (!parts && !text.includes("\n") && isKnown(text)) {
|
||||
out.labels.push(text);
|
||||
closeSection();
|
||||
heading = text;
|
||||
section = { label: text, lines: [] };
|
||||
continue;
|
||||
}
|
||||
if (section) section.lines.push(text);
|
||||
else out.texts.push(text);
|
||||
}
|
||||
closeSection();
|
||||
return out;
|
||||
}
|
||||
|
||||
// ─── Dokumenttyper ──────────────────────────────────────────────────────────
|
||||
|
||||
/** Etiketten på dokumentets eget ID-fält, per dokumenttyp. */
|
||||
const CODE_LABEL: Partial<Record<ImportKind, string>> = {
|
||||
CHARACTER: "karaktärs",
|
||||
PET: "djur",
|
||||
HOME: "bostads",
|
||||
COMPANY: "företags",
|
||||
PREMISES: "lokal",
|
||||
EDUCATION: "utbildnings",
|
||||
SCENARIO: "scenario",
|
||||
VEHICLE: "fordons",
|
||||
REFERENCE: "referens",
|
||||
RESEARCH: "research",
|
||||
RELATION: "relations",
|
||||
};
|
||||
|
||||
/** Etiketter som pekar ut vilken sorts dokument det är (normaliserade, utan "ID"). */
|
||||
const KIND_BY_LABEL: Record<string, ImportKind> = Object.fromEntries(Object.entries(CODE_LABEL).map(([kind, label]) => [label!, kind as ImportKind]));
|
||||
|
||||
/** Etiketter som ger postens namn. Flera delar sätts ihop i ordning (förnamn och efternamn). */
|
||||
const NAME_LABELS: Partial<Record<ImportKind, string[]>> = {
|
||||
CHARACTER: ["förnamn", "efternamn"],
|
||||
PET: ["namn"],
|
||||
COMPANY: ["företagets namn", "företags namn", "företagsnamn"],
|
||||
EDUCATION: ["skolans namn", "utbildningens namn"],
|
||||
APP: ["namn"],
|
||||
WEBSITE: ["namn"],
|
||||
VEHICLE: ["märke och modell"],
|
||||
};
|
||||
const GENERIC_NAME = ["namn"];
|
||||
|
||||
type LinkRule = { type: string; /** Posten i dokumentet är det man länkar till */ toDocument: boolean };
|
||||
|
||||
/** Vad en deltagarlista eller ett fält betyder, per dokumenttyp och rubrik (normaliserad). */
|
||||
const LINK_RULES: Partial<Record<ImportKind, Record<string, LinkRule>>> = {
|
||||
HOME: { boende: { type: "Bor på", toDocument: true } },
|
||||
COMPANY: { anställda: { type: "Jobbar på", toDocument: true } },
|
||||
EDUCATION: {
|
||||
"lärare till klassen": { type: "Lärare på", toDocument: true },
|
||||
"elever i klassen": { type: "Elev på", toDocument: true },
|
||||
},
|
||||
SCENARIO: {
|
||||
"involverade karaktärer": { type: "Involverad i", toDocument: true },
|
||||
"berörda karaktärer": { type: "Berörd av", toDocument: true },
|
||||
},
|
||||
CHARACTER: { "anställd hos": { type: "Jobbar på", toDocument: false } },
|
||||
PET: { ägare: { type: "Husdjur till", toDocument: false } },
|
||||
};
|
||||
|
||||
/** Etiketter i dokumenten som avser ett fält med annat namn i mallen. */
|
||||
const ALIASES: Partial<Record<ImportKind, Record<string, string>>> = { SCENARIO: { kopplat: "linkedEntity" } };
|
||||
|
||||
export function fieldsFor(kind: ImportKind, templates?: Partial<Record<ImportKind, FieldDef[]>>): FieldDef[] {
|
||||
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));
|
||||
}
|
||||
|
||||
/** 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;
|
||||
const allLabels = [...extracted.labels, ...extracted.registers.flatMap((r) => r.header)];
|
||||
for (const label of allLabels) {
|
||||
const kind = KIND_BY_LABEL[normLabel(label)];
|
||||
// "Lokal ID" är ett eget ID i en lokalmall men en koppling i en företagsmall, så de mer unika etiketterna prövas först
|
||||
if (kind && kind !== "PREMISES") return kind;
|
||||
}
|
||||
const text = [filename, ...extracted.texts, ...extracted.labels].join(" ").toLowerCase();
|
||||
if (/hemsid/.test(text)) return "WEBSITE";
|
||||
if (/\bapp(ar|likation\w*)?\b|appregister/.test(text)) return "APP";
|
||||
if (allLabels.some((l) => normLabel(l) === "lokal")) return "PREMISES";
|
||||
|
||||
let best: { kind: ImportKind; score: number } | null = null;
|
||||
for (const kind of IMPORT_KINDS) {
|
||||
const fields = fieldsFor(kind, templates);
|
||||
const score = allLabels.filter((l) => fields.some((f) => labelsMatch(l, f.label))).length;
|
||||
if (score > (best?.score ?? 0)) best = { kind, score };
|
||||
}
|
||||
return best?.kind ?? null;
|
||||
}
|
||||
|
||||
// ─── Värden ─────────────────────────────────────────────────────────────────
|
||||
|
||||
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;
|
||||
const code = CODE_IN_TEXT.exec(text)?.[0];
|
||||
if (code) {
|
||||
const byCode = pool.find((e) => e.code === code);
|
||||
if (byCode) return byCode;
|
||||
}
|
||||
const name = text.replace(CODE_IN_TEXT, "").replace(/[()[\],;:]+/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
|
||||
if (!name) return null;
|
||||
const matches = pool.filter((e) => e.name.toLowerCase() === name);
|
||||
return matches.length === 1 ? matches[0] : null;
|
||||
}
|
||||
|
||||
export type ItemLink = {
|
||||
/** Vilken typ av relation som skapas */
|
||||
type: string;
|
||||
toDocument: boolean;
|
||||
/** Posten i boken, eller null om den inte hittades */
|
||||
entityId: string | null;
|
||||
/** Det som stod i dokumentet */
|
||||
text: string;
|
||||
note: string;
|
||||
};
|
||||
|
||||
export type ParsedItem = {
|
||||
entityKind: ImportKind;
|
||||
name: string;
|
||||
code: string | null;
|
||||
data: Record<string, unknown>;
|
||||
/** Läsbar text för kopplingsfält, per fältnyckel */
|
||||
display: Record<string, string>;
|
||||
links: ItemLink[];
|
||||
/** Det som stod i dokumentet men inte gick att placera i ett fält */
|
||||
unmatched: Pair[];
|
||||
};
|
||||
|
||||
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 {
|
||||
const text = raw.trim();
|
||||
if (!text) return null;
|
||||
switch (field.type) {
|
||||
case "number": {
|
||||
const n = Number(/-?\d+(?:[.,]\d+)?/.exec(text.replace(/\s/g, ""))?.[0]?.replace(",", "."));
|
||||
return Number.isFinite(n) ? { value: n } : null;
|
||||
}
|
||||
case "date": {
|
||||
const date = normalizeStoryDate(text) ?? normalizeStoryDate(/\d{4}(?:-\d{1,2}(?:-\d{1,2})?)?/.exec(text)?.[0]);
|
||||
return date ? { value: date } : null;
|
||||
}
|
||||
case "checkbox": {
|
||||
const yes = parseYesNo(text);
|
||||
return yes === null ? null : { value: yes };
|
||||
}
|
||||
case "select": {
|
||||
const option = pickOption(text, field.options ?? []);
|
||||
return option ? { value: option } : null;
|
||||
}
|
||||
case "url":
|
||||
return /^https?:\/\/\S+$/i.test(text) ? { value: text } : null;
|
||||
case "reference": {
|
||||
const entity = findEntity(text, ctx.known, field.refKind);
|
||||
return entity ? { value: entity.id, display: entity.code ? `${entity.code} · ${entity.name}` : entity.name } : null;
|
||||
}
|
||||
default:
|
||||
return { value: text };
|
||||
}
|
||||
}
|
||||
|
||||
/** Delar ett värde som "KI-0001, Anna" eller en lista med en post per rad i flera poster. */
|
||||
function splitEntries(value: string): string[] {
|
||||
return value
|
||||
.split(/\n|;|,(?=\s*[A-ZÅÄÖ])/)
|
||||
.map((s) => s.trim())
|
||||
.filter(Boolean);
|
||||
}
|
||||
|
||||
/** Tolkar etikett/värde-par till en post. */
|
||||
export function buildItem(kind: ImportKind, pairs: Pair[], lists: ListBlock[], ctx: Context): ParsedItem {
|
||||
const item: ParsedItem = { entityKind: kind, name: "", code: null, data: {}, display: {}, links: [], unmatched: [] };
|
||||
const nameParts: { order: number; value: string }[] = [];
|
||||
const nameLabels = NAME_LABELS[kind] ?? [];
|
||||
const links = LINK_RULES[kind] ?? {};
|
||||
const used = new Set<string>();
|
||||
|
||||
for (const pair of pairs) {
|
||||
const norm = normLabel(pair.label);
|
||||
const value = pair.value.trim();
|
||||
if (!value) continue;
|
||||
|
||||
if (norm === CODE_LABEL[kind]) {
|
||||
item.code = CODE_IN_TEXT.exec(value)?.[0] ?? null;
|
||||
continue;
|
||||
}
|
||||
const nameIndex = nameLabels.findIndex((n) => normLabel(n) === norm);
|
||||
if (nameIndex >= 0 || (GENERIC_NAME.includes(norm) && nameLabels.length === 0)) {
|
||||
nameParts.push({ order: Math.max(nameIndex, 0), value });
|
||||
// Märke och modell är dessutom ett vanligt fält i mallen
|
||||
if (kind !== "VEHICLE") continue;
|
||||
}
|
||||
if (GENERIC_NAME.includes(norm) && nameLabels.length > 0 && nameIndex < 0 && kind !== "VEHICLE") {
|
||||
nameParts.push({ order: 9, value });
|
||||
continue;
|
||||
}
|
||||
|
||||
const linkKey = Object.keys(links).find((k) => labelsMatch(k, pair.label));
|
||||
if (linkKey && !links[linkKey].toDocument) {
|
||||
for (const entry of splitEntries(value)) {
|
||||
const entity = findEntity(entry, ctx.known);
|
||||
item.links.push({ type: links[linkKey].type, toDocument: false, entityId: entity?.id ?? null, text: entry, note: "" });
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// Ålder och födelsedatum står ihop i en etikett i karaktärsmallen
|
||||
if (kind === "CHARACTER" && labelsMatch(pair.label, "ålderfödelsedatum")) {
|
||||
const date = normalizeStoryDate(/\d{4}(?:-\d{1,2}(?:-\d{1,2})?)?/.exec(value)?.[0]);
|
||||
const age = /^\d{1,3}$/.exec(value.trim())?.[0];
|
||||
if (date && !used.has("birthDate")) {
|
||||
item.data.birthDate = date;
|
||||
used.add("birthDate");
|
||||
continue;
|
||||
}
|
||||
if (age && !used.has("age")) {
|
||||
item.data.age = Number(age);
|
||||
used.add("age");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
const alias = ALIASES[kind]?.[norm];
|
||||
const free = ctx.fields.filter((f) => !used.has(f.key));
|
||||
const loose = free.filter((f) => looseMatch(pair.label, f.label));
|
||||
const field = free.find((f) => f.key === alias || labelsMatch(pair.label, f.label)) ?? (loose.length === 1 ? loose[0] : undefined);
|
||||
const converted = field ? convert(field, value, ctx) : null;
|
||||
if (field && converted) {
|
||||
item.data[field.key] = converted.value;
|
||||
if (converted.display) item.display[field.key] = converted.display;
|
||||
used.add(field.key);
|
||||
} else {
|
||||
item.unmatched.push({ label: pair.label.trim(), value });
|
||||
}
|
||||
}
|
||||
|
||||
item.name = nameParts.sort((a, b) => a.order - b.order).map((p) => p.value).join(" ").trim();
|
||||
|
||||
for (const list of lists) {
|
||||
const key = Object.keys(links).find((k) => labelsMatch(k, list.heading));
|
||||
if (!key) {
|
||||
for (const e of list.entries) item.unmatched.push({ label: list.heading || "Lista", value: [e.name, e.code].filter(Boolean).join(" ") });
|
||||
continue;
|
||||
}
|
||||
for (const entry of list.entries) {
|
||||
const text = [entry.name, entry.code].filter(Boolean).join(" ");
|
||||
if (!text) continue;
|
||||
const entity = findEntity(entry.code || "", ctx.known) ?? findEntity(text, ctx.known);
|
||||
item.links.push({
|
||||
type: links[key].type,
|
||||
toDocument: links[key].toDocument,
|
||||
entityId: entity?.id ?? null,
|
||||
text,
|
||||
note: [entry.role, entry.subject].filter(Boolean).join(", "),
|
||||
});
|
||||
}
|
||||
}
|
||||
return item;
|
||||
}
|
||||
|
||||
export function usableCode(kind: EntityKind, code: string | null): string | null {
|
||||
const prefix = ENTITY_PREFIX[kind];
|
||||
return code && prefix && new RegExp(`^${prefix}-\\d+$`).test(code) ? code : null;
|
||||
}
|
||||
|
||||
// ─── Hela dokument ──────────────────────────────────────────────────────────
|
||||
|
||||
export type ParsedDocument = {
|
||||
file: string;
|
||||
kind: ImportKind | null;
|
||||
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 }[] };
|
||||
warnings: string[];
|
||||
};
|
||||
|
||||
const baseName = (file: string) => file.replace(/\.[^.]+$/, "").trim();
|
||||
|
||||
/** Fördelar paren i ett appregister (upprepade Namn/Beskrivning) på en post per app. */
|
||||
function groupByName(pairs: Pair[]): Pair[][] {
|
||||
const groups: Pair[][] = [];
|
||||
for (const pair of pairs) {
|
||||
if (normLabel(pair.label) === "namn" || groups.length === 0) groups.push([]);
|
||||
groups[groups.length - 1].push(pair);
|
||||
}
|
||||
return groups.filter((g) => g.some((p) => normLabel(p.label) === "namn"));
|
||||
}
|
||||
|
||||
function fallbackName(kind: ImportKind, item: ParsedItem, file: string): string {
|
||||
if (item.name) return item.name;
|
||||
const address = typeof item.data.address === "string" ? item.data.address : "";
|
||||
const description = typeof item.data.description === "string" ? item.data.description : "";
|
||||
const type = ["homeType", "scenarioType"].map((k) => item.data[k]).find((v) => typeof v === "string") as string | undefined;
|
||||
const typed = [type, item.code].filter(Boolean).join(" ");
|
||||
// Ett scenario heter efter typ och ID, referenser och research efter sin beskrivning
|
||||
const candidates = kind === "SCENARIO" ? [typed, address, description.slice(0, 60)] : [address, description.slice(0, 60), typed];
|
||||
return (candidates.find(Boolean) || item.code || baseName(file) || kind).slice(0, 200);
|
||||
}
|
||||
|
||||
export function analyzeDocument(
|
||||
blocks: DocBlock[],
|
||||
file: string,
|
||||
known: KnownEntity[],
|
||||
options: { kind?: ImportKind | null; templates?: Partial<Record<ImportKind, FieldDef[]>> } = {},
|
||||
): ParsedDocument {
|
||||
const templates = options.templates;
|
||||
const knownLabel = (label: string) =>
|
||||
IMPORT_KINDS.some((k) => fieldsFor(k, templates).some((f) => labelsMatch(label, f.label))) ||
|
||||
Object.values(CODE_LABEL).some((c) => normLabel(label) === c) ||
|
||||
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: [] };
|
||||
if (!kind) {
|
||||
result.warnings.push(unsupportedDocument(extracted) ? "unsupported" : "unknown-kind");
|
||||
return result;
|
||||
}
|
||||
const ctx: Context = { known, fields: fieldsFor(kind, templates) };
|
||||
|
||||
if (kind === "RELATION") {
|
||||
const item = buildItem(kind, extracted.pairs, [], ctx);
|
||||
const list = extracted.lists.find((l) => /ingår/.test(normLabel(l.heading))) ?? extracted.lists[0];
|
||||
const participants = (list?.entries ?? [])
|
||||
.filter((e) => e.name || e.code)
|
||||
.map((e) => ({ text: [e.name, e.code].filter(Boolean).join(" "), entityId: (findEntity(e.code, known) ?? findEntity(e.name, known, "CHARACTER"))?.id ?? null }));
|
||||
const category = typeof item.data.category === "string" ? item.data.category : "";
|
||||
result.relation = { type: category || "Relation", participants };
|
||||
item.name = result.relation.type;
|
||||
result.items.push(item);
|
||||
if (participants.length < 2) result.warnings.push("few-participants");
|
||||
return result;
|
||||
}
|
||||
|
||||
if (extracted.registers.length > 0) {
|
||||
for (const table of extracted.registers) {
|
||||
for (const row of table.rows) {
|
||||
const pairs = table.header.map((label, i) => ({ label, value: row[i] ?? "" })).filter((p) => p.value.trim());
|
||||
// Kolumnen med registrets eget ID heter t.ex. "Fordons ID"
|
||||
const item = buildItem(kind, pairs, [], ctx);
|
||||
item.name = fallbackName(kind, item, file);
|
||||
result.items.push(item);
|
||||
}
|
||||
}
|
||||
if (result.items.length === 0) result.warnings.push("empty");
|
||||
return result;
|
||||
}
|
||||
|
||||
if (kind === "APP" || kind === "WEBSITE") {
|
||||
for (const group of groupByName(extracted.pairs)) {
|
||||
const item = buildItem(kind, group, [], ctx);
|
||||
item.name = fallbackName(kind, item, file);
|
||||
result.items.push(item);
|
||||
}
|
||||
if (result.items.length === 0) result.warnings.push("empty");
|
||||
return result;
|
||||
}
|
||||
|
||||
const item = buildItem(kind, extracted.pairs, extracted.lists, ctx);
|
||||
item.name = fallbackName(kind, item, file);
|
||||
if (Object.keys(item.data).length === 0 && !item.name && item.links.length === 0) result.warnings.push("empty");
|
||||
result.items.push(item);
|
||||
return result;
|
||||
}
|
||||
|
||||
/** Fält som tar emot det som inte gick att placera: Övrigt eller Beskrivning, annars ingenting. */
|
||||
export function overflowField(fields: FieldDef[]): string | null {
|
||||
return (fields.find((f) => f.key === "notes") ?? fields.find((f) => f.key === "description"))?.key ?? null;
|
||||
}
|
||||
|
||||
export function describeUnmatched(unmatched: Pair[]): string {
|
||||
return unmatched.map((p) => `${p.label}: ${p.value}`).join("\n");
|
||||
}
|
||||
|
||||
export { markedOption, parseOptions };
|
||||
@@ -0,0 +1,138 @@
|
||||
// Etiketter i Word-mallarna: jämförelse mellan etiketter, och val i rutor som "Ja: X Nej:".
|
||||
|
||||
/** Gör en etikett jämförbar: små bokstäver, utan parenteser (mallens hjälptexter), skiljetecken och ID-ord. */
|
||||
export function normLabel(text: string): string {
|
||||
return text
|
||||
.toLowerCase()
|
||||
.replace(/\([^)]*\)/g, " ")
|
||||
.replace(/[-–—_/.,:;?!"']/g, " ")
|
||||
.split(/\s+/)
|
||||
.filter((w) => w && w !== "id" && w !== "nr")
|
||||
.join(" ")
|
||||
.trim();
|
||||
}
|
||||
|
||||
const compact = (s: string) => s.replace(/\s+/g, "");
|
||||
|
||||
/**
|
||||
* Är två etiketter samma sak? Orden får stå i annan ordning, mellanslag och bindestreck spelar ingen roll
|
||||
* ("Djur kategori" och "Djurkategori"), och en skrivfel-ändelse på upp till två tecken godtas ("Längde" och "Längd").
|
||||
*/
|
||||
export function labelsMatch(a: string, b: string): boolean {
|
||||
const x = normLabel(a);
|
||||
const y = normLabel(b);
|
||||
if (!x || !y) return false;
|
||||
if (x === y || compact(x) === compact(y)) return true;
|
||||
if ([...x.split(" ")].sort().join(" ") === [...y.split(" ")].sort().join(" ")) return true;
|
||||
const [short, long] = compact(x).length <= compact(y).length ? [compact(x), compact(y)] : [compact(y), compact(x)];
|
||||
return short.length >= 4 && long.startsWith(short) && long.length - short.length <= 2;
|
||||
}
|
||||
|
||||
const STOP = new Set(["i", "och", "eller", "om", "av", "på", "till", "för", "att", "med", "mer", "är", "den", "det", "hur", "en", "ett", "som", "att", "beskriv"]);
|
||||
|
||||
/**
|
||||
* Lösare jämförelse för etiketter som skrivits längre eller på annat sätt än i mallen, t.ex. "Djurets personlighet" mot
|
||||
* "Personlighet". Alla betydelsebärande ord i fältets etikett ska finnas i dokumentets, och minst ett ord ska vara långt.
|
||||
*/
|
||||
export function looseMatch(docLabel: string, fieldLabel: string): boolean {
|
||||
const words = (s: string) => normLabel(s).split(" ").filter((w) => w && !STOP.has(w));
|
||||
const wanted = words(fieldLabel);
|
||||
const have = words(docLabel);
|
||||
if (wanted.length === 0 || have.length === 0 || !wanted.some((w) => w.length >= 5)) return false;
|
||||
const joined = have.join("");
|
||||
return wanted.every((w) => have.some((h) => h.startsWith(w) || w.startsWith(h)) || (w.length >= 4 && joined.includes(w)));
|
||||
}
|
||||
|
||||
// ─── Val i rutor ("Ja: X Nej:") ─────────────────────────────────────────────
|
||||
|
||||
export type MarkedOption = { label: string; marked: boolean };
|
||||
|
||||
const AFTER_MARK = /^(?:x|✓|✔|☒|☑|■)(?=\s|$)\s*/i;
|
||||
const BEFORE_MARK = /^(?:✓|✔|☒|☑|■)\s*/;
|
||||
const UNCHECKED = /^☐\s*/;
|
||||
|
||||
/** Är texten en lista med alternativ, till exempel "Ja: Nej:"? Parenteser (hjälptexter) räknas inte. */
|
||||
export function isOptionList(text: string): boolean {
|
||||
const stripped = text.replace(/\([^)]*\)/g, " ");
|
||||
if (stripped.length > 300) return false;
|
||||
const lines = stripped.split("\n").map((l) => l.trim()).filter(Boolean);
|
||||
if (lines.length === 0 || !singleLineOptions(lines[0])) return false;
|
||||
// Alternativen kan fortsätta på nästa rad: en ny rad med alternativ, eller ett enstaka kort alternativ ("Blivande:")
|
||||
return lines.slice(1).every((line) => singleLineOptions(line) || /^[^\s:]{1,15}:\s*(?:x|✓|✔|☒|☑|■)?$/i.test(line));
|
||||
}
|
||||
|
||||
/** Minst två alternativ med text på en rad, och varje del mellan kolon ska vara kort: alternativ, inte meningar. */
|
||||
function singleLineOptions(line: string): boolean {
|
||||
const parts = line.split(":");
|
||||
if (parts.slice(0, -1).filter((part) => part.trim()).length < 2) return false;
|
||||
return parts.every((part) => part.trim().length <= 40);
|
||||
}
|
||||
|
||||
/**
|
||||
* Läser en rad med alternativ och vilka som är markerade. Ett alternativ är markerat om det har ett kryss efter sig
|
||||
* ("Ja: X Nej:") eller en ruta med kryss före sig ("☒ Ja: ☐ Nej:"). Returnerar null om texten inte är en alternativlista.
|
||||
*/
|
||||
export function parseOptions(text: string): MarkedOption[] | null {
|
||||
if (!isOptionList(text)) return null;
|
||||
const parts = text.replace(/\([^)]*\)/g, " ").replace(/\s*\n\s*/g, " ").split(":");
|
||||
const options: MarkedOption[] = [];
|
||||
|
||||
parts.forEach((part, index) => {
|
||||
let rest = part.trim();
|
||||
// Kryss efter föregående alternativ
|
||||
if (index > 0 && options.length > 0) {
|
||||
const after = AFTER_MARK.exec(rest);
|
||||
if (after) {
|
||||
options[options.length - 1].marked = true;
|
||||
rest = rest.slice(after[0].length).trim();
|
||||
}
|
||||
}
|
||||
if (index === parts.length - 1) return; // texten efter sista kolonet är bara ett eventuellt kryss
|
||||
let marked = false;
|
||||
const before = BEFORE_MARK.exec(rest) ?? (index === 0 ? AFTER_MARK.exec(rest) : null);
|
||||
if (before) {
|
||||
marked = true;
|
||||
rest = rest.slice(before[0].length).trim();
|
||||
} else {
|
||||
const unchecked = UNCHECKED.exec(rest);
|
||||
if (unchecked) rest = rest.slice(unchecked[0].length).trim();
|
||||
}
|
||||
if (rest) options.push({ label: rest, marked });
|
||||
});
|
||||
return options.length >= 2 ? options : null;
|
||||
}
|
||||
|
||||
/** Det markerade alternativet, eller null om inget (eller flera) är markerat. */
|
||||
export function markedOption(options: MarkedOption[]): string | null {
|
||||
const marked = options.filter((o) => o.marked);
|
||||
return marked.length === 1 ? marked[0].label : null;
|
||||
}
|
||||
|
||||
const YES = new Set(["ja", "yes", "x", "✓", "✔", "☒", "☑", "sant", "true"]);
|
||||
const NO = new Set(["nej", "no", "falskt", "false"]);
|
||||
|
||||
/** Tolkar ett ja/nej-värde, eller null om det inte går att avgöra. */
|
||||
export function parseYesNo(raw: string): boolean | null {
|
||||
const options = parseOptions(raw);
|
||||
const text = (options ? markedOption(options) : raw.trim())?.toLowerCase().replace(/[.!]+$/, "") ?? "";
|
||||
if (YES.has(text)) return true;
|
||||
if (NO.has(text)) return false;
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Hittar det alternativ i `options` som texten avser (samma ord, eller samma början), eller null. */
|
||||
export function pickOption(raw: string, options: string[]): string | null {
|
||||
const parsed = parseOptions(raw);
|
||||
const text = (parsed ? markedOption(parsed) : raw.trim()) ?? "";
|
||||
if (!text) return null;
|
||||
const wanted = normLabel(text);
|
||||
if (!wanted) return null;
|
||||
const exact = options.find((o) => normLabel(o) === wanted);
|
||||
if (exact) return exact;
|
||||
const prefix = options.find((o) => {
|
||||
const n = normLabel(o);
|
||||
const [short, long] = n.length <= wanted.length ? [n, wanted] : [wanted, n];
|
||||
return short.length >= 3 && long.startsWith(short);
|
||||
});
|
||||
return prefix ?? null;
|
||||
}
|
||||
@@ -0,0 +1,242 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { UPLOAD_DIR, saveImageBytes } from "@/lib/files";
|
||||
import { MAX_VERSIONS } from "@/lib/history";
|
||||
import { isStale, versionOf, type ConflictInfo, type SaveResult } from "@/lib/conflict";
|
||||
import { makeImage } from "../helpers/fixtures";
|
||||
import { describeDb, filesIn, makeBook, makeEntity, makeEvent, makeRelation, 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 { saveEntity } from "@/actions/entities";
|
||||
import { saveEvent } from "@/actions/events";
|
||||
import { saveRelation } from "@/actions/relations";
|
||||
|
||||
const form = (fields: Record<string, string | string[] | Blob>) => {
|
||||
const data = new FormData();
|
||||
for (const [key, value] of Object.entries(fields)) {
|
||||
if (value instanceof Blob) data.append(key, value, "bild.png");
|
||||
else for (const v of Array.isArray(value) ? value : [value]) data.append(key, v);
|
||||
}
|
||||
return data;
|
||||
};
|
||||
|
||||
/** Kör en sparåtgärd. Antingen omdirigerar den (sparat) eller svarar med en krock. */
|
||||
async function save(run: () => Promise<SaveResult>): Promise<{ saved: true; to: string } | { saved: false; conflict: ConflictInfo }> {
|
||||
try {
|
||||
const result = await run();
|
||||
if (result?.conflict) return { saved: false, conflict: result.conflict };
|
||||
throw new Error("Åtgärden svarade varken med omdirigering eller krock");
|
||||
} catch (error) {
|
||||
const message = error instanceof Error ? error.message : "";
|
||||
if (message.startsWith("REDIRECT:")) return { saved: true, to: message.slice(9) };
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
describe("isStale", () => {
|
||||
const now = new Date("2026-01-01T12:00:00.000Z");
|
||||
it("jämför versionen som formuläret öppnades med", () => {
|
||||
expect(isStale(versionOf(now), now)).toBe(false);
|
||||
expect(isStale(versionOf(new Date(now.getTime() - 1)), now)).toBe(true);
|
||||
});
|
||||
it("kontrollerar inget när versionen saknas", () => {
|
||||
expect(isStale("", now)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describeDb("skydd mot kolliderande ändringar", () => {
|
||||
let ownerId: string;
|
||||
let otherId: string;
|
||||
let bookId: string;
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetAll();
|
||||
const owner = await makeUser("Ägare");
|
||||
const other = await makeUser("Kollega", "kollega@example.com");
|
||||
ownerId = owner.id;
|
||||
otherId = other.id;
|
||||
bookId = (await makeBook(ownerId)).id;
|
||||
await prisma.bookMember.create({ data: { bookId, userId: otherId, role: "EDITOR" } });
|
||||
login.userId = ownerId;
|
||||
});
|
||||
|
||||
describe("poster", () => {
|
||||
const edit = (id: string, version: string, fields: Record<string, string> = {}) =>
|
||||
save(() => saveEntity(form({ bookId, id, name: "Anna", version, ...fields })));
|
||||
|
||||
it("sparar när versionen stämmer, och ger en ny version", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
const result = await edit(anna.id, versionOf(anna.updatedAt), { summary: "Ny" });
|
||||
expect(result).toMatchObject({ saved: true });
|
||||
const after = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
|
||||
expect(after.summary).toBe("Ny");
|
||||
expect(after.updatedById).toBe(ownerId);
|
||||
expect(versionOf(after.updatedAt)).not.toBe(versionOf(anna.updatedAt));
|
||||
});
|
||||
|
||||
it("sparar ingenting när någon annan hunnit före, och visar vad som skiljer", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { summary: "Från början", data: { nickname: "Ann" } });
|
||||
const opened = versionOf(anna.updatedAt);
|
||||
|
||||
// Kollegan sparar först
|
||||
login.userId = otherId;
|
||||
await edit(anna.id, opened, { summary: "Kollegans text", f_nickname: "Ann" });
|
||||
|
||||
// Sedan sparar den första med den gamla versionen
|
||||
login.userId = ownerId;
|
||||
const result = await edit(anna.id, opened, { summary: "Min text", f_nickname: "Annie" });
|
||||
expect(result.saved).toBe(false);
|
||||
if (result.saved) return;
|
||||
|
||||
expect(result.conflict.by).toBe("Kollega");
|
||||
expect(result.conflict.changes).toEqual(
|
||||
expect.arrayContaining([
|
||||
{ label: "Sammanfattning", before: "Kollegans text", after: "Min text" },
|
||||
{ label: "Smeknamn", before: "Ann", after: "Annie" },
|
||||
]),
|
||||
);
|
||||
const stored = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
|
||||
expect(stored.summary).toBe("Kollegans text");
|
||||
expect(stored.updatedById).toBe(otherId);
|
||||
});
|
||||
|
||||
it("att spara ändå med den nya versionen skriver över, och den andras version hamnar i historiken", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { summary: "Från början" });
|
||||
const opened = versionOf(anna.updatedAt);
|
||||
login.userId = otherId;
|
||||
await edit(anna.id, opened, { summary: "Kollegans text" });
|
||||
|
||||
login.userId = ownerId;
|
||||
const conflict = await edit(anna.id, opened, { summary: "Min text" });
|
||||
if (conflict.saved) throw new Error("Väntade en krock");
|
||||
const forced = await edit(anna.id, conflict.conflict.version, { summary: "Min text" });
|
||||
expect(forced.saved).toBe(true);
|
||||
|
||||
expect((await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).summary).toBe("Min text");
|
||||
const versions = await prisma.entityVersion.findMany({ where: { entityId: anna.id }, orderBy: { createdAt: "asc" } });
|
||||
const summaries = versions.map((v) => (v.snapshot as { summary: string }).summary);
|
||||
expect(summaries).toEqual(["Från början", "Kollegans text"]);
|
||||
expect(versions[1].userId).toBe(ownerId);
|
||||
});
|
||||
|
||||
it("tre samtidiga redigerare: bara en kommer igenom med samma version", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
const opened = versionOf(anna.updatedAt);
|
||||
const results = await Promise.all([1, 2, 3].map((n) => edit(anna.id, opened, { summary: `Text ${n}` }).catch((e) => ({ error: String(e) }))));
|
||||
const saved = results.filter((r) => "saved" in r && r.saved).length;
|
||||
const conflicts = results.filter((r) => "saved" in r && !r.saved).length;
|
||||
expect(saved).toBe(1);
|
||||
expect(conflicts).toBe(2);
|
||||
});
|
||||
|
||||
it("en ny bild läggs inte kvar som skräp när sparningen avbryts av en krock", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
const opened = versionOf(anna.updatedAt);
|
||||
await edit(anna.id, opened, { summary: "Först" });
|
||||
|
||||
const before = await filesIn(UPLOAD_DIR);
|
||||
const png = new Blob([(await makeImage(50, 50, "png")) as BlobPart], { type: "image/png" });
|
||||
const result = await save(() => saveEntity(form({ bookId, id: anna.id, name: "Anna", version: opened, image: png })));
|
||||
expect(result.saved).toBe(false);
|
||||
expect(await filesIn(UPLOAD_DIR)).toEqual(before);
|
||||
});
|
||||
|
||||
it("en bild som byts ut tar bort den gamla först när sparningen lyckats", async () => {
|
||||
const old = await saveImageBytes(await makeImage(40, 40, "png"));
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: old });
|
||||
const png = new Blob([(await makeImage(50, 50, "png")) as BlobPart], { type: "image/png" });
|
||||
const result = await edit(anna.id, versionOf(anna.updatedAt), { image: png as unknown as string });
|
||||
expect(result.saved).toBe(true);
|
||||
const after = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
|
||||
expect(after.imageFile).toBeTruthy();
|
||||
expect(after.imageFile).not.toBe(old);
|
||||
expect(await filesIn(UPLOAD_DIR)).not.toContain(old);
|
||||
});
|
||||
|
||||
it("formulär utan version sparas som förut", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
expect((await save(() => saveEntity(form({ bookId, id: anna.id, name: "Anna", summary: "Utan version" })))).saved).toBe(true);
|
||||
});
|
||||
|
||||
it("nya poster behöver ingen version", async () => {
|
||||
const result = await save(() => saveEntity(form({ bookId, kind: "CHARACTER", name: "Ny", version: "" })));
|
||||
expect(result.saved).toBe(true);
|
||||
expect((await prisma.entity.findFirstOrThrow({ where: { name: "Ny" } })).updatedById).toBe(ownerId);
|
||||
});
|
||||
|
||||
it("historiken håller sig inom gränsen även med många krockar", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
let version = versionOf(anna.updatedAt);
|
||||
for (let i = 0; i < MAX_VERSIONS + 3; i++) {
|
||||
await edit(anna.id, version, { summary: `v${i}` });
|
||||
version = versionOf((await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).updatedAt);
|
||||
}
|
||||
expect(await prisma.entityVersion.count({ where: { entityId: anna.id } })).toBe(MAX_VERSIONS);
|
||||
});
|
||||
});
|
||||
|
||||
describe("relationer", () => {
|
||||
it("kan inte skriva över en relation som ändrats av någon annan", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const b = await makeEntity(bookId, "CHARACTER", "B");
|
||||
const relation = await makeRelation(bookId, a.id, b.id, "Vänner");
|
||||
const opened = versionOf(relation.updatedAt);
|
||||
const edit = (type: string, version: string) => save(() => saveRelation(form({ bookId, id: relation.id, type, version })));
|
||||
|
||||
login.userId = otherId;
|
||||
expect((await edit("Bästa vänner", opened)).saved).toBe(true);
|
||||
login.userId = ownerId;
|
||||
const result = await edit("Ovänner", opened);
|
||||
expect(result.saved).toBe(false);
|
||||
if (result.saved) return;
|
||||
expect(result.conflict.by).toBe("Kollega");
|
||||
expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Bästa vänner");
|
||||
|
||||
expect((await edit("Ovänner", result.conflict.version)).saved).toBe(true);
|
||||
expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Ovänner");
|
||||
});
|
||||
|
||||
it("deltagarna behålls när en sparning avvisas", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const b = await makeEntity(bookId, "CHARACTER", "B");
|
||||
const c = await makeEntity(bookId, "CHARACTER", "C");
|
||||
const relation = await makeRelation(bookId, a.id, b.id, "Grupp", [c.id]);
|
||||
const opened = versionOf(relation.updatedAt);
|
||||
await save(() => saveRelation(form({ bookId, id: relation.id, type: "Grupp 2", version: opened, memberIds: [c.id] })));
|
||||
const result = await save(() => saveRelation(form({ bookId, id: relation.id, type: "Grupp 3", version: opened })));
|
||||
expect(result.saved).toBe(false);
|
||||
expect(await prisma.relationMember.count({ where: { relationId: relation.id } })).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("händelser", () => {
|
||||
it("kan inte skriva över en händelse som ändrats av någon annan", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const event = await makeEvent(bookId, "Fest", "2000", [a.id]);
|
||||
const opened = versionOf(event.updatedAt);
|
||||
const edit = (title: string, version: string) => save(() => saveEvent(form({ bookId, id: event.id, title, date: "2000", version, participantIds: [a.id] })));
|
||||
|
||||
login.userId = otherId;
|
||||
expect((await edit("Stor fest", opened)).saved).toBe(true);
|
||||
login.userId = ownerId;
|
||||
const result = await edit("Liten fest", opened);
|
||||
expect(result.saved).toBe(false);
|
||||
expect((await prisma.storyEvent.findUniqueOrThrow({ where: { id: event.id } })).title).toBe("Stor fest");
|
||||
expect(await prisma.eventParticipant.count({ where: { eventId: event.id } })).toBe(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,327 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { UPLOAD_DIR, saveImageBytes } from "@/lib/files";
|
||||
import { makeImage } from "../helpers/fixtures";
|
||||
import { describeDb, filesIn, makeBook, makeEntity, makeEvent, makeRelation, makeUser, prisma, resetAll } from "../helpers/db";
|
||||
|
||||
// Här används den riktiga inloggningskontrollen (session.ts). Bara själva inloggningen, cache och
|
||||
// omdirigeringar ersätts, så att åtgärderna kan köras utan webbserver.
|
||||
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 { deleteBook, updateBook } from "@/actions/books";
|
||||
import { deleteEntity, saveEntity } from "@/actions/entities";
|
||||
import { addEvent } from "@/actions/events";
|
||||
import { addRelation } from "@/actions/relations";
|
||||
import { changeMemberRole, leaveSharedBook, removeBookMember, shareBook } from "@/actions/sharing";
|
||||
import { emptyTrash, purgeTrash, restoreTrashEntity } from "@/actions/trash";
|
||||
import { saveTemplate } from "@/actions/templates";
|
||||
import { GET as exportBook } from "@/app/api/books/[bookId]/export/route";
|
||||
import { GET as searchBook } from "@/app/api/books/[bookId]/search/route";
|
||||
import { bookAccess } from "@/lib/book-access";
|
||||
import { listMembers } from "@/lib/sharing";
|
||||
|
||||
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;
|
||||
};
|
||||
|
||||
/** Kör en åtgärd. Returnerar "ok" om den gick igenom, annars vad som hände (omdirigering eller 404). */
|
||||
async function attempt(run: () => Promise<unknown>): Promise<string> {
|
||||
try {
|
||||
await run();
|
||||
return "ok";
|
||||
} catch (error) {
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
if (message.startsWith("REDIRECT:") || message === "NOT_FOUND") return message;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
describeDb("delning av böcker", () => {
|
||||
let owner: { id: string };
|
||||
let admin: { id: string };
|
||||
let editor: { id: string };
|
||||
let viewer: { id: string };
|
||||
let stranger: { id: string };
|
||||
let bookId: string;
|
||||
|
||||
const as = (user: { id: string }) => {
|
||||
login.userId = user.id;
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetAll();
|
||||
owner = await makeUser("Ägare");
|
||||
admin = await makeUser("Admin");
|
||||
editor = await makeUser("Redaktör");
|
||||
viewer = await makeUser("Läsare");
|
||||
stranger = await makeUser("Obehörig");
|
||||
bookId = (await makeBook(owner.id, "Delad bok")).id;
|
||||
await prisma.bookMember.createMany({
|
||||
data: [
|
||||
{ bookId, userId: admin.id, role: "ADMIN" },
|
||||
{ bookId, userId: editor.id, role: "EDITOR" },
|
||||
{ bookId, userId: viewer.id, role: "VIEWER" },
|
||||
],
|
||||
});
|
||||
});
|
||||
|
||||
describe("åtkomst", () => {
|
||||
it("ger rätt roll åt ägare, medlemmar och ingen alls åt andra", async () => {
|
||||
expect((await bookAccess(bookId, owner.id))?.role).toBe("OWNER");
|
||||
expect((await bookAccess(bookId, admin.id))?.role).toBe("ADMIN");
|
||||
expect((await bookAccess(bookId, editor.id))?.role).toBe("EDITOR");
|
||||
expect((await bookAccess(bookId, viewer.id))?.role).toBe("VIEWER");
|
||||
expect(await bookAccess(bookId, stranger.id)).toBeNull();
|
||||
expect(await bookAccess("finns-inte", owner.id)).toBeNull();
|
||||
});
|
||||
|
||||
it("boken ligger kvar hos ägaren och medlemskapet försvinner med boken eller användaren", async () => {
|
||||
await prisma.user.delete({ where: { id: editor.id } });
|
||||
expect(await prisma.bookMember.count({ where: { bookId } })).toBe(2);
|
||||
await prisma.book.delete({ where: { id: bookId } });
|
||||
expect(await prisma.bookMember.count()).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("vad varje roll får göra", () => {
|
||||
const create = (name: string) => saveEntity(form({ bookId, kind: "CHARACTER", name }));
|
||||
|
||||
it("läsare kan läsa men inte skriva", async () => {
|
||||
as(viewer);
|
||||
expect(await attempt(() => create("Ny"))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => addRelation(form({ bookId, fromId: "a", toId: "b", type: "x" })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => addEvent(form({ bookId, title: "x", date: "2000" })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.entity.count()).toBe(0);
|
||||
// Läsning och export fungerar
|
||||
const res = await exportBook(new Request("http://x/api"), { params: Promise.resolve({ bookId }) });
|
||||
expect(res.status).toBe(200);
|
||||
});
|
||||
|
||||
it("redaktörer skriver som ägaren men administrerar inte", async () => {
|
||||
as(editor);
|
||||
expect(await attempt(() => create("Anna"))).toMatch(/^REDIRECT:/);
|
||||
const anna = await prisma.entity.findFirstOrThrow({ where: { bookId } });
|
||||
expect(anna.updatedById).toBe(editor.id);
|
||||
expect(await attempt(() => updateBook(form({ bookId, title: "Ny titel" })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => saveTemplate(form({ bookId, kind: "CHARACTER", fields: "[]" })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => shareBook(form({ bookId, email: "x@example.com", role: "VIEWER" })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => deleteBook(form({ bookId })))).toBe("NOT_FOUND");
|
||||
expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Delad bok");
|
||||
});
|
||||
|
||||
it("administratörer ändrar bokens uppgifter och delar den, men tar inte bort den", async () => {
|
||||
as(admin);
|
||||
expect(await attempt(() => updateBook(form({ bookId, title: "Nytt namn" })))).toBe("ok");
|
||||
expect((await prisma.book.findUniqueOrThrow({ where: { id: bookId } })).title).toBe("Nytt namn");
|
||||
expect(await attempt(() => deleteBook(form({ bookId })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.book.count()).toBe(1);
|
||||
});
|
||||
|
||||
it("bara ägaren tar bort boken, och den hamnar i ägarens papperskorg", async () => {
|
||||
as(owner);
|
||||
expect(await attempt(() => deleteBook(form({ bookId })))).toBe("REDIRECT:/");
|
||||
expect(await prisma.book.count()).toBe(0);
|
||||
expect(await prisma.trashItem.count({ where: { ownerId: owner.id, kind: "book" } })).toBe(1);
|
||||
});
|
||||
|
||||
it("obehöriga får 404 överallt, även för export och sök", async () => {
|
||||
as(stranger);
|
||||
expect(await attempt(() => create("Intrång"))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => updateBook(form({ bookId, title: "x" })))).toBe("NOT_FOUND");
|
||||
expect((await exportBook(new Request("http://x/api"), { params: Promise.resolve({ bookId }) })).status).toBe(404);
|
||||
expect((await searchBook(new Request("http://x/api?q=anna"), { params: Promise.resolve({ bookId }) })).status).toBe(404);
|
||||
});
|
||||
|
||||
it("sök fungerar för medlemmar", async () => {
|
||||
await makeEntity(bookId, "CHARACTER", "Annika");
|
||||
as(viewer);
|
||||
const res = await searchBook(new Request("http://x/api?q=anni"), { params: Promise.resolve({ bookId }) });
|
||||
expect(res.status).toBe(200);
|
||||
expect(((await res.json()) as { results: unknown[] }).results).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("inloggning krävs", async () => {
|
||||
login.userId = "";
|
||||
expect(await attempt(() => create("Anonym"))).toBe("REDIRECT:/login");
|
||||
expect((await exportBook(new Request("http://x/api"), { params: Promise.resolve({ bookId }) })).status).toBe(401);
|
||||
});
|
||||
});
|
||||
|
||||
describe("hantera delningen", () => {
|
||||
it("ägaren delar med e-postadress, oavsett stora och små bokstäver", async () => {
|
||||
const friend = await makeUser("Vän", "Vän@Example.com");
|
||||
as(owner);
|
||||
expect(await attempt(() => shareBook(form({ bookId, email: " vän@example.COM ", role: "EDITOR" })))).toBe("REDIRECT:" + `/books/${bookId}/settings?share=ok`);
|
||||
expect((await prisma.bookMember.findFirstOrThrow({ where: { userId: friend.id } })).role).toBe("EDITOR");
|
||||
});
|
||||
|
||||
it("ger tydliga svar när delningen inte går", async () => {
|
||||
as(owner);
|
||||
const share = (email: string, role = "EDITOR") => attempt(() => shareBook(form({ bookId, email, role })));
|
||||
expect(await share("ingen@example.com")).toContain("share=not-found");
|
||||
expect(await share("ägare@example.com")).toContain("share=owner");
|
||||
expect(await share("redaktör@example.com")).toContain("share=already");
|
||||
expect(await share("inte-en-adress")).toContain("share=invalid");
|
||||
expect(await share("läsare@example.com", "SUPER")).toContain("share=invalid");
|
||||
expect(await prisma.bookMember.count()).toBe(3);
|
||||
});
|
||||
|
||||
it("en administratör kan dela som redaktör eller läsare men inte utse administratörer", async () => {
|
||||
const friend = await makeUser("Vän");
|
||||
as(admin);
|
||||
expect(await attempt(() => shareBook(form({ bookId, email: "vän@example.com", role: "ADMIN" })))).toContain("share=forbidden");
|
||||
expect(await attempt(() => shareBook(form({ bookId, email: "vän@example.com", role: "VIEWER" })))).toContain("share=ok");
|
||||
expect((await prisma.bookMember.findFirstOrThrow({ where: { userId: friend.id } })).role).toBe("VIEWER");
|
||||
});
|
||||
|
||||
it("en administratör kan inte röra en annan administratör, ägaren kan", async () => {
|
||||
const second = await makeUser("Admin två");
|
||||
await prisma.bookMember.create({ data: { bookId, userId: second.id, role: "ADMIN" } });
|
||||
as(admin);
|
||||
expect(await attempt(() => changeMemberRole(form({ bookId, userId: second.id, role: "VIEWER" })))).toContain("share=forbidden");
|
||||
expect(await attempt(() => removeBookMember(form({ bookId, userId: second.id })))).toContain("share=forbidden");
|
||||
expect(await prisma.bookMember.count({ where: { userId: second.id } })).toBe(1);
|
||||
as(owner);
|
||||
expect(await attempt(() => changeMemberRole(form({ bookId, userId: second.id, role: "VIEWER" })))).toContain("share=ok");
|
||||
expect(await attempt(() => removeBookMember(form({ bookId, userId: second.id })))).toContain("share=ok");
|
||||
expect(await prisma.bookMember.count({ where: { userId: second.id } })).toBe(0);
|
||||
});
|
||||
|
||||
it("redaktörer och läsare kan inte hantera delningen", async () => {
|
||||
for (const user of [editor, viewer]) {
|
||||
as(user);
|
||||
expect(await attempt(() => removeBookMember(form({ bookId, userId: viewer.id })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => changeMemberRole(form({ bookId, userId: viewer.id, role: "ADMIN" })))).toBe("NOT_FOUND");
|
||||
}
|
||||
expect(await prisma.bookMember.count()).toBe(3);
|
||||
});
|
||||
|
||||
it("en medlem kan lämna boken, och ägaren kan inte lämna sin egen", async () => {
|
||||
as(viewer);
|
||||
expect(await attempt(() => leaveSharedBook(form({ bookId })))).toBe("REDIRECT:/");
|
||||
expect(await bookAccess(bookId, viewer.id)).toBeNull();
|
||||
as(owner);
|
||||
await attempt(() => leaveSharedBook(form({ bookId })));
|
||||
expect((await bookAccess(bookId, owner.id))?.role).toBe("OWNER");
|
||||
});
|
||||
|
||||
it("listar ägare och medlemmar", async () => {
|
||||
const { owner: o, members } = await listMembers(bookId);
|
||||
expect(o.id).toBe(owner.id);
|
||||
expect(members.map((m) => [m.user.name, m.role])).toEqual([
|
||||
["Admin", "ADMIN"],
|
||||
["Redaktör", "EDITOR"],
|
||||
["Läsare", "VIEWER"],
|
||||
]);
|
||||
});
|
||||
|
||||
it("tar bort en delning utan att röra bokens innehåll", async () => {
|
||||
await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
as(owner);
|
||||
await attempt(() => removeBookMember(form({ bookId, userId: editor.id })));
|
||||
expect(await prisma.entity.count({ where: { bookId } })).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe("papperskorgen i en delad bok", () => {
|
||||
it("en redaktör flyttar en post dit under ägarens namn, och återställer den", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
as(editor);
|
||||
expect(await attempt(() => deleteEntity(form({ bookId, id: anna.id })))).toMatch(/^REDIRECT:/);
|
||||
const item = await prisma.trashItem.findFirstOrThrow();
|
||||
expect(item).toMatchObject({ ownerId: owner.id, bookId, kind: "entity" });
|
||||
|
||||
expect(await attempt(() => restoreTrashEntity(form({ bookId, id: item.id })))).toContain(`/entity/${anna.id}`);
|
||||
expect(await prisma.entity.count({ where: { id: anna.id } })).toBe(1);
|
||||
});
|
||||
|
||||
it("läsare kan inte ta bort eller återställa", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
as(viewer);
|
||||
expect(await attempt(() => deleteEntity(form({ bookId, id: anna.id })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.entity.count()).toBe(1);
|
||||
});
|
||||
|
||||
it("bara administratörer rensar papperskorgen", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
as(editor);
|
||||
await attempt(() => deleteEntity(form({ bookId, id: anna.id })));
|
||||
const item = await prisma.trashItem.findFirstOrThrow();
|
||||
|
||||
expect(await attempt(() => purgeTrash(form({ bookId, id: item.id })))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => emptyTrash(form({ bookId })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.trashItem.count()).toBe(1);
|
||||
|
||||
as(admin);
|
||||
expect(await attempt(() => purgeTrash(form({ bookId, id: item.id })))).toBe("ok");
|
||||
expect(await prisma.trashItem.count()).toBe(0);
|
||||
});
|
||||
|
||||
it("en annan boks papperskorg går inte att återställa eller rensa", async () => {
|
||||
const otherBook = await makeBook(stranger.id, "Annans bok");
|
||||
const secret = await makeEntity(otherBook.id, "CHARACTER", "Hemlig");
|
||||
const { trashEntity } = await import("@/lib/trash");
|
||||
await trashEntity(stranger.id, otherBook.id, secret.id);
|
||||
const item = await prisma.trashItem.findFirstOrThrow();
|
||||
|
||||
as(editor);
|
||||
// Rätt bok i formuläret men en annan boks post: ingenting återställs
|
||||
expect(await attempt(() => restoreTrashEntity(form({ bookId, id: item.id })))).toContain("restore=failed");
|
||||
expect(await attempt(() => purgeTrash(form({ bookId, id: item.id })))).toBe("NOT_FOUND");
|
||||
expect(await prisma.trashItem.count()).toBe(1);
|
||||
expect(await prisma.entity.count({ where: { id: secret.id } })).toBe(0);
|
||||
});
|
||||
|
||||
it("borttagna böcker går bara att återställa och rensa för ägaren", async () => {
|
||||
as(owner);
|
||||
await attempt(() => deleteBook(form({ bookId })));
|
||||
const item = await prisma.trashItem.findFirstOrThrow({ where: { kind: "book" } });
|
||||
as(admin);
|
||||
await attempt(() => purgeTrash(form({ id: item.id })));
|
||||
expect(await prisma.trashItem.count()).toBe(1);
|
||||
as(owner);
|
||||
await attempt(() => purgeTrash(form({ id: item.id })));
|
||||
expect(await prisma.trashItem.count()).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("lagring", () => {
|
||||
it("bilder som en redaktör laddar upp räknas på ägaren", async () => {
|
||||
const image = await saveImageBytes(await makeImage(60, 40, "png"));
|
||||
await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: image });
|
||||
const { userStorageBytes } = await import("@/lib/storage");
|
||||
expect(await userStorageBytes(owner.id)).toBeGreaterThan(0);
|
||||
expect(await userStorageBytes(editor.id)).toBe(0);
|
||||
expect(await filesIn(UPLOAD_DIR)).toContain(image);
|
||||
});
|
||||
});
|
||||
|
||||
describe("relationer och händelser skrivs av redaktörer", () => {
|
||||
it("sparar vem som gjorde ändringen", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const b = await makeEntity(bookId, "CHARACTER", "B");
|
||||
as(editor);
|
||||
await attempt(() => addEvent(form({ bookId, title: "Möte", date: "2001" })));
|
||||
expect((await prisma.storyEvent.findFirstOrThrow()).updatedById).toBe(editor.id);
|
||||
await attempt(() => addRelation(form({ bookId, fromId: a.id, toId: b.id, type: "Vänner" })));
|
||||
expect(await prisma.relation.count()).toBe(1);
|
||||
expect(await makeRelation(bookId, a.id, b.id)).toBeTruthy();
|
||||
expect(await makeEvent(bookId, "x", "2000")).toBeTruthy();
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,276 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { makeDocx, para, table } from "../helpers/docx";
|
||||
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 { previewWordImport, saveWordImport } from "@/actions/word-import";
|
||||
import { MAX_DOCX_BYTES } from "@/lib/word-docx";
|
||||
import { commitWordImport, previewWordFiles, type CommitItem } from "@/lib/word-import-db";
|
||||
|
||||
const character = (name: string, extra: string[][] = [], code = "KI-0001") =>
|
||||
makeDocx([table(["Karaktärs ID:", code], ["Förnamn:", name], ["Efternamn:", "Test"], ...extra), para("Övrigt:"), para("Anteckning.")]);
|
||||
|
||||
const bytes = (doc: Uint8Array) => ({ name: "doc.docx", bytes: doc });
|
||||
|
||||
async function attempt(run: () => Promise<unknown>): Promise<string> {
|
||||
try {
|
||||
await run();
|
||||
return "ok";
|
||||
} catch (error) {
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
if (message === "NOT_FOUND" || message.startsWith("REDIRECT:")) return message;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
describeDb("import från Word", () => {
|
||||
let ownerId: string;
|
||||
let bookId: string;
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetAll();
|
||||
ownerId = (await makeUser()).id;
|
||||
bookId = (await makeBook(ownerId)).id;
|
||||
login.userId = ownerId;
|
||||
});
|
||||
|
||||
describe("förhandsgranskning", () => {
|
||||
it("tolkar dokumentet mot bokens poster och markerar dubbletter", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna Test");
|
||||
const [doc] = await previewWordFiles(bookId, [bytes(character("Anna", [["Anställd hos:", "Okänd"]]))]);
|
||||
expect(doc.error).toBeNull();
|
||||
expect(doc.kind).toBe("CHARACTER");
|
||||
expect(doc.items[0]).toMatchObject({ name: "Anna Test", code: "KI-0001" });
|
||||
expect(doc.items[0].duplicates).toEqual([{ id: anna.id, name: "Anna Test", code: anna.code }]);
|
||||
expect(doc.items[0].links).toEqual([{ type: "Jobbar på", toDocument: false, entityId: null, text: "Okänd", note: "" }]);
|
||||
});
|
||||
|
||||
it("hittar poster i boken på ID och namn, men inte i en annan bok", async () => {
|
||||
const company = await makeEntity(bookId, "COMPANY", "Lunds skola");
|
||||
const otherBook = await makeBook(ownerId, "Annan bok");
|
||||
await makeEntity(otherBook.id, "COMPANY", "Främmande AB");
|
||||
const [doc] = await previewWordFiles(bookId, [
|
||||
bytes(character("Eva", [["Anställd hos:", `Lunds skola ${company.code}, Främmande AB`]])),
|
||||
]);
|
||||
expect(doc.items[0].links.map((l) => [l.text, l.entityId])).toEqual([
|
||||
[`Lunds skola ${company.code}`, company.id],
|
||||
["Främmande AB", null],
|
||||
]);
|
||||
});
|
||||
|
||||
it("använder bokens egen mall, med ändrade etiketter", async () => {
|
||||
await prisma.template.create({ data: { bookId, kind: "CHARACTER", fields: [{ key: "job", label: "Arbete", type: "text" }, { key: "notes", label: "Övrigt", type: "textarea" }] } });
|
||||
const [doc] = await previewWordFiles(bookId, [bytes(character("Eva", [["Arbete:", "Snickare"]]))]);
|
||||
expect(doc.items[0].data).toEqual({ job: "Snickare", notes: "Anteckning." });
|
||||
});
|
||||
|
||||
it("rapporterar filer som inte går att läsa, och läser de andra", async () => {
|
||||
const docs = await previewWordFiles(bookId, [
|
||||
{ name: "text.docx", bytes: new TextEncoder().encode("bara text") },
|
||||
bytes(character("Eva")),
|
||||
{ name: "stor.docx", bytes: new Uint8Array(MAX_DOCX_BYTES + 1) },
|
||||
]);
|
||||
expect(docs.map((d) => d.error)).toEqual(["not-docx", null, "too-large"]);
|
||||
expect(docs[1].items).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("låter användaren byta dokumenttyp", async () => {
|
||||
const [doc] = await previewWordFiles(bookId, [bytes(makeDocx([table(["Namn:", "Rex"], ["Ras:", "Boxer"])]))], ["PET"]);
|
||||
expect(doc).toMatchObject({ kind: "PET" });
|
||||
expect(doc.items[0]).toMatchObject({ name: "Rex", data: { breed: "Boxer" } });
|
||||
});
|
||||
|
||||
it("sparar ingenting", async () => {
|
||||
await previewWordFiles(bookId, [bytes(character("Eva"))]);
|
||||
expect(await prisma.entity.count()).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("sparande", () => {
|
||||
const item = (overrides: Partial<CommitItem> = {}): CommitItem => ({
|
||||
include: true,
|
||||
entityKind: "CHARACTER",
|
||||
name: "Eva Test",
|
||||
code: "KI-0007",
|
||||
data: { occupation: "Lärare" },
|
||||
links: [],
|
||||
unmatched: [],
|
||||
...overrides,
|
||||
});
|
||||
const commit = (items: CommitItem[], appendUnmatched = true) => commitWordImport(bookId, ownerId, items, { appendUnmatched });
|
||||
|
||||
it("skapar poster med dokumentets ID när det är ledigt, annars ett nytt", async () => {
|
||||
await makeEntity(bookId, "CHARACTER", "Redan"); // tar KI-0001
|
||||
const result = await commit([item(), item({ name: "Två", code: "KI-0001" }), item({ name: "Tre", code: null }), item({ name: "Fyra", code: "FEL-1" })]);
|
||||
expect(result).toMatchObject({ created: 4, skipped: 0 });
|
||||
const codes = Object.fromEntries((await prisma.entity.findMany({ where: { bookId } })).map((e) => [e.name, e.code]));
|
||||
expect(codes["Eva Test"]).toBe("KI-0007");
|
||||
expect(new Set(Object.values(codes)).size).toBe(5); // alla ID är unika
|
||||
expect(codes["Två"]).not.toBe("KI-0001");
|
||||
});
|
||||
|
||||
it("nya poster fortsätter numreringen efter importerade ID", async () => {
|
||||
await commit([item({ code: "KI-0020" })]);
|
||||
expect((await makeEntity(bookId, "CHARACTER", "Nästa")).code).toBe("KI-0021");
|
||||
});
|
||||
|
||||
it("hoppar över poster som användaren valt bort, och poster utan namn", async () => {
|
||||
const result = await commit([item({ include: false }), item({ name: " " }), item({ name: "Behåll", code: null })]);
|
||||
expect(result).toMatchObject({ created: 1, skipped: 2 });
|
||||
expect((await prisma.entity.findMany({ where: { bookId } })).map((e) => e.name)).toEqual(["Behåll"]);
|
||||
});
|
||||
|
||||
it("lägger det som inte tolkats i Övrigt, om användaren vill", async () => {
|
||||
await commit([item({ data: { notes: "Först." }, unmatched: [{ label: "Relationer", value: "Vän med Bo." }] })]);
|
||||
const [saved] = await prisma.entity.findMany({ where: { bookId } });
|
||||
expect((saved.data as { notes: string }).notes).toBe("Först.\n\nRelationer: Vän med Bo.");
|
||||
|
||||
const other = await makeBook(ownerId, "Utan tillägg");
|
||||
await commitWordImport(other.id, ownerId, [item({ unmatched: [{ label: "Relationer", value: "Vän med Bo." }] })], { appendUnmatched: false });
|
||||
expect((await prisma.entity.findFirstOrThrow({ where: { bookId: other.id } })).data).toEqual({ occupation: "Lärare" });
|
||||
});
|
||||
|
||||
it("skapar relationer åt rätt håll med anteckning", async () => {
|
||||
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
const company = await makeEntity(bookId, "COMPANY", "Firma");
|
||||
await commit([
|
||||
item({ name: "Eva", links: [{ type: "Jobbar på", toDocument: false, entityId: company.id, text: "Firma", note: "" }] }),
|
||||
item({
|
||||
entityKind: "COMPANY",
|
||||
name: "Kaffe AB",
|
||||
code: null,
|
||||
data: {},
|
||||
links: [
|
||||
{ type: "Jobbar på", toDocument: true, entityId: anna.id, text: "Anna", note: "Barista" },
|
||||
{ type: "Jobbar på", toDocument: true, entityId: null, text: "Okänd", note: "" },
|
||||
],
|
||||
}),
|
||||
]);
|
||||
const relations = await prisma.relation.findMany({ include: { from: true, to: true }, orderBy: { createdAt: "asc" } });
|
||||
expect(relations.map((r) => [r.from.name, r.type, r.to.name, r.description])).toEqual([
|
||||
["Eva", "Jobbar på", "Firma", null],
|
||||
["Anna", "Jobbar på", "Kaffe AB", "Barista"],
|
||||
]);
|
||||
expect(relations.every((r) => r.code && r.updatedById === ownerId)).toBe(true);
|
||||
});
|
||||
|
||||
it("kopplingar till poster i en annan bok och till sig själv ignoreras", async () => {
|
||||
const otherBook = await makeBook(ownerId, "Annan");
|
||||
const foreign = await makeEntity(otherBook.id, "CHARACTER", "Främling");
|
||||
await commit([item({ links: [{ type: "Vän till", toDocument: false, entityId: foreign.id, text: "Främling", note: "" }] })]);
|
||||
expect(await prisma.relation.count()).toBe(0);
|
||||
});
|
||||
|
||||
it("rensar värden som inte hör hemma i mallen, och kopplingsfält till fel typ eller bok", async () => {
|
||||
const otherBook = await makeBook(ownerId, "Annan");
|
||||
const foreign = await makeEntity(otherBook.id, "PREMISES", "Främmande lokal");
|
||||
const own = await makeEntity(bookId, "CHARACTER", "Anna");
|
||||
await commit([
|
||||
item({
|
||||
entityKind: "COMPANY",
|
||||
name: "Firma",
|
||||
code: null,
|
||||
data: { industry: "Kaffe", premises: foreign.id, sketch: own.id, hotelRooms: "tio", okänt: "x", satisfaction: "Fantastisk", hasSketches: true },
|
||||
}),
|
||||
]);
|
||||
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Firma" } })).data).toEqual({ industry: "Kaffe", hasSketches: true });
|
||||
});
|
||||
|
||||
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);
|
||||
});
|
||||
|
||||
it("en relation kräver två deltagare i boken och sätter släktband för partner", async () => {
|
||||
const a = await makeEntity(bookId, "CHARACTER", "A");
|
||||
const b = await makeEntity(bookId, "CHARACTER", "B");
|
||||
const c = await makeEntity(bookId, "CHARACTER", "C");
|
||||
const relation = (participants: string[], category: string): CommitItem =>
|
||||
item({ entityKind: "RELATION", name: category, code: null, data: { category, healthy: true }, participants });
|
||||
|
||||
expect(await commit([relation([a.id], "Partner")])).toMatchObject({ relations: 0, skipped: 1 });
|
||||
expect(await commit([relation([a.id, "finns-inte"], "Partner")])).toMatchObject({ relations: 0 });
|
||||
|
||||
await commit([relation([a.id, b.id, c.id], "Partner"), relation([a.id, c.id], "Vännergrupp")]);
|
||||
const relations = await prisma.relation.findMany({ include: { members: true }, orderBy: { createdAt: "asc" } });
|
||||
expect(relations.map((r) => [r.type, r.bond, r.members.length])).toEqual([
|
||||
["Partner till", "PARTNER", 1],
|
||||
["Vänner", null, 0],
|
||||
]);
|
||||
expect(relations[0]).toMatchObject({ fromId: a.id, toId: b.id, data: { category: "Partner", healthy: true } });
|
||||
});
|
||||
|
||||
it("sparar allt eller inget om något går fel", async () => {
|
||||
const result = commit([item({ name: "Bra", code: null }), item({ name: "x".repeat(10), code: null, data: { nickname: "y".repeat(30000) } })]);
|
||||
await expect(result).resolves.toMatchObject({ created: 2 });
|
||||
// För långa värden kortas i stället för att avvisas
|
||||
const long = await prisma.entity.findFirstOrThrow({ where: { bookId, name: "xxxxxxxxxx" } });
|
||||
expect(((long.data as { nickname: string }).nickname ?? "").length).toBeLessThanOrEqual(20000);
|
||||
});
|
||||
});
|
||||
|
||||
describe("åtgärderna", () => {
|
||||
const formWith = (docs: { name: string; bytes: Uint8Array }[], kinds: string[] = []) => {
|
||||
const data = new FormData();
|
||||
data.set("bookId", bookId);
|
||||
for (const d of docs) data.append("files", new File([d.bytes as BlobPart], d.name));
|
||||
for (const k of kinds) data.append("kinds", k);
|
||||
return data;
|
||||
};
|
||||
|
||||
it("förhandsgranskar och sparar för redaktörer", async () => {
|
||||
const response = await previewWordImport(formWith([bytes(character("Eva"))]));
|
||||
if (!("docs" in response)) throw new Error("Väntade förhandsgranskning");
|
||||
expect(response.docs[0].items[0].name).toBe("Eva Test");
|
||||
|
||||
const result = await saveWordImport({ bookId, appendUnmatched: true, items: [{ include: true, entityKind: "CHARACTER", name: "Eva Test", code: null, data: {}, links: [], unmatched: [] }] });
|
||||
expect(result.created).toBe(1);
|
||||
});
|
||||
|
||||
it("kräver minst en fil och högst 20", async () => {
|
||||
expect(await previewWordImport(formWith([]))).toEqual({ error: "no-files" });
|
||||
expect(await previewWordImport(formWith(Array.from({ length: 21 }, () => bytes(character("Eva")))))).toEqual({ error: "limit" });
|
||||
});
|
||||
|
||||
it("stora filer läses inte alls", async () => {
|
||||
const response = await previewWordImport(formWith([{ name: "stor.docx", bytes: new Uint8Array(MAX_DOCX_BYTES + 10) }]));
|
||||
if (!("docs" in response)) throw new Error("Väntade svar");
|
||||
expect(response.docs[0].error).toBe("too-large");
|
||||
});
|
||||
|
||||
it("läsare och obehöriga får inte importera", async () => {
|
||||
const viewer = await makeUser("Läsare");
|
||||
const stranger = await makeUser("Obehörig");
|
||||
await prisma.bookMember.create({ data: { bookId, userId: viewer.id, role: "VIEWER" } });
|
||||
const editor = await makeUser("Redaktör");
|
||||
await prisma.bookMember.create({ data: { bookId, userId: editor.id, role: "EDITOR" } });
|
||||
|
||||
for (const user of [viewer, stranger]) {
|
||||
login.userId = user.id;
|
||||
expect(await attempt(() => previewWordImport(formWith([bytes(character("Eva"))])))).toBe("NOT_FOUND");
|
||||
expect(await attempt(() => saveWordImport({ bookId, appendUnmatched: false, items: [] }))).toBe("NOT_FOUND");
|
||||
}
|
||||
expect(await prisma.entity.count()).toBe(0);
|
||||
|
||||
login.userId = editor.id;
|
||||
const result = await saveWordImport({ bookId, appendUnmatched: false, items: [{ include: true, entityKind: "CHARACTER", name: "Av redaktör", code: null, data: {}, links: [], unmatched: [] }] });
|
||||
expect(result.created).toBe(1);
|
||||
expect((await prisma.entity.findFirstOrThrow()).updatedById).toBe(editor.id);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,67 @@
|
||||
import type { DocBlock } from "@/lib/word-docx";
|
||||
import { isOptionList, labelsMatch } from "@/lib/word-labels";
|
||||
|
||||
const labelOf = (line: string): string | null => {
|
||||
const colon = line.indexOf(":");
|
||||
const text = colon >= 0 ? line.slice(0, colon) : line;
|
||||
return text.trim() ? text.trim() : null;
|
||||
};
|
||||
|
||||
const isHint = (line: string) => /^\([^)]*\)$/.test(line.trim());
|
||||
|
||||
/**
|
||||
* Fyller i en etikett i ett dokument på det sätt en person skulle göra i Word: värdet skrivs i cellen bredvid,
|
||||
* i raden under, eller på raden efter etiketten i en cell med flera etiketter. Ett val ("Ja: X Nej:") ersätter
|
||||
* alternativlistan som redan står där. Kastar om etiketten inte finns.
|
||||
*/
|
||||
export function fill(blocks: DocBlock[], label: string, value: string, occurrence = 1): DocBlock[] {
|
||||
const copy: DocBlock[] = JSON.parse(JSON.stringify(blocks));
|
||||
let seen = 0;
|
||||
|
||||
for (const [b, block] of copy.entries()) {
|
||||
if (block.type === "paragraph") {
|
||||
if (labelsMatch(labelOf(block.text) ?? "", label) && ++seen === occurrence) {
|
||||
copy.splice(b + 1, 0, { type: "paragraph", text: value });
|
||||
return copy;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
for (const [r, row] of block.rows.entries()) {
|
||||
for (const [c, cell] of row.entries()) {
|
||||
const lines = cell.split("\n");
|
||||
const at = lines.findIndex((line) => {
|
||||
const l = labelOf(line);
|
||||
return l !== null && line.includes(":") && labelsMatch(l, label);
|
||||
});
|
||||
// Etiketter utan kolon följda av en alternativlista ("Finns skisser | Ja: Nej:")
|
||||
const plain = at < 0 && lines.length === 1 && labelsMatch(cell.trim(), label);
|
||||
if (at < 0 && !plain) continue;
|
||||
if (++seen !== occurrence) continue;
|
||||
|
||||
if (lines.filter((l) => l.trim()).length > 1) {
|
||||
// Flera etiketter i en cell: värdet hamnar efter etiketten (och efter dess hjälptext)
|
||||
let insert = at + 1;
|
||||
while (isHint(lines[insert] ?? "")) insert++;
|
||||
if (isOptionList(value) && isOptionList(lines[insert] ?? "")) lines[insert] = value;
|
||||
else lines.splice(insert, 0, value);
|
||||
block.rows[r][c] = lines.join("\n");
|
||||
} else if (c + 1 < row.length && !row[c + 1].trim()) {
|
||||
row[c + 1] = value;
|
||||
} else if (c + 1 < row.length && isOptionList(row[c + 1]) && isOptionList(value)) {
|
||||
row[c + 1] = value;
|
||||
} else if (row.filter((x) => x.trim()).length === 1 && block.rows[r + 1]) {
|
||||
// Värdet står i raden under: en tom rad eller en alternativlista där ersätts, annars läggs en ny rad till
|
||||
const next = block.rows[r + 1];
|
||||
if (next.every((x) => !x.trim()) || (isOptionList(next[0] ?? "") && isOptionList(value))) block.rows[r + 1] = [value];
|
||||
else block.rows.splice(r + 1, 0, [value]);
|
||||
} else {
|
||||
row[c] = `${cell.trim()} ${value}`;
|
||||
}
|
||||
return copy;
|
||||
}
|
||||
}
|
||||
}
|
||||
throw new Error(`Etiketten "${label}" finns inte i dokumentet`);
|
||||
}
|
||||
|
||||
export const fillAll = (blocks: DocBlock[], values: [string, string][]): DocBlock[] => values.reduce((acc, [label, value]) => fill(acc, label, value), blocks);
|
||||
@@ -0,0 +1,28 @@
|
||||
import { strToU8, zipSync } from "fflate";
|
||||
import type { DocBlock } from "@/lib/word-docx";
|
||||
|
||||
const escape = (text: string) => text.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
||||
|
||||
const paragraphXml = (text: string) =>
|
||||
`<w:p><w:pPr><w:pStyle w:val="Normal"/></w:pPr>${text
|
||||
.split("\n")
|
||||
.map((line, i) => `${i > 0 ? "<w:r><w:br/></w:r>" : ""}<w:r><w:rPr><w:b/></w:rPr><w:t xml:space="preserve">${escape(line)}</w:t></w:r>`)
|
||||
.join("")}</w:p>`;
|
||||
|
||||
const cellXml = (text: string) => `<w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/></w:tcPr>${text.split("\n").map(paragraphXml).join("")}</w:tc>`;
|
||||
|
||||
/** Skriver block som ett Word-dokument på samma sätt som Word gör det, för att testa läsningen av riktiga filer. */
|
||||
export function makeDocx(blocks: DocBlock[]): Uint8Array {
|
||||
const body = blocks
|
||||
.map((b) =>
|
||||
b.type === "paragraph"
|
||||
? paragraphXml(b.text)
|
||||
: `<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/></w:tblPr><w:tblGrid/>${b.rows.map((r) => `<w:tr><w:trPr/>${r.map(cellXml).join("")}</w:tr>`).join("")}</w:tbl>`,
|
||||
)
|
||||
.join("");
|
||||
const xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>${body}<w:sectPr/></w:body></w:document>`;
|
||||
return zipSync({ "[Content_Types].xml": strToU8("<Types/>"), "word/document.xml": strToU8(xml) });
|
||||
}
|
||||
|
||||
export const para = (text: string): DocBlock => ({ type: "paragraph", text });
|
||||
export const table = (...rows: string[][]): DocBlock => ({ type: "table", rows });
|
||||
@@ -0,0 +1,61 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { canChangeMember, hasRole, manageableRoles, parseMemberRole, type BookRole } from "@/lib/access";
|
||||
|
||||
const ROLES: BookRole[] = ["VIEWER", "EDITOR", "ADMIN", "OWNER"];
|
||||
|
||||
describe("hasRole", () => {
|
||||
it("varje roll räcker för sin egen nivå och allt under", () => {
|
||||
for (const [i, role] of ROLES.entries()) {
|
||||
for (const [j, min] of ROLES.entries()) expect(hasRole(role, min)).toBe(i >= j);
|
||||
}
|
||||
});
|
||||
|
||||
it("läsare får inte skriva, redaktörer får inte administrera, bara ägaren äger", () => {
|
||||
expect(hasRole("VIEWER", "EDITOR")).toBe(false);
|
||||
expect(hasRole("EDITOR", "ADMIN")).toBe(false);
|
||||
expect(hasRole("ADMIN", "OWNER")).toBe(false);
|
||||
expect(hasRole("OWNER", "OWNER")).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseMemberRole", () => {
|
||||
it("godtar bara roller som kan delas ut", () => {
|
||||
expect(parseMemberRole("ADMIN")).toBe("ADMIN");
|
||||
expect(parseMemberRole("EDITOR")).toBe("EDITOR");
|
||||
expect(parseMemberRole("VIEWER")).toBe("VIEWER");
|
||||
expect(parseMemberRole("OWNER")).toBeNull();
|
||||
expect(parseMemberRole("admin")).toBeNull();
|
||||
expect(parseMemberRole(undefined)).toBeNull();
|
||||
expect(parseMemberRole(1)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("vem som får hantera vem", () => {
|
||||
it("ägaren hanterar alla, administratören bara redaktörer och läsare, andra ingen", () => {
|
||||
expect(manageableRoles("OWNER")).toEqual(["ADMIN", "EDITOR", "VIEWER"]);
|
||||
expect(manageableRoles("ADMIN")).toEqual(["EDITOR", "VIEWER"]);
|
||||
expect(manageableRoles("EDITOR")).toEqual([]);
|
||||
expect(manageableRoles("VIEWER")).toEqual([]);
|
||||
});
|
||||
|
||||
it("en administratör kan varken ändra, ta bort eller utse andra administratörer", () => {
|
||||
expect(canChangeMember("ADMIN", "ADMIN", "EDITOR")).toBe(false);
|
||||
expect(canChangeMember("ADMIN", "ADMIN", null)).toBe(false);
|
||||
expect(canChangeMember("ADMIN", "EDITOR", "ADMIN")).toBe(false);
|
||||
expect(canChangeMember("ADMIN", "EDITOR", "VIEWER")).toBe(true);
|
||||
expect(canChangeMember("ADMIN", "VIEWER", null)).toBe(true);
|
||||
});
|
||||
|
||||
it("ägaren kan göra allt", () => {
|
||||
expect(canChangeMember("OWNER", "ADMIN", "VIEWER")).toBe(true);
|
||||
expect(canChangeMember("OWNER", "EDITOR", "ADMIN")).toBe(true);
|
||||
expect(canChangeMember("OWNER", "VIEWER", null)).toBe(true);
|
||||
});
|
||||
|
||||
it("redaktörer och läsare kan inte hantera någon", () => {
|
||||
for (const actor of ["EDITOR", "VIEWER"] as const) {
|
||||
expect(canChangeMember(actor, "VIEWER", "EDITOR")).toBe(false);
|
||||
expect(canChangeMember(actor, "VIEWER", null)).toBe(false);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,93 @@
|
||||
import { strToU8, zipSync } from "fflate";
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { DocxError, MAX_DOCX_BYTES, decodeXml, parseDocumentXml, readDocx } from "@/lib/word-docx";
|
||||
import { makeDocx, para, table } from "../helpers/docx";
|
||||
|
||||
const wrap = (body: string) => `<w:document xmlns:w="x"><w:body>${body}</w:body></w:document>`;
|
||||
const p = (text: string) => `<w:p><w:r><w:t>${text}</w:t></w:r></w:p>`;
|
||||
|
||||
describe("parseDocumentXml", () => {
|
||||
it("läser stycken i ordning och hoppar över tomma", () => {
|
||||
expect(parseDocumentXml(wrap(`${p("Första")}<w:p/><w:p><w:pPr/></w:p>${p("Andra")}`))).toEqual([
|
||||
{ type: "paragraph", text: "Första" },
|
||||
{ type: "paragraph", text: "Andra" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("sätter ihop text som Word delat upp i flera delar", () => {
|
||||
const xml = wrap(`<w:p><w:r><w:t>Hej </w:t></w:r><w:r><w:t xml:space="preserve">världen</w:t></w:r></w:p>`);
|
||||
expect(parseDocumentXml(xml)).toEqual([{ type: "paragraph", text: "Hej världen" }]);
|
||||
});
|
||||
|
||||
it("läser tabeller med rader och celler, och behåller tomma celler", () => {
|
||||
const cell = (text: string) => `<w:tc><w:tcPr/>${text ? p(text) : "<w:p/>"}</w:tc>`;
|
||||
const xml = wrap(`<w:tbl><w:tblPr/><w:tr>${cell("Namn:")}${cell("")}</w:tr><w:tr>${cell("Ålder:")}${cell("30")}</w:tr></w:tbl>${p("Efter")}`);
|
||||
expect(parseDocumentXml(xml)).toEqual([
|
||||
{ type: "table", rows: [["Namn:", ""], ["Ålder:", "30"]] },
|
||||
{ type: "paragraph", text: "Efter" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("flera stycken i en cell slås ihop med radbrytning", () => {
|
||||
const xml = wrap(`<w:tbl><w:tr><w:tc>${p("Rad ett")}${p("Rad två")}</w:tc></w:tr></w:tbl>`);
|
||||
expect(parseDocumentXml(xml)).toEqual([{ type: "table", rows: [["Rad ett\nRad två"]] }]);
|
||||
});
|
||||
|
||||
it("en tabell i en cell blir text i den yttre cellen", () => {
|
||||
const inner = `<w:tbl><w:tr><w:tc>${p("Inre")}</w:tc></w:tr></w:tbl>`;
|
||||
const xml = wrap(`<w:tbl><w:tr><w:tc>${p("Yttre")}${inner}</w:tc><w:tc>${p("Bredvid")}</w:tc></w:tr></w:tbl>`);
|
||||
expect(parseDocumentXml(xml)).toEqual([{ type: "table", rows: [["Yttre\nInre", "Bredvid"]] }]);
|
||||
});
|
||||
|
||||
it("tolkar radbrytning, tabb och symboler", () => {
|
||||
const xml = wrap(`<w:p><w:r><w:t>A</w:t><w:br/><w:t>B</w:t><w:tab/><w:t>C</w:t><w:sym w:font="Wingdings" w:char="F0FE"/></w:r></w:p>`);
|
||||
expect(parseDocumentXml(xml)).toEqual([{ type: "paragraph", text: "A\nB\tC✓" }]);
|
||||
});
|
||||
|
||||
it("avkodar tecken i texten", () => {
|
||||
expect(parseDocumentXml(wrap(p("Tom & Jerry <3 åä")))).toEqual([{ type: "paragraph", text: "Tom & Jerry <3 åä" }]);
|
||||
});
|
||||
|
||||
it("klarar tomt och trasigt innehåll utan att kasta", () => {
|
||||
expect(parseDocumentXml("")).toEqual([]);
|
||||
expect(parseDocumentXml(wrap("<w:tbl><w:tr><w:tc>"))).toEqual([]);
|
||||
expect(() => parseDocumentXml("</w:tbl></w:tbl></w:p><w:t>")).not.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe("decodeXml", () => {
|
||||
it("avkodar de vanliga tecknen och lämnar okända som de är", () => {
|
||||
expect(decodeXml("&<>"'")).toBe(`&<>"'`);
|
||||
expect(decodeXml("&okänd;")).toBe("&okänd;");
|
||||
expect(decodeXml("��")).toBe("");
|
||||
});
|
||||
});
|
||||
|
||||
describe("readDocx", () => {
|
||||
it("läser en docx-fil som skrivits som Word gör", () => {
|
||||
const blocks = [para("Rubrik:"), table(["Förnamn:", "Åsa"], ["Smeknamn:", "Rad ett\nRad två"]), para("Text med <tecken> & annat")];
|
||||
expect(readDocx(makeDocx(blocks))).toEqual(blocks);
|
||||
});
|
||||
|
||||
it("avvisar filer som inte är Word-dokument", () => {
|
||||
const code = (bytes: Uint8Array) => {
|
||||
try {
|
||||
readDocx(bytes);
|
||||
return null;
|
||||
} catch (error) {
|
||||
return error instanceof DocxError ? error.code : "annat";
|
||||
}
|
||||
};
|
||||
expect(code(new Uint8Array())).toBe("not-docx");
|
||||
expect(code(strToU8("det här är text"))).toBe("not-docx");
|
||||
expect(code(zipSync({ "annat.txt": strToU8("x") }))).toBe("not-docx");
|
||||
expect(code(new Uint8Array([0x50, 0x4b, 1, 2, 3, 4, 5, 6]))).toBe("invalid");
|
||||
expect(code(new Uint8Array(MAX_DOCX_BYTES + 1))).toBe("too-large");
|
||||
});
|
||||
|
||||
it("packar inte upp något annat än huvuddokumentet", () => {
|
||||
// Ett jättestort dokument stoppas av gränsen för uppackad storlek
|
||||
const huge = zipSync({ "word/document.xml": strToU8("x".repeat(31 * 1024 * 1024)) });
|
||||
expect(() => readDocx(huge)).toThrow(DocxError);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,212 @@
|
||||
import { existsSync, readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { readDocx, type DocBlock } from "@/lib/word-docx";
|
||||
import { analyzeDocument, type KnownEntity } from "@/lib/word-import";
|
||||
import { fillAll } from "../helpers/docx-fill";
|
||||
|
||||
// Ifyllda versioner av de riktiga Word-mallarna i Mall/ och Register/. Mallen läses ur filen och fylls i på det sätt
|
||||
// en person skulle göra i Word, så att tolkningen prövas mot mallarnas verkliga uppbyggnad.
|
||||
|
||||
const root = new URL("../../", import.meta.url);
|
||||
const available = existsSync(new URL("Mall/Karaktärermall.docx", root));
|
||||
const load = (path: string): DocBlock[] => readDocx(new Uint8Array(readFileSync(new URL(path, root))));
|
||||
|
||||
const known: KnownEntity[] = [
|
||||
{ id: "k1", name: "Anna Lind", code: "KI-0001", kind: "CHARACTER" },
|
||||
{ id: "k2", name: "Bo Ek", code: "KI-0002", kind: "CHARACTER" },
|
||||
{ id: "c1", name: "Lunds skola", code: "FI-0002", kind: "COMPANY" },
|
||||
{ id: "l1", name: "Café Lund", code: "LI-0001", kind: "PREMISES" },
|
||||
];
|
||||
|
||||
const analyze = (blocks: DocBlock[], file: string) => {
|
||||
const doc = analyzeDocument(blocks, file, known);
|
||||
expect(doc.items.length).toBeGreaterThan(0);
|
||||
return { doc, item: doc.items[0] };
|
||||
};
|
||||
|
||||
describe.skipIf(!available)("ifyllda riktiga mallar", () => {
|
||||
it("karaktärsmallen", () => {
|
||||
const blocks = fillAll(load("Mall/Karaktärermall.docx"), [
|
||||
["Karaktärs ID", "KI-0042"],
|
||||
["Förnamn", "Åsa"],
|
||||
["Efternamn", "Berg"],
|
||||
["Smeknamn", "Åsa-Lena"],
|
||||
["Yrke", "Lärare"],
|
||||
["Anställd hos", "Lunds skola FI-0002"],
|
||||
["Utseende", "Lång och smal."],
|
||||
["Personlighet", "Varm och nyfiken."],
|
||||
]);
|
||||
const { doc, item } = analyze(blocks, "asa.docx");
|
||||
expect(doc.kind).toBe("CHARACTER");
|
||||
expect(item).toMatchObject({ name: "Åsa Berg", code: "KI-0042" });
|
||||
expect(item.data).toMatchObject({ nickname: "Åsa-Lena", occupation: "Lärare", appearance: "Lång och smal.", personality: "Varm och nyfiken." });
|
||||
expect(item.links).toEqual([{ type: "Jobbar på", toDocument: false, entityId: "c1", text: "Lunds skola FI-0002", note: "" }]);
|
||||
expect(item.unmatched).toEqual([]);
|
||||
});
|
||||
|
||||
it("korta karaktärsmallen, ifylld i samma cell och i cellen bredvid", () => {
|
||||
const original = load("Mall/Karaktärermall-kort.docx");
|
||||
const inline = fillAll(original, [
|
||||
["Förnamn", "Åsa"],
|
||||
["Efternamn", "Berg"],
|
||||
["Yrke", "Lärare"],
|
||||
["Utseende", "Lång."],
|
||||
]);
|
||||
expect(analyze(inline, "kort.docx").item).toMatchObject({ name: "Åsa Berg", data: { occupation: "Lärare", appearance: "Lång." } });
|
||||
|
||||
// Värdena i cellen bredvid, på raden som motsvarar etiketten
|
||||
const beside: DocBlock[] = JSON.parse(JSON.stringify(original));
|
||||
const first = beside[0];
|
||||
if (first.type !== "table") throw new Error("Väntade en tabell");
|
||||
const lines = first.rows[0][0].split("\n");
|
||||
const values = lines.map(() => "");
|
||||
values[lines.indexOf("Förnamn:")] = "Åsa";
|
||||
values[lines.indexOf("Efternamn:")] = "Berg";
|
||||
values[lines.indexOf("Yrke:")] = "Lärare";
|
||||
first.rows[0][1] = values.join("\n");
|
||||
expect(analyze(beside, "kort.docx").item).toMatchObject({ name: "Åsa Berg", data: { occupation: "Lärare" } });
|
||||
});
|
||||
|
||||
it("bostadsmallen", () => {
|
||||
const blocks = fillAll(load("Mall/Bostadsmall.docx"), [
|
||||
["Bostads ID", "BI-0003"],
|
||||
["Bostads typ", "Hyresrätt: X Bostadsrätt: Villa:"],
|
||||
["Adress", "Storgatan 1"],
|
||||
["Antal Rum", "3"],
|
||||
["Boarea", "75"],
|
||||
["Namn", "Anna Lind KI-0001"],
|
||||
["Byggnadsutseende", "Rött trähus."],
|
||||
["Balkong", "Ja: X Nej:"],
|
||||
["Hyra lägenhet", "5000 kr"],
|
||||
]);
|
||||
const { doc, item } = analyze(blocks, "bostad.docx");
|
||||
expect(doc.kind).toBe("HOME");
|
||||
expect(item).toMatchObject({ name: "Storgatan 1", code: "BI-0003" });
|
||||
expect(item.data).toMatchObject({ homeType: "Hyresrätt", address: "Storgatan 1", rooms: 3, livingArea: 75, buildingLook: "Rött trähus.", balcony: true, rentFee: "5000 kr" });
|
||||
expect(item.links.map((l) => [l.type, l.entityId])).toEqual([["Bor på", "k1"]]);
|
||||
});
|
||||
|
||||
it("företagsmallen", () => {
|
||||
const blocks = fillAll(load("Mall/Företagsmall.docx"), [
|
||||
["Företagets namn", "Lunds Kaffe"],
|
||||
["Företags ID", "FI-0003"],
|
||||
["Bransch", "Kaffe"],
|
||||
["Lokal ID", "LI-0001"],
|
||||
["Finns skisser", "Ja: X Nej:"],
|
||||
["Namn", "Anna Lind\tBarista\tKI-0001"],
|
||||
["Alkoholservering", "Ja: X Nej:"],
|
||||
["Generell nöjdhet bland de anställda", "Bra: X Dåligt:"],
|
||||
["Beskriv arbetsmiljön", "Trevlig."],
|
||||
]);
|
||||
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.links).toEqual([{ type: "Jobbar på", toDocument: true, entityId: "k1", text: "Anna Lind KI-0001", note: "Barista" }]);
|
||||
});
|
||||
|
||||
it("scenariomallen, där frågorna står som egna rader", () => {
|
||||
const blocks = fillAll(load("Mall/Scenariomall.docx"), [
|
||||
["Scenario ID", "SNI-0003"],
|
||||
["Kopplat ID", "KI-0001"],
|
||||
["Scenario typ", "Bråk: X Olycka: Dödsfall: Otrohet: Brott: Övrigt:"],
|
||||
["Namn", "Anna Lind KI-0001"],
|
||||
["Beskriv scenariot", "De bråkade om pengar."],
|
||||
["Hur påverkas karaktärerna under scenariot", "Mycket spänt."],
|
||||
]);
|
||||
const { doc, item } = analyze(blocks, "scenario.docx");
|
||||
expect(doc.kind).toBe("SCENARIO");
|
||||
expect(item.code).toBe("SNI-0003");
|
||||
expect(item.data).toMatchObject({ linkedEntity: "k1", scenarioType: "Bråk", description: "De bråkade om pengar.", impactDuring: "Mycket spänt." });
|
||||
expect(item.links.map((l) => [l.type, l.entityId])).toEqual([["Involverad i", "k1"]]);
|
||||
});
|
||||
|
||||
it("relationsmallen", () => {
|
||||
const blocks = fillAll(load("Mall/Relationsmall.docx"), [
|
||||
["Relations ID", "REI-0009"],
|
||||
["Relations typ", "Vännergrupper: Partner: X Familj: Kollegor:"],
|
||||
["Är relationen Hälsosam", "Ja: X Nej:"],
|
||||
["Namn", "Anna Lind KI-0001"],
|
||||
["Namn", "Bo Ek KI-0002"],
|
||||
["Hur fungerar relationen", "De bråkar sällan."],
|
||||
]);
|
||||
const { doc, item } = analyze(blocks, "relation.docx");
|
||||
expect(doc.kind).toBe("RELATION");
|
||||
expect(doc.relation?.participants.map((p) => p.entityId).sort()).toEqual(["k1", "k2"]);
|
||||
expect(item.data).toMatchObject({ category: "Partner", healthy: true, howItWorks: "De bråkar sällan." });
|
||||
});
|
||||
|
||||
it("utbildningsmallen", () => {
|
||||
const blocks = fillAll(load("Mall/Utbildningsmall.docx"), [
|
||||
["Utbildnings ID", "UI-0002"],
|
||||
["Skolans namn", "Lunds gymnasium"],
|
||||
["Utbildningstyp", "Förskola: lågstadium: Mellanstadium: Högstadium:\nGymnasium: X Högskola: Yrkeshögskola: Komvux:"],
|
||||
["Linje", "Natur"],
|
||||
["Klass", "3A"],
|
||||
]);
|
||||
const { doc, item } = analyze(blocks, "skola.docx");
|
||||
expect(doc.kind).toBe("EDUCATION");
|
||||
expect(item).toMatchObject({ name: "Lunds gymnasium", code: "UI-0002" });
|
||||
expect(item.data).toMatchObject({ educationType: "Gymnasium", program: "Natur", class: "3A" });
|
||||
});
|
||||
|
||||
it("lokalmallen", () => {
|
||||
const blocks = fillAll(load("Mall/Lokalmall.docx"), [
|
||||
["Lokal ID", "LI-0005"],
|
||||
["Adress", "Torget 3"],
|
||||
["Placerings ID", "PI-0001"],
|
||||
["Ägande", "Hyr: X Äga:"],
|
||||
["Hiss", "Ja: X Nej:"],
|
||||
["Beskriv insidan av lokalen", "Ljust."],
|
||||
]);
|
||||
const { doc, item } = analyze(blocks, "lokal.docx");
|
||||
expect(doc.kind).toBe("PREMISES");
|
||||
expect(item).toMatchObject({ name: "Torget 3", code: "LI-0005" });
|
||||
expect(item.data).toMatchObject({ address: "Torget 3", placementId: "PI-0001", tenure: "Hyr", elevator: true, interior: "Ljust." });
|
||||
});
|
||||
|
||||
it("djurmallen", () => {
|
||||
const blocks = fillAll(load("Mall/Djurmall.docx"), [
|
||||
["Djur ID", "DI-0004"],
|
||||
["Namn", "Findus"],
|
||||
["Ägare", "Anna Lind"],
|
||||
["Djur kategori", "Husdjur: X Gårdsdjur: Annat:"],
|
||||
["Ålder", "5"],
|
||||
["Djurets personlighet", "Nyfiken."],
|
||||
]);
|
||||
const { doc, item } = analyze(blocks, "djur.docx");
|
||||
expect(doc.kind).toBe("PET");
|
||||
expect(item).toMatchObject({ name: "Findus", code: "DI-0004" });
|
||||
expect(item.data).toMatchObject({ category: "Husdjur", age: 5, personality: "Nyfiken." });
|
||||
expect(item.links.map((l) => [l.type, l.entityId])).toEqual([["Husdjur till", "k1"]]);
|
||||
});
|
||||
|
||||
it("fordonsregistret med flera rader", () => {
|
||||
const blocks = load("Register/Fordonsregister.docx");
|
||||
const first = blocks[0];
|
||||
if (first.type !== "table") throw new Error("Väntade en tabell");
|
||||
first.rows[1] = ["FD-0001", "Volvo V70", "Diesel", "Anna Lind KI-0001", ""];
|
||||
first.rows[2] = ["FD-0002", "Tesla Model 3", "El", "", ""];
|
||||
const doc = analyzeDocument(blocks, "fordon.docx", known);
|
||||
expect(doc.kind).toBe("VEHICLE");
|
||||
expect(doc.items.map((i) => [i.name, i.code, i.data.fuel, i.data.owner])).toEqual([
|
||||
["Volvo V70", "FD-0001", "Diesel", "k1"],
|
||||
["Tesla Model 3", "FD-0002", "El", undefined],
|
||||
]);
|
||||
});
|
||||
|
||||
it("appregistret med en post per namn", () => {
|
||||
const blocks = load("Register/Appregister.docx");
|
||||
const first = blocks.find((b) => b.type === "table");
|
||||
if (first?.type !== "table") throw new Error("Väntade en tabell");
|
||||
first.rows[0] = ["Namn: Instagram"];
|
||||
first.rows[1] = ["Beskrivning: Bilder"];
|
||||
first.rows[2] = ["Namn: Bankapp"];
|
||||
const doc = analyzeDocument(blocks, "appar.docx", known);
|
||||
expect(doc.kind).toBe("APP");
|
||||
expect(doc.items.map((i) => [i.name, i.data.description])).toEqual([
|
||||
["Instagram", "Bilder"],
|
||||
["Bankapp", undefined],
|
||||
]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,687 @@
|
||||
import { existsSync, readFileSync } from "node:fs";
|
||||
import { describe, expect, it } from "vitest";
|
||||
import type { DocBlock } from "@/lib/word-docx";
|
||||
import { readDocx } from "@/lib/word-docx";
|
||||
import { analyzeDocument, detectKind, extract, findEntity, multiLabels, parseCellList, parseInlineBlock, splitLabel, usableCode, type ImportKind, type KnownEntity, type ParsedDocument } from "@/lib/word-import";
|
||||
import { cleanData } from "@/lib/word-import-db";
|
||||
import { getDefaultTemplate } from "@/lib/templates";
|
||||
import { makeDocx, para, table } from "../helpers/docx";
|
||||
|
||||
const known: KnownEntity[] = [
|
||||
{ id: "k1", name: "Anna Lind", code: "KI-0001", kind: "CHARACTER" },
|
||||
{ id: "k2", name: "Bo Ek", code: "KI-0002", kind: "CHARACTER" },
|
||||
{ id: "c1", name: "Lunds skola", code: "FI-0002", kind: "COMPANY" },
|
||||
{ id: "l1", name: "Café Lund", code: "LI-0001", kind: "PREMISES" },
|
||||
{ id: "r1", name: "Fågelboken", code: "RD-0002", kind: "REFERENCE" },
|
||||
];
|
||||
|
||||
const analyze = (blocks: DocBlock[], file = "mall.docx", kind?: ImportKind): ParsedDocument => analyzeDocument(blocks, file, known, { kind });
|
||||
const only = (doc: ParsedDocument) => {
|
||||
expect(doc.items).toHaveLength(1);
|
||||
return doc.items[0];
|
||||
};
|
||||
|
||||
describe("splitLabel", () => {
|
||||
it("delar etikett och värde, och ser hjälptexten som en del av resten", () => {
|
||||
expect(splitLabel("Förnamn: Anna")).toEqual({ label: "Förnamn", rest: " Anna" });
|
||||
expect(splitLabel("Anställd hos:(inkludera ID)")).toEqual({ label: "Anställd hos", rest: "(inkludera ID)" });
|
||||
});
|
||||
|
||||
it("avvisar det som inte är en etikett", () => {
|
||||
expect(splitLabel("Ingen etikett här")).toBeNull();
|
||||
expect(splitLabel("06:00")).toBeNull();
|
||||
expect(splitLabel(":kolon först")).toBeNull();
|
||||
expect(splitLabel("http://example.com")).toBeNull();
|
||||
expect(splitLabel(`${"x".repeat(100)}: för lång`)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("multiLabels", () => {
|
||||
it("läser en etikett per rad och slår ihop etiketter som delats över två rader", () => {
|
||||
const entries = multiLabels("Karaktärs ID:\n\nFörnamn:\nEfternamn:\nÅlder\nfödelsedatum:\nAnställd hos:\n(inkludera ID)");
|
||||
expect(entries.map((e) => e.label)).toEqual(["Karaktärs ID", "Förnamn", "Efternamn", "Ålder födelsedatum", "Anställd hos"]);
|
||||
expect(entries[3].lines).toEqual([4, 5]);
|
||||
});
|
||||
|
||||
it("tar värden som står direkt efter etiketten", () => {
|
||||
expect(multiLabels("Förnamn: Anna\nEfternamn: Lind").map((e) => e.inline)).toEqual(["Anna", "Lind"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("celler med flera rader", () => {
|
||||
it("ett block med etiketter och värden om vartannat", () => {
|
||||
const block = parseInlineBlock(
|
||||
"Arbetsplats för karaktärer:\nJa: X Nej:\n\nAlkoholservering:\n(om restaurang/hotell)\nJa: Nej:\n\nAntal rum:\n(Om hotell)\n12\n\nHyra:\n5000 kr\nmånadsvis",
|
||||
() => false,
|
||||
);
|
||||
expect(block.labels).toEqual(["Arbetsplats för karaktärer", "Alkoholservering", "Antal rum", "Hyra"]);
|
||||
expect(block.pairs).toEqual([
|
||||
{ label: "Arbetsplats för karaktärer", value: "Ja: X Nej:" },
|
||||
{ label: "Alkoholservering", value: "Ja: Nej:" },
|
||||
{ label: "Antal rum", value: "12" },
|
||||
{ label: "Hyra", value: "5000 kr\nmånadsvis" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("ett alternativ på en egen rad hör till föregående lista, men en känd etikett gör det inte", () => {
|
||||
const known = (label: string) => label === "Eldstad";
|
||||
const block = parseInlineBlock("Inglasad:\nJa: delvis:\nNej: X\nEldstad:\nJa: X Nej:", known);
|
||||
expect(block.pairs).toEqual([
|
||||
{ label: "Inglasad", value: "Ja: delvis:\nNej: X" },
|
||||
{ label: "Eldstad", value: "Ja: X Nej:" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("en lista i en cell: rubriker på egna rader och en deltagare per rad", () => {
|
||||
expect(parseCellList("Namn:\nRoll:\nKaraktärsnummer:\n\nAnna Lind\tBarista\tKI-0001\nBo Ek KI-0002\n\n")).toEqual([
|
||||
{ name: "Anna Lind", code: "KI-0001", role: "Barista", subject: "" },
|
||||
{ name: "Bo Ek", code: "KI-0002", role: "", subject: "" },
|
||||
]);
|
||||
expect(parseCellList("Namn:\nKaraktärs ID:\nNamn:\nKaraktärs ID:")).toEqual([]);
|
||||
expect(parseCellList("Förnamn:\nEfternamn:")).toBeNull();
|
||||
});
|
||||
|
||||
it("tabellrader med en enda cell tolkas som lista eller block", () => {
|
||||
const { pairs, lists } = extract(
|
||||
[table(["Anställda:"], ["Namn:\nRoll:\nKaraktärsnummer:\nAnna Lind\tBarista\tKI-0001"], ["Annan information:"], ["Bransch:\nKaffe\nSkyltat utomhus:\nJa: X Nej:"])],
|
||||
() => false,
|
||||
);
|
||||
expect(lists).toEqual([{ heading: "Anställda", entries: [{ name: "Anna Lind", code: "KI-0001", role: "Barista", subject: "" }] }]);
|
||||
expect(pairs).toEqual([
|
||||
{ label: "Bransch", value: "Kaffe" },
|
||||
{ label: "Skyltat utomhus", value: "Ja: X Nej:" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("val utan markering är tomma värden", () => {
|
||||
expect(extract([table(["Bostads typ:", "Hyresrätt: Bostadsrätt: Villa:"], ["Balkong:", "Ja: Nej:"])], () => false).pairs).toEqual([]);
|
||||
});
|
||||
|
||||
it("en fråga utan kolon som är en känd etikett är inte ett värde", () => {
|
||||
const known = (label: string) => label.startsWith("Hur påverkas");
|
||||
const { pairs } = extract([table(["Beskriv scenariot:"], [""], ["Hur påverkas karaktärerna under scenariot?"], ["Mycket."])], known);
|
||||
expect(pairs).toEqual([{ label: "Hur påverkas karaktärerna under scenariot?", value: "Mycket." }]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("extract", () => {
|
||||
it("läser etikett/värde-par åt båda hållen, med värdet i samma eller nästa cell", () => {
|
||||
const { pairs } = extract([table(["Förnamn:", "Anna"], ["Efternamn: Lind"], ["Smeknamn:", ""], ["Yrke:", "Lärare", "Kön:", "Kvinna"])], () => false);
|
||||
expect(pairs).toEqual([
|
||||
{ label: "Förnamn", value: "Anna" },
|
||||
{ label: "Efternamn", value: "Lind" },
|
||||
{ label: "Yrke", value: "Lärare" },
|
||||
{ label: "Kön", value: "Kvinna" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("samlar alla etiketter, även utan värde", () => {
|
||||
expect(extract([table(["Förnamn:", ""], ["Efternamn:", ""]), para("Utseende:")], () => false).labels).toEqual(["Förnamn", "Efternamn", "Utseende"]);
|
||||
});
|
||||
|
||||
it("hjälptexter i parentes är inte värden", () => {
|
||||
const { pairs } = extract([table(["Anställd hos:(inkludera ID)", ""]), para("Hur fungerar relationen: (Finns det något känsligt?)"), para("Bråkar sällan.")], () => false);
|
||||
expect(pairs).toEqual([{ label: "Hur fungerar relationen", value: "Bråkar sällan." }]);
|
||||
});
|
||||
|
||||
it("stycken under en rubrik blir värdet, tills nästa rubrik", () => {
|
||||
const { pairs } = extract([para("Utseende:"), para("Lång."), para("Mörkt hår."), para("Personlighet:"), para("Varm."), para("Intressen:")], () => false);
|
||||
expect(pairs).toEqual([
|
||||
{ label: "Utseende", value: "Lång.\nMörkt hår." },
|
||||
{ label: "Personlighet", value: "Varm." },
|
||||
]);
|
||||
});
|
||||
|
||||
it("en rad med kolon mitt i löpande text är inte en ny rubrik", () => {
|
||||
const { pairs } = extract([para("Bakgrund:"), para("Hon växte upp i Lund. Tid: sommaren 1990."), para("Fler detaljer.")], () => false);
|
||||
expect(pairs).toEqual([{ label: "Bakgrund", value: "Hon växte upp i Lund. Tid: sommaren 1990.\nFler detaljer." }]);
|
||||
});
|
||||
|
||||
it("en känd etikett med värde i samma stycke läses som en etikett", () => {
|
||||
const { pairs } = extract([para("Smeknamn: Annie"), para("Okänd: något")], (label) => label === "Smeknamn");
|
||||
expect(pairs).toEqual([{ label: "Smeknamn", value: "Annie" }]);
|
||||
});
|
||||
|
||||
it("val i rutor behålls som de skrevs", () => {
|
||||
const { pairs } = extract([table(["Finns skisser", "Ja: X Nej:"], ["Balkong:", "Ja: Nej: X"])], () => false);
|
||||
expect(pairs).toEqual([
|
||||
{ label: "Finns skisser", value: "Ja: X Nej:" },
|
||||
{ label: "Balkong", value: "Ja: Nej: X" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("en etikett på en rad och alternativen på nästa rad hör ihop", () => {
|
||||
const { pairs } = extract([table(["Scenario typ:"], ["Bråk: X Olycka: Dödsfall:"])], () => false);
|
||||
expect(pairs).toEqual([{ label: "Scenario typ", value: "Bråk: X Olycka: Dödsfall:" }]);
|
||||
});
|
||||
|
||||
it("deltagarlistor läses med rubrik, namn, ID och roll, och tomma rader hoppas över", () => {
|
||||
const { lists, pairs } = extract(
|
||||
[table(["Anställda:"], ["Namn:", "Roll:", "Karaktärsnummer:"], ["Anna Lind", "Barista", "KI-0001"], ["", "", ""], ["Bo Ek", "", "KI-0002"], ["", "", ""], ["Annan information:"], ["Alkoholservering:", "Ja: X Nej:"])],
|
||||
() => false,
|
||||
);
|
||||
expect(lists).toEqual([
|
||||
{
|
||||
heading: "Anställda",
|
||||
entries: [
|
||||
{ name: "Anna Lind", code: "KI-0001", role: "Barista", subject: "" },
|
||||
{ name: "Bo Ek", code: "KI-0002", role: "", subject: "" },
|
||||
],
|
||||
},
|
||||
]);
|
||||
expect(pairs).toEqual([{ label: "Alkoholservering", value: "Ja: X Nej:" }]);
|
||||
});
|
||||
|
||||
it("en lista utan ifyllda rader ger ingen lista", () => {
|
||||
expect(extract([table(["Boende:"], ["Namn:", "Karaktärs ID:"], ["", ""], ["", ""])], () => false).lists).toEqual([]);
|
||||
});
|
||||
|
||||
it("register med rubrikrad och flera rader", () => {
|
||||
const { registers } = extract([table(["Referens ID:", "Beskrivning:"], ["RD-0001", "En bok"], ["", ""], ["RD-0002", "En film"])], () => false);
|
||||
expect(registers).toEqual([{ header: ["Referens ID", "Beskrivning"], rows: [["RD-0001", "En bok"], ["RD-0002", "En film"]] }]);
|
||||
});
|
||||
|
||||
it("en tabell med tomma celler i första raden är inget register", () => {
|
||||
const { registers, pairs } = extract([table(["Djur ID:", "", "Namn:", ""], ["Smeknamn:", "", "Ägare:", ""], ["Ras:", ""])], () => false);
|
||||
expect(registers).toEqual([]);
|
||||
expect(pairs).toEqual([]);
|
||||
});
|
||||
|
||||
it("flera etiketter i en cell med värden på motsvarande rader i cellen bredvid", () => {
|
||||
const { pairs } = extract([table(["Förnamn:\nEfternamn:\nÅlder\nfödelsedatum:\nKön:", "Anna\nLind\n1990\n\nKvinna"])], () => false);
|
||||
expect(pairs).toEqual([
|
||||
{ label: "Förnamn", value: "Anna" },
|
||||
{ label: "Efternamn", value: "Lind" },
|
||||
{ label: "Ålder födelsedatum", value: "1990" },
|
||||
{ label: "Kön", value: "Kvinna" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("kraschar inte på konstiga block", () => {
|
||||
expect(() => extract([table(), table([]), table([""]), para(""), para(":"), table(["::", ":"])], () => true)).not.toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe("findEntity", () => {
|
||||
it("hittar på ID, på namn och på båda", () => {
|
||||
expect(findEntity("KI-0001", known)?.id).toBe("k1");
|
||||
expect(findEntity("Anna Lind", known)?.id).toBe("k1");
|
||||
expect(findEntity("anna lind (KI-0001)", known)?.id).toBe("k1");
|
||||
expect(findEntity("Lunds skola FI-0002", known)?.id).toBe("c1");
|
||||
});
|
||||
|
||||
it("ID går före ett namn som pekar på en annan post", () => {
|
||||
expect(findEntity("Bo Ek KI-0001", known)?.id).toBe("k1");
|
||||
});
|
||||
|
||||
it("begränsar till en typ och hittar inte det som är tvetydigt eller okänt", () => {
|
||||
expect(findEntity("KI-0001", known, "COMPANY")).toBeNull();
|
||||
expect(findEntity("Okänd", known)).toBeNull();
|
||||
expect(findEntity("", known)).toBeNull();
|
||||
const twins: KnownEntity[] = [
|
||||
{ id: "a", name: "Sven", code: "KI-0010", kind: "CHARACTER" },
|
||||
{ id: "b", name: "Sven", code: "KI-0011", kind: "CHARACTER" },
|
||||
];
|
||||
expect(findEntity("Sven", twins)).toBeNull();
|
||||
expect(findEntity("Sven KI-0011", twins)?.id).toBe("b");
|
||||
});
|
||||
});
|
||||
|
||||
describe("usableCode", () => {
|
||||
it("godtar bara ID med rätt prefix", () => {
|
||||
expect(usableCode("CHARACTER", "KI-0007")).toBe("KI-0007");
|
||||
expect(usableCode("CHARACTER", "FI-0007")).toBeNull();
|
||||
expect(usableCode("CHARACTER", "KI-abc")).toBeNull();
|
||||
expect(usableCode("CHARACTER", null)).toBeNull();
|
||||
expect(usableCode("APP", "KI-0001")).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
// ─── Hela dokument, byggda som de riktiga mallarna ──────────────────────────
|
||||
|
||||
describe("karaktär", () => {
|
||||
const blocks = [
|
||||
table(
|
||||
["Karaktärs ID:", "KI-0007"],
|
||||
["Förnamn:", "Anna"],
|
||||
["Efternamn:", "Lind"],
|
||||
["Smeknamn:", "Annie"],
|
||||
["Ålderfödelsedatum:", "1990-05-04"],
|
||||
["Längd:", "170"],
|
||||
["Kön:", "Kvinna"],
|
||||
["Läggning:", ""],
|
||||
["Yrke:", "Lärare"],
|
||||
["Anställd hos:(inkludera ID)", "Lunds skola FI-0002"],
|
||||
),
|
||||
para("Utseende:"),
|
||||
para("Lång och smal."),
|
||||
para("Personlighet:"),
|
||||
para("Varm."),
|
||||
para("Relationer:"),
|
||||
para("Vän med Bo."),
|
||||
para("Övrigt:"),
|
||||
para("Gillar katter."),
|
||||
];
|
||||
|
||||
it("känns igen och tolkas till namn, ID, fält och koppling", () => {
|
||||
const doc = analyze(blocks);
|
||||
expect(doc.kind).toBe("CHARACTER");
|
||||
const item = only(doc);
|
||||
expect(item).toMatchObject({ entityKind: "CHARACTER", name: "Anna Lind", code: "KI-0007" });
|
||||
expect(item.data).toEqual({
|
||||
nickname: "Annie",
|
||||
birthDate: "1990-05-04",
|
||||
height: "170",
|
||||
gender: "Kvinna",
|
||||
occupation: "Lärare",
|
||||
appearance: "Lång och smal.",
|
||||
personality: "Varm.",
|
||||
notes: "Gillar katter.",
|
||||
});
|
||||
expect(item.links).toEqual([{ type: "Jobbar på", toDocument: false, entityId: "c1", text: "Lunds skola FI-0002", note: "" }]);
|
||||
expect(item.unmatched).toEqual([{ label: "Relationer", value: "Vän med Bo." }]);
|
||||
});
|
||||
|
||||
it("ålder utan födelsedatum blir ålder", () => {
|
||||
const item = only(analyze([table(["Karaktärs ID:", ""], ["Förnamn:", "Eva"], ["Ålderfödelsedatum:", "34"])]));
|
||||
expect(item.data).toEqual({ age: 34 });
|
||||
});
|
||||
|
||||
it("namnet kan bara vara ett förnamn, och utan namn används filnamnet", () => {
|
||||
expect(only(analyze([table(["Karaktärs ID:", ""], ["Förnamn:", "Eva"])])).name).toBe("Eva");
|
||||
expect(only(analyze([table(["Karaktärs ID:", ""], ["Yrke:", "Lärare"])], "Min figur.docx")).name).toBe("Min figur");
|
||||
});
|
||||
|
||||
it("korta mallen med alla etiketter i en cell och värdena i cellen bredvid", () => {
|
||||
const labels = "Karaktärs ID:\n\nFörnamn:\nEfternamn:\nSmeknamn:\nÅlder\nfödelsedatum:\nLängd:\nKön:\nLäggning:\nYrke:\nAnställd hos:\n(inkludera ID)";
|
||||
const values = "KI-0009\n\nAnna\nLind\nAnnie\n1990-05-04\n\n170\nKvinna\n\nLärare\nLunds skola FI-0002";
|
||||
const item = only(analyze([table([labels, values]), table(["Utseende:"], ["Lång."], ["Övrigt:"], ["Hej."])]));
|
||||
expect(item).toMatchObject({ name: "Anna Lind", code: "KI-0009" });
|
||||
expect(item.data).toMatchObject({ nickname: "Annie", birthDate: "1990-05-04", height: "170", gender: "Kvinna", occupation: "Lärare", appearance: "Lång.", notes: "Hej." });
|
||||
expect(item.links[0]).toMatchObject({ type: "Jobbar på", entityId: "c1" });
|
||||
});
|
||||
|
||||
it("flera anställningar i samma fält", () => {
|
||||
const item = only(analyze([table(["Karaktärs ID:", ""], ["Förnamn:", "Eva"], ["Anställd hos:(inkludera ID)", "Lunds skola FI-0002, Okänd AB"])]));
|
||||
expect(item.links.map((l) => [l.text, l.entityId])).toEqual([["Lunds skola FI-0002", "c1"], ["Okänd AB", null]]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("djur", () => {
|
||||
it("val i rutor och ägare", () => {
|
||||
const doc = analyze([
|
||||
table(["Djur ID:", "DI-0004", "Namn:", "Findus"], ["Smeknamn:", "Fisse", "Ägare:", "Anna Lind"]),
|
||||
para("Djuridentitet:"),
|
||||
table(["Djur kategori:", "Husdjur: X Gårdsdjur: Annat:"], ["Djur typ:(Hund/katt/häst)", "Katt"], ["Ras:", "Huskatt"], ["Ålder:", "5", "Kön:", "Hona/kvinnlig: Hane/manlig: X"], ["Päls/hud/fjäder färg:", "Grå", "Vikt:", "4,5 kg"]),
|
||||
para("Djurets personlighet:"),
|
||||
para("Nyfiken."),
|
||||
]);
|
||||
expect(doc.kind).toBe("PET");
|
||||
const item = only(doc);
|
||||
expect(item).toMatchObject({ name: "Findus", code: "DI-0004" });
|
||||
expect(item.data).toMatchObject({ nickname: "Fisse", category: "Husdjur", species: "Katt", breed: "Huskatt", age: 5, sex: "Hane", coat: "Grå", weight: "4,5 kg", personality: "Nyfiken." });
|
||||
expect(item.links).toEqual([{ type: "Husdjur till", toDocument: false, entityId: "k1", text: "Anna Lind", note: "" }]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("bostad", () => {
|
||||
const blocks = [
|
||||
table(
|
||||
["Bostads ID:", "BI-0001", "Bostads typ:", "Hyresrätt: Bostadsrätt: X Villa:"],
|
||||
["Adress:", "Storgatan 1"],
|
||||
["Antal Rum:", "3", "Boarea:", "75,5", "Skiss ID:(Boarea)", ""],
|
||||
["Boende:"],
|
||||
["Namn:", "Karaktärs ID:"],
|
||||
["Anna Lind", "KI-0001"],
|
||||
["Bo Ek", ""],
|
||||
["", ""],
|
||||
),
|
||||
para("Byggnadsutseende: (Beskriv byggnadens utseende kring byggnaden)"),
|
||||
para("Rött trähus."),
|
||||
table(["Hyra lägenhet:", "5000 kr", "Våning:", "2"], ["Hyra parkeringsplats:", "", "Balkong:", "Ja: X Nej:"]),
|
||||
];
|
||||
|
||||
it("tolkar fält av olika sorter och deltagarlistan", () => {
|
||||
const doc = analyze(blocks);
|
||||
expect(doc.kind).toBe("HOME");
|
||||
const item = only(doc);
|
||||
expect(item.name).toBe("Storgatan 1");
|
||||
expect(item.data).toEqual({ homeType: "Bostadsrätt", address: "Storgatan 1", rooms: 3, livingArea: 75.5, buildingLook: "Rött trähus.", rentFee: "5000 kr", floor: "2", balcony: true });
|
||||
expect(item.links.map((l) => [l.type, l.toDocument, l.entityId])).toEqual([["Bor på", true, "k1"], ["Bor på", true, "k2"]]);
|
||||
});
|
||||
|
||||
it("ett val som saknas i mallen hamnar bland det som inte tolkats", () => {
|
||||
const item = only(analyze([table(["Bostads ID:", ""], ["Bostads typ:", "Slott: X Koja:"], ["Adress:", "Vägen 2"])]));
|
||||
expect(item.data).toEqual({ address: "Vägen 2" });
|
||||
expect(item.unmatched).toEqual([{ label: "Bostads typ", value: "Slott: X Koja:" }]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("företag", () => {
|
||||
const blocks = [
|
||||
table(
|
||||
["Företagets namn:", "Lunds Kaffe", "Företags ID:", "FI-0003"],
|
||||
["Bransch:", "Kaffe", "Finns skisser", "Ja: X Nej:"],
|
||||
["Lokal ID:", "LI-0001", "Skiss ID:", ""],
|
||||
["Anställda:"],
|
||||
["Namn:", "Roll:", "Karaktärsnummer:"],
|
||||
["Anna Lind", "Barista", "KI-0001"],
|
||||
["", "", ""],
|
||||
),
|
||||
para("Annan information:"),
|
||||
table(
|
||||
["Arbetsplats för karaktärer:", "Ja: X Nej:", "Plats för karaktärerna att umgås:", "Ja: Nej: X"],
|
||||
["Bryr sig chefen om de anställda?", "Ja: X Nej:", "Generell nöjdhet bland de anställda:", "Bra: X Dåligt:"],
|
||||
),
|
||||
para("Arbetsmiljö:"),
|
||||
para("Trevlig."),
|
||||
];
|
||||
|
||||
it("tolkar namn, ID, koppling till lokal, val i rutor och anställda med roll", () => {
|
||||
const doc = analyze(blocks);
|
||||
expect(doc.kind).toBe("COMPANY");
|
||||
const item = only(doc);
|
||||
expect(item).toMatchObject({ name: "Lunds Kaffe", code: "FI-0003" });
|
||||
expect(item.data).toEqual({
|
||||
industry: "Kaffe",
|
||||
hasSketches: true,
|
||||
premises: "l1",
|
||||
workplaceForCharacters: true,
|
||||
socialPlace: false,
|
||||
bossCares: true,
|
||||
satisfaction: "Bra",
|
||||
workEnvironment: "Trevlig.",
|
||||
});
|
||||
expect(item.display.premises).toBe("LI-0001 · Café Lund");
|
||||
expect(item.links).toEqual([{ type: "Jobbar på", toDocument: true, entityId: "k1", text: "Anna Lind KI-0001", note: "Barista" }]);
|
||||
});
|
||||
});
|
||||
|
||||
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"])]);
|
||||
expect(doc.kind).toBe("PREMISES");
|
||||
const item = only(doc);
|
||||
expect(item).toMatchObject({ code: "LI-0005", name: "Torget 3" });
|
||||
expect(item.data).toEqual({ address: "Torget 3", placementId: "PI-0001", industryFit: "Café", rooms: 2, area: 40, tenure: "Hyr", coldStorage: true, elevator: false });
|
||||
});
|
||||
|
||||
it("utbildning med lärare och elever", () => {
|
||||
const doc = analyze([
|
||||
table(
|
||||
["Utbildnings ID:", "UI-0001", "Skolans namn:", "Lunds gymnasium"],
|
||||
["Utbildningstyp:", "Förskola: lågstadium: Mellanstadium: Högstadium: Gymnasium: X Högskola:"],
|
||||
["Linje:(Om Gymnasium eller högre)", "Natur"],
|
||||
["Lärare till klassen:"],
|
||||
["Namn:", "Ämne:", "Karaktärs ID:"],
|
||||
["Anna Lind", "Biologi", "KI-0001"],
|
||||
["", "", ""],
|
||||
["Elever i klassen:"],
|
||||
["Namn:", "Karaktärs ID:"],
|
||||
["Bo Ek", "KI-0002"],
|
||||
),
|
||||
]);
|
||||
expect(doc.kind).toBe("EDUCATION");
|
||||
const item = only(doc);
|
||||
expect(item).toMatchObject({ name: "Lunds gymnasium", code: "UI-0001" });
|
||||
expect(item.data).toEqual({ educationType: "Gymnasium", program: "Natur" });
|
||||
expect(item.links.map((l) => [l.type, l.entityId, l.note])).toEqual([
|
||||
["Lärare på", "k1", "Biologi"],
|
||||
["Elev på", "k2", ""],
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("scenario", () => {
|
||||
it("typ på nästa rad, kopplat ID och två deltagarlistor", () => {
|
||||
const doc = analyze([
|
||||
table(
|
||||
["Scenario ID:", "SNI-0001", "Kopplat ID:", "KI-0001"],
|
||||
["Scenario typ:"],
|
||||
["Bråk: X Olycka: Dödsfall: Otrohet: Brott: Övrigt:"],
|
||||
["Involverade karaktärer:"],
|
||||
["Namn:", "Karaktärs ID:"],
|
||||
["Anna Lind", "KI-0001"],
|
||||
["", ""],
|
||||
),
|
||||
para("Berörda karaktärer:"),
|
||||
table(["Namn:", "Karaktärs ID:"], ["Bo Ek", "KI-0002"]),
|
||||
para("Beskriv scenariot:"),
|
||||
para("De bråkade om pengar."),
|
||||
para("Övrig information:"),
|
||||
]);
|
||||
expect(doc.kind).toBe("SCENARIO");
|
||||
const item = only(doc);
|
||||
expect(item.code).toBe("SNI-0001");
|
||||
expect(item.data).toEqual({ linkedEntity: "k1", scenarioType: "Bråk", description: "De bråkade om pengar." });
|
||||
expect(item.name).toBe("Bråk SNI-0001");
|
||||
expect(item.links.map((l) => [l.type, l.toDocument, l.entityId])).toEqual([["Involverad i", true, "k1"], ["Berörd av", true, "k2"]]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("relation", () => {
|
||||
const blocks = [
|
||||
table(
|
||||
["Relations ID:", "REI-0004", "Relations typ:", "Vännergrupper: Partner: X Familj: Kollegor:"],
|
||||
["Är relationen Hälsosam?", "Ja: X Nej:", "Är relationen aktiv:", "Ja: X Nej: Blivande:"],
|
||||
["Vilka ingår i relationen:"],
|
||||
["Namn:", "Karaktärs ID:"],
|
||||
["Anna Lind", "KI-0001"],
|
||||
["Bo Ek", ""],
|
||||
["Okänd Person", "KI-9999"],
|
||||
["", ""],
|
||||
),
|
||||
para("Hur fungerar relationen: (Finns det som är känsligt eller gammalt bråk)"),
|
||||
para("De bråkar sällan."),
|
||||
para("Övrigt:"),
|
||||
];
|
||||
|
||||
it("ger deltagare, typ och fält", () => {
|
||||
const doc = analyze(blocks);
|
||||
expect(doc.kind).toBe("RELATION");
|
||||
expect(doc.relation).toEqual({
|
||||
type: "Partner",
|
||||
participants: [
|
||||
{ text: "Anna Lind KI-0001", entityId: "k1" },
|
||||
{ text: "Bo Ek", entityId: "k2" },
|
||||
{ text: "Okänd Person KI-9999", entityId: null },
|
||||
],
|
||||
});
|
||||
expect(only(doc).data).toEqual({ category: "Partner", healthy: true, active: "Ja", howItWorks: "De bråkar sällan." });
|
||||
expect(doc.warnings).toEqual([]);
|
||||
});
|
||||
|
||||
it("varnar när deltagare saknas", () => {
|
||||
const doc = analyze([table(["Relations ID:", ""], ["Vilka ingår i relationen:"], ["Namn:", "Karaktärs ID:"], ["Anna Lind", "KI-0001"])]);
|
||||
expect(doc.warnings).toContain("few-participants");
|
||||
});
|
||||
});
|
||||
|
||||
describe("register", () => {
|
||||
it("fordon med koppling till ägare och referens, en post per rad", () => {
|
||||
const doc = analyze([
|
||||
table(
|
||||
["Fordons ID:", "Märke och modell:", "Drivmedel: (Bensin/diesel/el)", "Ägare: (Karaktärens namn och ID)", "Referens ID:"],
|
||||
["FD-0001", "Volvo V70", "Diesel", "Anna Lind KI-0001", "RD-0002"],
|
||||
["", "", "", "", ""],
|
||||
["FD-0002", "Tesla Model 3", "El", "Okänd", ""],
|
||||
),
|
||||
]);
|
||||
expect(doc.kind).toBe("VEHICLE");
|
||||
expect(doc.items).toHaveLength(2);
|
||||
expect(doc.items[0]).toMatchObject({ name: "Volvo V70", code: "FD-0001" });
|
||||
expect(doc.items[0].data).toEqual({ model: "Volvo V70", fuel: "Diesel", owner: "k1", reference: "r1" });
|
||||
expect(doc.items[1].data).toEqual({ model: "Tesla Model 3", fuel: "El" });
|
||||
expect(doc.items[1].unmatched).toEqual([{ label: "Ägare", value: "Okänd" }]);
|
||||
});
|
||||
|
||||
it("referenser får namn av beskrivningen", () => {
|
||||
const doc = analyze([table(["Referens ID:", "Beskrivning:"], ["RD-0005", "En bok om fåglar"], ["", ""], ["RD-0006", "En film"])]);
|
||||
expect(doc.kind).toBe("REFERENCE");
|
||||
expect(doc.items.map((i) => [i.code, i.name, i.data.description])).toEqual([
|
||||
["RD-0005", "En bok om fåglar", "En bok om fåglar"],
|
||||
["RD-0006", "En film", "En film"],
|
||||
]);
|
||||
});
|
||||
|
||||
it("research", () => {
|
||||
expect(analyze([table(["Research ID:", "Beskrivning:"], ["RI-0001", "Polisens rutiner"], ["", ""], ["", ""])]).kind).toBe("RESEARCH");
|
||||
});
|
||||
|
||||
it("appar och hemsidor: en post per namn", () => {
|
||||
const apps = analyze([para("Appar:"), para("Applikationer på telefoner som karaktärerna kommer att använda."), table(["Namn: Instagram"], ["Beskrivning: Bilder"], ["Namn: Bankapp"], ["Beskrivning:"], ["Namn:"], ["Beskrivning:"])]);
|
||||
expect(apps.kind).toBe("APP");
|
||||
expect(apps.items.map((i) => [i.name, i.data.description])).toEqual([
|
||||
["Instagram", "Bilder"],
|
||||
["Bankapp", undefined],
|
||||
]);
|
||||
|
||||
const sites = analyze([para("Hemsidor:"), para("Hemsidor på telefoner och datorer."), table(["Namn:", "Lunds kommun"], ["Beskrivning:", "Kommunens sida"])]);
|
||||
expect(sites.kind).toBe("WEBSITE");
|
||||
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"] });
|
||||
const scheduleRegister = analyze([table(["Schema ID:", "Karaktärs ID:", "Dag/natt:"], ["", "", "Dag: Natt:"], ["", "", "Dag: Natt:"])]);
|
||||
expect(scheduleRegister).toMatchObject({ kind: null, warnings: ["unsupported"] });
|
||||
const maps = analyze([table(["Kart ID:", "Placerings ID:", "Stad/Område:"], ["", "", ""], ["", "", ""])]);
|
||||
expect(maps).toMatchObject({ kind: null, warnings: ["unsupported"] });
|
||||
});
|
||||
});
|
||||
|
||||
describe("typ och varningar", () => {
|
||||
it("ett dokument som inte liknar någon mall får okänd typ", () => {
|
||||
expect(analyze([para("Bara lite text."), para("Mer text.")])).toMatchObject({ kind: null, warnings: ["unknown-kind"] });
|
||||
});
|
||||
|
||||
it("användaren kan välja typ själv", () => {
|
||||
const doc = analyze([table(["Namn:", "Rex"], ["Ras:", "Boxer"])], "hund.docx", "PET");
|
||||
expect(doc.kind).toBe("PET");
|
||||
expect(only(doc)).toMatchObject({ name: "Rex", data: { breed: "Boxer" } });
|
||||
});
|
||||
|
||||
it("ett tomt dokument ger en varning", () => {
|
||||
expect(analyze([table(["Referens ID:", "Beskrivning:"], ["", ""], ["", ""])]).warnings).toContain("empty");
|
||||
});
|
||||
|
||||
it("detectKind går på dokumentets eget ID före andra etiketter", () => {
|
||||
// Ett företag har både Företags ID och Lokal ID, men är ett företag
|
||||
const ex = extract([table(["Företags ID:", ""], ["Lokal ID:", ""])], () => false);
|
||||
expect(detectKind(ex, "x.docx")).toBe("COMPANY");
|
||||
});
|
||||
});
|
||||
|
||||
describe("tolkning av värden", () => {
|
||||
const item = (rows: string[][], kind: ImportKind = "CHARACTER") => analyzeDocument([table(...rows)], "x.docx", known, { kind }).items[0];
|
||||
|
||||
it("tal med komma, text runt talet och ogiltiga tal", () => {
|
||||
expect(item([["Förnamn:", "A"], ["Antal Rum:", "3,5"]], "HOME").data).toMatchObject({ rooms: 3.5 });
|
||||
expect(item([["Adress:", "X"], ["Antal rum:", "ca 4 st"]], "HOME").data).toMatchObject({ rooms: 4 });
|
||||
expect(item([["Adress:", "X"], ["Antal rum:", "många"]], "HOME").unmatched).toEqual([{ label: "Antal rum", value: "många" }]);
|
||||
});
|
||||
|
||||
it("datum med bara år, och text som inte är ett datum", () => {
|
||||
expect(item([["Förnamn:", "A"], ["Ålderfödelsedatum:", "1985"]]).data).toEqual({ birthDate: "1985" });
|
||||
expect(item([["Förnamn:", "A"], ["Ålderfödelsedatum:", "i våras"]]).unmatched).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("länkar måste vara riktiga webbadresser", () => {
|
||||
expect(item([["Namn:", "Wiki"], ["Länk eller källa:", "https://sv.wikipedia.org"]], "REFERENCE").data).toEqual({ link: "https://sv.wikipedia.org" });
|
||||
expect(item([["Namn:", "Wiki"], ["Länk eller källa:", "javascript:alert(1)"]], "REFERENCE").data).toEqual({});
|
||||
});
|
||||
|
||||
it("samma fält två gånger: första räknas, resten rapporteras", () => {
|
||||
const parsed = item([["Förnamn:", "A"], ["Yrke:", "Lärare"], ["Yrke:", "Chef"]]);
|
||||
expect(parsed.data).toEqual({ occupation: "Lärare" });
|
||||
expect(parsed.unmatched).toEqual([{ label: "Yrke", value: "Chef" }]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("riktiga Word-filer", () => {
|
||||
const dir = new URL("../../", import.meta.url);
|
||||
const file = (path: string) => new Uint8Array(readFileSync(new URL(path, dir)));
|
||||
const available = existsSync(new URL("Mall/Karaktärermall.docx", dir));
|
||||
|
||||
// Mallarna är blanka, så typen kommer av etiketterna: alla dokument ska ändå kännas igen och inget ska krascha
|
||||
const expected: [string, string | null][] = [
|
||||
["Mall/Karaktärermall.docx", "CHARACTER"],
|
||||
["Mall/Karaktärermall-kort.docx", "CHARACTER"],
|
||||
["Mall/Djurmall.docx", "PET"],
|
||||
["Mall/Bostadsmall.docx", "HOME"],
|
||||
["Mall/Företagsmall.docx", "COMPANY"],
|
||||
["Mall/Lokalmall.docx", "PREMISES"],
|
||||
["Mall/Utbildningsmall.docx", "EDUCATION"],
|
||||
["Mall/Scenariomall.docx", "SCENARIO"],
|
||||
["Mall/Relationsmall.docx", "RELATION"],
|
||||
["Mall/Schema dag.docx", null],
|
||||
["Mall/Schema natt.docx", null],
|
||||
["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],
|
||||
];
|
||||
|
||||
it.skipIf(!available).each(expected)("%s känns igen som %s", (path, kind) => {
|
||||
const doc = analyzeDocument(readDocx(file(path)), path.split("/").pop()!, known);
|
||||
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([]);
|
||||
});
|
||||
|
||||
it.skipIf(!available)("alla mallar går att läsa och tolka utan fel", () => {
|
||||
for (const [path] of expected) expect(() => analyzeDocument(readDocx(file(path)), path, known)).not.toThrow();
|
||||
});
|
||||
|
||||
it("ett ifyllt dokument i riktigt Word-format går hela vägen från fil till post", () => {
|
||||
const bytes = makeDocx([table(["Karaktärs ID:", "KI-0042"], ["Förnamn:", "Åsa"], ["Efternamn:", "Öberg"], ["Yrke:", "Läkare"]), para("Övrigt:"), para("Rad ett"), para("Rad två")]);
|
||||
const doc = analyzeDocument(readDocx(bytes), "asa.docx", known);
|
||||
expect(doc.kind).toBe("CHARACTER");
|
||||
expect(only(doc)).toMatchObject({ name: "Åsa Öberg", code: "KI-0042", data: { occupation: "Läkare", notes: "Rad ett\nRad två" } });
|
||||
});
|
||||
});
|
||||
|
||||
describe("cleanData", () => {
|
||||
const fields = getDefaultTemplate("COMPANY", "sv");
|
||||
const entities = new Map<string, "COMPANY" | "PREMISES" | "SKETCH">([["l1", "PREMISES"], ["c1", "COMPANY"]]);
|
||||
|
||||
it("behåller bara giltiga värden av rätt sort i fält som finns i mallen", () => {
|
||||
const clean = cleanData(
|
||||
fields,
|
||||
{
|
||||
industry: " Kaffe ",
|
||||
premises: "l1",
|
||||
hasSketches: true,
|
||||
satisfaction: "Bra",
|
||||
hotelRooms: 10,
|
||||
okänt: "x",
|
||||
},
|
||||
entities as never,
|
||||
);
|
||||
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", () => {
|
||||
const clean = cleanData(
|
||||
fields,
|
||||
{ industry: 5, premises: "c1", sketch: "finns-inte", hasSketches: "ja", satisfaction: "Fantastisk", hotelRooms: "10", signOutside: null },
|
||||
entities as never,
|
||||
);
|
||||
expect(clean).toEqual({});
|
||||
});
|
||||
|
||||
it("datum normaliseras och ogiltiga avvisas", () => {
|
||||
const characterFields = getDefaultTemplate("CHARACTER", "sv");
|
||||
expect(cleanData(characterFields, { birthDate: "1990-5-4", deathDate: "nej" }, new Map())).toEqual({ birthDate: "1990-05-04" });
|
||||
});
|
||||
|
||||
it("webbadresser måste börja med http", () => {
|
||||
const refFields = getDefaultTemplate("REFERENCE", "sv");
|
||||
expect(cleanData(refFields, { link: "https://example.com" }, new Map())).toEqual({ link: "https://example.com" });
|
||||
expect(cleanData(refFields, { link: "javascript:alert(1)" }, new Map())).toEqual({});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,139 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { isOptionList, labelsMatch, looseMatch, markedOption, normLabel, parseOptions, parseYesNo, pickOption } from "@/lib/word-labels";
|
||||
|
||||
describe("normLabel", () => {
|
||||
it("tar bort hjälptexter, skiljetecken och ID-ord", () => {
|
||||
expect(normLabel("Anställd hos:(inkludera ID)")).toBe("anställd hos");
|
||||
expect(normLabel("Skiss ID:(Boarea)")).toBe("skiss");
|
||||
expect(normLabel("Är relationen Hälsosam?")).toBe("är relationen hälsosam");
|
||||
expect(normLabel("Schema-ID")).toBe("schema");
|
||||
expect(normLabel(" Alkoholservering:(om restaurang/hotell) ")).toBe("alkoholservering");
|
||||
});
|
||||
});
|
||||
|
||||
describe("labelsMatch", () => {
|
||||
it("känner igen samma etikett skriven på olika sätt", () => {
|
||||
expect(labelsMatch("Djur kategori", "Djurkategori")).toBe(true);
|
||||
expect(labelsMatch("Antal Rum:", "Antal rum")).toBe(true);
|
||||
expect(labelsMatch("Boarea:", "Boarea (m²)")).toBe(true);
|
||||
expect(labelsMatch("Är relationen Hälsosam?", "Relationen är hälsosam")).toBe(true);
|
||||
expect(labelsMatch("Ordförråd: (världsspråk och fackspråk):", "Ordförråd (världsspråk och fackspråk)")).toBe(true);
|
||||
expect(labelsMatch("Lokal ID", "Lokal")).toBe(true);
|
||||
});
|
||||
|
||||
it("godtar ett skrivfel i slutet men inte olika ord", () => {
|
||||
expect(labelsMatch("Längde", "Längd")).toBe(true);
|
||||
expect(labelsMatch("Alkohol", "Alkoholservering")).toBe(false);
|
||||
expect(labelsMatch("Ålder", "Födelsedatum")).toBe(false);
|
||||
expect(labelsMatch("Kön", "Läggning")).toBe(false);
|
||||
expect(labelsMatch("Våning", "Antal våningar")).toBe(false);
|
||||
});
|
||||
|
||||
it("tomma etiketter matchar ingenting", () => {
|
||||
expect(labelsMatch("", "")).toBe(false);
|
||||
expect(labelsMatch("ID", "ID")).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("looseMatch", () => {
|
||||
it("känner igen etiketter som skrivits längre än i mallen", () => {
|
||||
expect(looseMatch("Djurets personlighet", "Personlighet")).toBe(true);
|
||||
expect(looseMatch("Päls/hud/fjäder färg", "Päls-, hud- eller fjäderfärg")).toBe(true);
|
||||
expect(looseMatch("Beskriv djurets utseende mer detaljerat", "Utseende i detalj")).toBe(true);
|
||||
});
|
||||
|
||||
it("kräver att alla betydelsebärande ord finns", () => {
|
||||
expect(looseMatch("Personlighet", "Djurets personlighet och bakgrund")).toBe(false);
|
||||
expect(looseMatch("Adress", "Antal rum")).toBe(false);
|
||||
expect(looseMatch("Ja", "Hiss")).toBe(false);
|
||||
});
|
||||
|
||||
it("korta etiketter räcker inte för en lös träff", () => {
|
||||
expect(looseMatch("Hiss i huset", "Hiss")).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("alternativ i rutor", () => {
|
||||
it("känner igen en lista med alternativ men inte en vanlig etikett", () => {
|
||||
expect(isOptionList("Ja: Nej:")).toBe(true);
|
||||
expect(isOptionList("Förskola: lågstadium: Mellanstadium: Högstadium:")).toBe(true);
|
||||
expect(isOptionList("Anställd hos:(inkludera ID)")).toBe(false);
|
||||
expect(isOptionList("Ordförråd: (världsspråk och fackspråk):")).toBe(false);
|
||||
expect(isOptionList("Namn:")).toBe(false);
|
||||
expect(isOptionList("Bara en vanlig text utan kolon")).toBe(false);
|
||||
});
|
||||
|
||||
it("läser kryss efter alternativet", () => {
|
||||
expect(parseOptions("Ja: X Nej:")).toEqual([
|
||||
{ label: "Ja", marked: true },
|
||||
{ label: "Nej", marked: false },
|
||||
]);
|
||||
expect(parseOptions("Ja: Nej: x")).toEqual([
|
||||
{ label: "Ja", marked: false },
|
||||
{ label: "Nej", marked: true },
|
||||
]);
|
||||
expect(parseOptions("Bra: Dåligt:")?.every((o) => !o.marked)).toBe(true);
|
||||
});
|
||||
|
||||
it("läser kryssrutor före alternativet", () => {
|
||||
expect(parseOptions("☒ Ja: ☐ Nej:")).toEqual([
|
||||
{ label: "Ja", marked: true },
|
||||
{ label: "Nej", marked: false },
|
||||
]);
|
||||
expect(parseOptions("✓ Hona/kvinnlig: Hane/manlig:")).toEqual([
|
||||
{ label: "Hona/kvinnlig", marked: true },
|
||||
{ label: "Hane/manlig", marked: false },
|
||||
]);
|
||||
});
|
||||
|
||||
it("flera alternativ och hjälptexter", () => {
|
||||
const options = parseOptions("Hyresrätt: Bostadsrätt: X Villa:")!;
|
||||
expect(options.map((o) => o.label)).toEqual(["Hyresrätt", "Bostadsrätt", "Villa"]);
|
||||
expect(markedOption(options)).toBe("Bostadsrätt");
|
||||
});
|
||||
|
||||
it("inget eller flera markerade ger inget val", () => {
|
||||
expect(markedOption(parseOptions("Ja: Nej:")!)).toBeNull();
|
||||
expect(markedOption(parseOptions("Ja: X Nej: X")!)).toBeNull();
|
||||
});
|
||||
|
||||
it("ett alternativ som börjar på x tolkas inte som kryss", () => {
|
||||
expect(parseOptions("Ja: Xavier:")?.map((o) => o.marked)).toEqual([false, false]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseYesNo", () => {
|
||||
it("tolkar ja och nej på flera sätt", () => {
|
||||
expect(parseYesNo("Ja: X Nej:")).toBe(true);
|
||||
expect(parseYesNo("Ja: Nej: X")).toBe(false);
|
||||
expect(parseYesNo("ja")).toBe(true);
|
||||
expect(parseYesNo("Nej.")).toBe(false);
|
||||
expect(parseYesNo("X")).toBe(true);
|
||||
expect(parseYesNo("✓")).toBe(true);
|
||||
});
|
||||
|
||||
it("ger null när det inte går att avgöra", () => {
|
||||
expect(parseYesNo("")).toBeNull();
|
||||
expect(parseYesNo("Ja: Nej:")).toBeNull();
|
||||
expect(parseYesNo("kanske")).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("pickOption", () => {
|
||||
const options = ["Husdjur", "Gårdsdjur", "Annat"];
|
||||
it("väljer det markerade alternativet eller texten", () => {
|
||||
expect(pickOption("Husdjur: X Gårdsdjur: Annat:", options)).toBe("Husdjur");
|
||||
expect(pickOption("gårdsdjur", options)).toBe("Gårdsdjur");
|
||||
});
|
||||
|
||||
it("godtar en längre form av alternativet", () => {
|
||||
expect(pickOption("Hona/kvinnlig: Hane/manlig: X", ["Hona", "Hane"])).toBe("Hane");
|
||||
expect(pickOption("Vännergrupper", ["Vännergrupp", "Partner"])).toBe("Vännergrupp");
|
||||
});
|
||||
|
||||
it("ger null för okända val", () => {
|
||||
expect(pickOption("Hund", options)).toBeNull();
|
||||
expect(pickOption("", options)).toBeNull();
|
||||
expect(pickOption("Husdjur: Gårdsdjur: Annat:", options)).toBeNull();
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user