Supply Chain Resilience Assessment Tool

Table of Contents

Indholdsfortegnelse

Overview

The Supply Chain Resilience Assessment Tool is built on PocketBase — a single-binary Go backend that provides a SQLite database, REST API, and an integrated admin dashboard. Administrators manage the platform through the PocketBase Admin UI at /_/.

Admin Responsibilities

• Creating and managing sessions (groups of participants)
• Managing user accounts and access tokens
• Adding new question sets for different survey versions
• Monitoring survey completion status
• Database backup and maintenance

Oversigt

Supply Chain Resilience Assessment Tool er bygget på PocketBase — en single-binary Go-backend, der leverer en SQLite-database, REST API og et integreret adminpanel. Administratorer administrerer platformen via PocketBase Admin UI på /_/.

Administratoransvar

• Oprette og administrere sessioner (grupper af deltagere)
• Administrere brugerkonti og adgangstokens
• Tilføje nye spørgsmålssæt til forskellige undersøgelsesversioner
• Overvåge undersøgelsesafslutningsstatus
• Databasesikkerhedskopi og vedligeholdelse

PocketBase Basics

Accessing the Admin UI

The PocketBase admin dashboard is available at: http://<your-host>/_/

• Local development: http://127.0.0.1:8090/_/
• Production (Docker): http://localhost:8080/_/

Key Collections

Collection	Description
sessions	Survey sessions (groups of participants)
session_users	Participant accounts linked to sessions
app_settings	Global application settings
questions	Survey question sets (JSON schema)
forms	Submitted survey responses
snapshots	Collections schema snapshots

PocketBase-grundlæggende

Tilgå adminpanelet

PocketBase-adminpanelet er tilgængeligt på: http://<din-vært>/_/

• Lokal udvikling: http://127.0.0.1:8090/_/
• Produktion (Docker): http://localhost:8080/_/

Nøglesamlinger

Samling	Beskrivelse
sessions	Undersøgelsessessioner (grupper af deltagere)
session_users	Deltagerkonti knyttet til sessioner
app_settings	Globale applikationsindstillinger
questions	Undersøgelsesspørgsmålssæt (JSON-skema)
forms	Indsendte undersøgelsessvar
snapshots	Samlingsstruktur-snapshots

Authentication Tiers

The platform has three levels of access:

Role	Access Method	Capabilities
Superuser / Admin	PocketBase Admin UI (/_/)	Full platform management: manage all collections, users, settings, migrations
Session Manager	App login (/) with email + password	Create and manage sessions, view aggregated results and analysis charts
Survey Participant	Token link (/session/:name/survey?u=...&t=...)	Complete the survey for their assigned session only

Godkendelsesniveauer

Platformen har tre adgangsniveauer:

Rolle	Adgangsmetode	Kapaciteter
Superbruger / Administrator	PocketBase Admin UI (/_/)	Fuld platformsadministration: administrere alle samlinger, brugere, indstillinger og migrationer
Sessionsleder	App-login (/) med e-mail + adgangskode	Oprette og administrere sessioner, se aggregerede resultater og analysediagrammer
Undersøgelsesdeltager	Token-link (/session/:name/survey?u=...&t=...)	Udfylde undersøgelsen for deres tildelte session kun

Create Admin Account

There are two ways to create an admin account (pocketbase's superuser account). Choose the method that best fits your workflow.

Method 1: Via CLI

Use the PocketBase CLI to create a superuser from the command line. This works even when the server is not running.

# Using the standalone PocketBase binary:
./pocketbase superuser create admin@example.com yourpassword

# Or with Go run (when using PocketBase as a framework):
go run main.go superuser create admin@example.com yourpassword

# Or via Docker (when running in a container):
docker exec -it dk-if-open /backend superuser create admin@example.com yourpassword

Additional superuser subcommands:

Command	Description
superuser create EMAIL PASS	Create a new superuser
superuser upsert EMAIL PASS	Create a new superuser, or update the password if it already exists
superuser list	List all existing superusers

Method 2: From the Admin Panel

First-time Setup

On the very first start of the backend, PocketBase requires you to create a superuser account through the setup wizard:

1. Start the backend: go run main.go serve
2. Open http://127.0.0.1:8090/_/
3. PocketBase will redirect you to the setup page
4. Enter your admin email and a strong password
5. Click Create and login

Adding Additional Superusers

After the initial setup, you can create additional superuser accounts directly from the PocketBase admin dashboard:

1. Log in to the admin UI at /_/
2. Navigate to Collections > _superusers
3. Click New record
4. Enter the email and password for the new superuser
5. Click Create

Creating Session Manager Accounts

1. Log in to the admin UI at /_/
2. Navigate to Collections > users
3. Click New record
4. Enter the email and password for the session manager
5. Save the record
6. The session manager can now log in at the main app URL (/)

Opret adminkonto

Der er to måder at oprette en admin bruger (PocketBase-superbruger) på. Vælg den metode, der passer bedst til din arbejdsgang.

Metode 1: Via CLI

Brug PocketBase CLI til at oprette en superbruger fra kommandolinjen. Dette virker også når serveren ikke kører.

# Ved brug af den selvstændige PocketBase-binær:
./pocketbase superuser create admin@example.com dit_kodeord

# Eller med Go run (når PocketBase bruges som framework):
go run main.go superuser create admin@example.com dit_kodeord

# Eller via Docker (når du kører i en container):
docker exec -it dk-if-open /backend superuser create admin@example.com dit_kodeord

Yderligere superuser-underkommandoer:

Kommando	Beskrivelse
superuser create EMAIL KODEORD	Opret en ny superbruger
superuser upsert EMAIL KODEORD	Opret en ny superbruger, eller opdater adgangskoden hvis den allerede findes
superuser list	Vis alle eksisterende superbrugere

Metode 2: Fra adminpanelet

Førstegangsopsætning

Ved første start af backend kræver PocketBase, at du opretter en superbrugerkonto via opsætningsguiden:

1. Start backend: go run main.go serve
2. Åbn http://127.0.0.1:8090/_/
3. PocketBase viderestiller dig til opsætningssiden
4. Indtast din admin-e-mail og en stærk adgangskode
5. Klik på Opret og log ind

Tilføjelse af yderligere superbrugere

Efter den indledende opsætning kan du oprette yderligere superbrugerkonti direkte fra PocketBase-adminpanelet:

1. Log ind på adminpanelet på /_/
2. Naviger til Samlinger > _superusers
3. Klik på Ny post
4. Indtast e-mail og adgangskode til den nye superbruger
5. Klik på Opret

Opret sessionslederkonti

1. Log ind på adminpanelet på /_/
2. Naviger til Samlinger > users
3. Klik på Ny post
4. Indtast e-mail og adgangskode til sessionslederen
5. Gem posten
6. Sessionslederen kan nu logge ind på hoved-app-URL'en (/)

Reset Superuser Password

If you forget your superuser password, you can reset it via the PocketBase CLI:

# Stop the server first, then run:
./pocketbase superuser upsert new@email.com newpassword

# Or with go run:
go run main.go superuser upsert new@email.com newpassword

# Or via Docker:
docker exec -it dk-if-open /backend superuser upsert new@email.com newpassword

Nulstil superbrugerkodeord

Hvis du glemmer dit superbrugerkodeord, kan du nulstille det via PocketBase CLI:

# Stop serveren først, kør derefter:
./pocketbase superuser upsert ny@email.dk nyt_kodeord

# Eller med go run:
go run main.go superuser upsert ny@email.dk nyt_kodeord

# Eller via Docker:
docker exec -it dk-if-open /backend superuser upsert ny@email.dk nyt_kodeord

Add a New Question Set

The survey uses FormKit JSON schemas stored in the questions collection. You can add new question sets or customize existing ones.

Steps

1. Log in to the admin UI at /_/
2. Navigate to Collections > questions
3. Click New record
4. Fill in the fields:
   • name — Unique identifier for the question set
   • lang — Language code (en or da)
   • schema — FormKit JSON schema (see JSON Schema Reference)
5. Save the record

Tilføj nyt spørgsmålssæt

Undersøgelsen bruger FormKit JSON-skemaer gemt i questions-samlingen. Du kan tilføje nye spørgsmålssæt eller tilpasse eksisterende.

Trin

1. Log ind på adminpanelet på /_/
2. Naviger til Samlinger > questions
3. Klik på Ny post
4. Udfyld felterne:
   • name — Unikt id for spørgsmålssættet
   • lang — Sprogkode (en eller da)
   • schema — FormKit JSON-skema (se JSON-schemareference)
5. Gem posten

Verification Checklist

After setup, verify the following to ensure everything is working correctly:

Check	How to Verify
Backend is running	Visit http://<host>/api/health — should return {"code":200,...}
Admin UI accessible	Visit http://<host>/_/ — should show login or dashboard
Frontend loads	Visit http://<host>/ — should show the app
Migrations ran	In admin UI, verify collections: sessions, session_users, questions, forms exist
Question data seeded	In admin UI, check questions collection has records
Session manager login	Create a user account, then log in at /
Session creation	Log in as session manager, create a test session
Participant survey	Open the participant link from a test session

Verifikationstjekliste

Efter opsætning skal du verificere følgende for at sikre, at alt fungerer korrekt:

Tjek	Sådan verificeres
Backend kører	Besøg http://<vært>/api/health — bør returnere {"code":200,...}
Admin UI tilgængeligt	Besøg http://<vært>/_/ — bør vise login eller dashboard
Frontend indlæses	Besøg http://<vært>/ — bør vise appen
Migrationer kørte	I adminpanelet: verificer at samlingerne sessions, session_users, questions, forms findes
Spørgsmålsdata seeded	I adminpanelet: tjek at questions-samlingen har poster
Sessionsleder-login	Opret en brugerkonto, log derefter ind på /
Sessionsoprettelse	Log ind som sessionsleder, opret en testsession
Deltagerundersøgelse	Åbn deltagerlinket fra en testsession

Troubleshooting

Cannot access admin UI

• Verify the backend is running: go run main.go serve
• Check the port is correct (default: 8090 for dev, 8080 for Docker)
• Ensure no firewall is blocking the port
• Check server logs for errors

Migrations failed

• Delete pb_data/ and restart to run a fresh migration
• Check Go version is 1.21+
• Check server logs for specific error messages

Session manager cannot log in

• Verify the user account exists in the users collection
• Check that the email is confirmed (or disable email verification in admin settings)
• Reset the password via the admin UI

Participant link not working

• Verify the token matches the session_users record
• Check the session is active and not expired
• Ensure the frontend can reach the backend API

Data not saving

• Check browser console for API errors
• Verify VITE_API_URL in web/.env points to the correct backend URL
• Check PocketBase collection rules allow writes

Fejlfinding

Kan ikke tilgå adminpanelet

• Verificer at backend kører: go run main.go serve
• Tjek at porten er korrekt (standard: 8090 for udvikling, 8080 for Docker)
• Sørg for at ingen firewall blokerer porten
• Tjek serverlogge for fejl

Migrationer mislykkedes

• Slet pb_data/ og genstart for at køre en frisk migration
• Tjek at Go-versionen er 1.21+
• Tjek serverlogge for specifikke fejlmeddelelser

Sessionsleder kan ikke logge ind

• Verificer at brugerkontoen findes i users-samlingen
• Tjek at e-mailen er bekræftet (eller deaktiver e-mailbekræftelse i adminindstillingerne)
• Nulstil adgangskoden via adminpanelet

Deltagerlink virker ikke

• Verificer at token matcher session_users-posten
• Tjek at sessionen er aktiv og ikke udløbet
• Sørg for at frontend kan nå backend-API'en

Data gemmes ikke

• Tjek browserkonsol for API-fejl
• Verificer at VITE_API_URL i web/.env peger på den korrekte backend-URL
• Tjek at PocketBase-samlingsregler tillader skrivning

JSON Schema Reference

Survey questions are defined as FormKit JSON schemas stored in the questions collection. Each schema defines the form structure for one step of the survey.

Schema Format

Each question record in the questions collection has the following structure:

{
  "name": "form_en",      // Unique identifier
  "lang": "en",          // Language code
  "schema": [...]        // FormKit schema array
}

FormKit Schema Documentation

For detailed documentation on the FormKit schema format, see the FormKit Schema Reference. The survey uses FormKit v1 schema format with custom input types.

Source Files

The bundled English and Danish schemas are in web/src/surveys/:

• form_en.json — English survey schema
• form_dk.json — Danish survey schema

These are seeded into the database automatically on first start via the migration at back/migrations/1779593600_seed_questions.go.

JSON-schemareference

Undersøgelsesspørgsmål er defineret som FormKit JSON-skemaer gemt i questions-samlingen. Hvert skema definerer formularstrukturen for ét trin i undersøgelsen.

Skemaformat

Hver spørgsmålspost i questions-samlingen har følgende struktur:

{
  "name": "form_en",      // Unikt id
  "lang": "en",          // Sprogkode
  "schema": [...]        // FormKit-skema-array
}

FormKit-schemadokumentation

For detaljeret dokumentation om FormKit-skemaformatet, se FormKit-schemareference. Undersøgelsen bruger FormKit v1-skemaformat med brugerdefinerede inputtyper.

Kildefiler

De medfølgende engelske og danske skemaer findes i web/src/surveys/:

• form_en.json — Engelsk undersøgelsesskema
• form_dk.json — Dansk undersøgelsesskema

Disse seedes automatisk ind i databasen ved første start via migrationen på back/migrations/1779593600_seed_questions.go.