Add Employee Scheduling Quickstart Demo

.gitignore

@@ -0,0 +1,27 @@
+target
+local
+__pycache__
+.pytest_cache
+/*.egg-info
+/**/dist
+/**/*.egg-info
+/**/*-stubs
+.venv
+
+# Eclipse, Netbeans and IntelliJ files
+/.*
+!/.github
+!/.ci
+!.gitignore
+!.gitattributes
+!/.mvn
+/nbproject
+*.ipr
+*.iws
+*.iml
+
+# Repository wide ignore mac DS_Store files
+.DS_Store
+*.code-workspace
+CLAUDE.md
+DOCUMENTATION_AUDIT.md

Dockerfile

@@ -0,0 +1,24 @@
+# Use Python 3.12 base image
+FROM python:3.12
+
+# Install JDK 21 (required for solverforge-legacy)
+RUN apt-get update && \
+    apt-get install -y wget gnupg2 && \
+    wget -O- https://packages.adoptium.net/artifactory/api/gpg/key/public | gpg --dearmor > /usr/share/keyrings/adoptium-archive-keyring.gpg && \
+    echo "deb [signed-by=/usr/share/keyrings/adoptium-archive-keyring.gpg] https://packages.adoptium.net/artifactory/deb bookworm main" > /etc/apt/sources.list.d/adoptium.list && \
+    apt-get update && \
+    apt-get install -y temurin-21-jdk && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Copy application files
+COPY . .
+
+# Install the application
+RUN pip install --no-cache-dir -e .
+
+# Expose port 8080
+EXPOSE 8080
+
+# Run the application
+CMD ["run-app"]

README.md

@@ -1,12 +1,79 @@
 ---
-title: Employee Scheduling Python
+title: Employee Scheduling (Python)
 emoji: 👀
 colorFrom: gray
 colorTo: green
 sdk: docker
+app_port: 8080
 pinned: false
 license: apache-2.0
 short_description: SolverForge Quickstart for the Employee Scheduling problem
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Employee Scheduling (Python)
+
+Schedule shifts to employees, accounting for employee availability and shift skill requirements.
+
+- [Prerequisites](#prerequisites)
+- [Run the application](#run-the-application)
+- [Test the application](#test-the-application)
+
+## Prerequisites
+
+1. Install [Python 3.11 or 3.12](https://www.python.org/downloads/).
+
+2. Install JDK 17+, for example with [Sdkman](https://sdkman.io):
+
+   ```sh
+   $ sdk install java
+   ```
+
+## Run the application
+
+1. Git clone the solverforge-solver-python repo and navigate to this directory:
+
+   ```sh
+   $ git clone https://github.com/SolverForge/solverforge-quickstarts.git
+   ...
+   $ cd solverforge-quickstarts/employee-scheduling-fast
+   ```
+
+2. Create a virtual environment:
+
+   ```sh
+   $ python -m venv .venv
+   ```
+
+3. Activate the virtual environment:
+
+   ```sh
+   $ . .venv/bin/activate
+   ```
+
+4. Install the application:
+
+   ```sh
+   $ pip install -e .
+   ```
+
+5. Run the application:
+
+   ```sh
+   $ run-app
+   ```
+
+6. Visit [http://localhost:8080](http://localhost:8080) in your browser.
+
+7. Click on the **Solve** button.
+
+## Test the application
+
+1. Run tests:
+
+   ```sh
+   $ pytest
+   ```
+
+## More information
+
+Visit [solverforge.org](https://www.solverforge.org).

deploy/employee-scheduling/Chart.yaml

@@ -0,0 +1,6 @@
+apiVersion: v2
+name: employee-scheduling
+description: A Helm chart for Employee Scheduling application
+type: application
+version: 1.0.1
+appVersion: "1.0.1"

deploy/employee-scheduling/templates/_helpers.tpl

@@ -0,0 +1,49 @@
+{{/*
+Expand the name of the chart.
+*/}}
+{{- define "employee-scheduling.name" -}}
+{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" }}
+{{- end }}
+
+{{/*
+Create a default fully qualified app name.
+*/}}
+{{- define "employee-scheduling.fullname" -}}
+{{- if .Values.fullnameOverride }}
+{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
+{{- else }}
+{{- $name := default .Chart.Name .Values.nameOverride }}
+{{- if contains $name .Release.Name }}
+{{- .Release.Name | trunc 63 | trimSuffix "-" }}
+{{- else }}
+{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
+{{- end }}
+{{- end }}
+{{- end }}
+
+{{/*
+Create chart name and version as used by the chart label.
+*/}}
+{{- define "employee-scheduling.chart" -}}
+{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" }}
+{{- end }}
+
+{{/*
+Common labels
+*/}}
+{{- define "employee-scheduling.labels" -}}
+helm.sh/chart: {{ include "employee-scheduling.chart" . }}
+{{ include "employee-scheduling.selectorLabels" . }}
+{{- if .Chart.AppVersion }}
+app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
+{{- end }}
+app.kubernetes.io/managed-by: {{ .Release.Service }}
+{{- end }}
+
+{{/*
+Selector labels
+*/}}
+{{- define "employee-scheduling.selectorLabels" -}}
+app.kubernetes.io/name: {{ include "employee-scheduling.name" . }}
+app.kubernetes.io/instance: {{ .Release.Name }}
+{{- end }}

deploy/employee-scheduling/templates/deployment.yaml

@@ -0,0 +1,70 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ include "employee-scheduling.fullname" . }}
+  labels:
+    {{- include "employee-scheduling.labels" . | nindent 4 }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  selector:
+    matchLabels:
+      {{- include "employee-scheduling.selectorLabels" . | nindent 6 }}
+  template:
+    metadata:
+      labels:
+        {{- include "employee-scheduling.selectorLabels" . | nindent 8 }}
+      {{- with .Values.podAnnotations }}
+      annotations:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+    spec:
+      {{- if .Values.imagePullSecrets }}
+      imagePullSecrets:
+        {{- toYaml .Values.imagePullSecrets | nindent 8 }}
+      {{- end }}
+      {{- with .Values.podSecurityContext }}
+      securityContext:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      containers:
+        - name: {{ include "employee-scheduling.name" . }}
+          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
+          imagePullPolicy: {{ .Values.image.pullPolicy }}
+          ports:
+            - name: http
+              containerPort: {{ .Values.service.port }}
+              protocol: TCP
+          {{- with .Values.securityContext }}
+          securityContext:
+            {{- toYaml . | nindent 12 }}
+          {{- end }}
+          {{- if .Values.resources }}
+          resources:
+            {{- toYaml .Values.resources | nindent 12 }}
+          {{- end }}
+          livenessProbe:
+            httpGet:
+              path: /
+              port: http
+            initialDelaySeconds: 10
+            periodSeconds: 10
+            failureThreshold: 3
+          readinessProbe:
+            httpGet:
+              path: /
+              port: http
+            initialDelaySeconds: 5
+            periodSeconds: 5
+            failureThreshold: 3
+      {{- if .Values.nodeSelector }}
+      nodeSelector:
+        {{- toYaml .Values.nodeSelector | nindent 8 }}
+      {{- end }}
+      {{- if .Values.tolerations }}
+      tolerations:
+        {{- toYaml .Values.tolerations | nindent 8 }}
+      {{- end }}
+      {{- if .Values.affinity }}
+      affinity:
+        {{- toYaml .Values.affinity | nindent 8 }}
+      {{- end }}

deploy/employee-scheduling/templates/service.yaml

@@ -0,0 +1,18 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ include "employee-scheduling.fullname" . }}
+  labels:
+    {{- include "employee-scheduling.labels" . | nindent 4 }}
+spec:
+  type: {{ .Values.service.type }}
+  ports:
+  - port: {{ .Values.service.port }}
+    targetPort: http
+    protocol: TCP
+    name: http
+    {{- if .Values.service.nodePort }}
+    nodePort: {{ .Values.service.nodePort }}
+    {{- end }}
+  selector:
+    {{- include "employee-scheduling.selectorLabels" . | nindent 4 }}

deploy/employee-scheduling/values.yaml

@@ -0,0 +1,35 @@
+replicaCount: 1
+
+image:
+  repository: employee-scheduling
+  pullPolicy: IfNotPresent
+  tag: "1.0.1"
+
+imagePullSecrets: []
+nameOverride: ""
+fullnameOverride: ""
+
+podAnnotations: {}
+
+podSecurityContext: {}
+
+securityContext: {}
+
+service:
+  type: NodePort
+  port: 8080
+  nodePort: 30081
+
+resources: {}
+
+autoscaling:
+  enabled: false
+  minReplicas: 1
+  maxReplicas: 100
+  targetCPUUtilizationPercentage: 80
+
+nodeSelector: {}
+
+tolerations: []
+
+affinity: {}

logging.conf

@@ -0,0 +1,30 @@
+[loggers]
+keys=root,timefold_solver
+
+[handlers]
+keys=consoleHandler
+
+[formatters]
+keys=simpleFormatter
+
+[logger_root]
+level=INFO
+handlers=consoleHandler
+
+[logger_timefold_solver]
+level=INFO
+qualname=timefold.solver
+handlers=consoleHandler
+propagate=0
+
+[handler_consoleHandler]
+class=StreamHandler
+level=INFO
+formatter=simpleFormatter
+args=(sys.stdout,)
+
+[formatter_simpleFormatter]
+class=uvicorn.logging.ColourizedFormatter
+format={levelprefix:<8} @ {name} : {message}
+style={
+use_colors=True

pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "employee_scheduling"
+version = "1.0.1"
+requires-python = ">=3.10"
+dependencies = [
+    'solverforge-legacy == 1.24.1',
+    'fastapi == 0.111.0',
+    'pydantic == 2.7.3',
+    'uvicorn == 0.30.1',
+    'pytest == 8.2.2',
+]
+
+
+[project.scripts]
+run-app = "employee_scheduling:main"

src/employee_scheduling/__init__.py

@@ -0,0 +1,19 @@
+import uvicorn
+
+from .rest_api import app
+
+
+def main():
+    config = uvicorn.Config(
+        "employee_scheduling:app",
+        host="0.0.0.0",
+        port=8080,
+        log_config="logging.conf",
+        use_colors=True,
+    )
+    server = uvicorn.Server(config)
+    server.run()
+
+
+if __name__ == "__main__":
+    main()

src/employee_scheduling/constraints.py

@@ -0,0 +1,213 @@
+from solverforge_legacy.solver.score import (
+    constraint_provider,
+    ConstraintFactory,
+    Joiners,
+    HardSoftDecimalScore,
+    ConstraintCollectors,
+)
+from datetime import datetime, date
+
+from .domain import Employee, Shift
+
+
+def get_minute_overlap(shift1: Shift, shift2: Shift) -> int:
+    return (
+        min(shift1.end, shift2.end) - max(shift1.start, shift2.start)
+    ).total_seconds() // 60
+
+
+def is_overlapping_with_date(shift: Shift, dt: date) -> bool:
+    return shift.start.date() == dt or shift.end.date() == dt
+
+
+def overlapping_in_minutes(
+    first_start_datetime: datetime,
+    first_end_datetime: datetime,
+    second_start_datetime: datetime,
+    second_end_datetime: datetime,
+) -> int:
+    latest_start = max(first_start_datetime, second_start_datetime)
+    earliest_end = min(first_end_datetime, second_end_datetime)
+    delta = (earliest_end - latest_start).total_seconds() / 60
+    return max(0, delta)
+
+
+def get_shift_overlapping_duration_in_minutes(shift: Shift, dt: date) -> int:
+    overlap = 0
+    start_date_time = datetime.combine(dt, datetime.min.time())
+    end_date_time = datetime.combine(dt, datetime.max.time())
+    overlap += overlapping_in_minutes(
+        start_date_time, end_date_time, shift.start, shift.end
+    )
+    return overlap
+
+
+@constraint_provider
+def define_constraints(constraint_factory: ConstraintFactory):
+    return [
+        # Hard constraints
+        required_skill(constraint_factory),
+        no_overlapping_shifts(constraint_factory),
+        at_least_10_hours_between_two_shifts(constraint_factory),
+        one_shift_per_day(constraint_factory),
+        unavailable_employee(constraint_factory),
+        max_shifts_per_employee(constraint_factory),
+        # Soft constraints
+        undesired_day_for_employee(constraint_factory),
+        desired_day_for_employee(constraint_factory),
+        balance_employee_shift_assignments(constraint_factory),
+    ]
+
+
+def required_skill(constraint_factory: ConstraintFactory):
+    return (
+        constraint_factory.for_each(Shift)
+        .filter(lambda shift: not shift.has_required_skill())
+        .penalize(HardSoftDecimalScore.ONE_HARD)
+        .as_constraint("Missing required skill")
+    )
+
+
+def no_overlapping_shifts(constraint_factory: ConstraintFactory):
+    return (
+        constraint_factory.for_each_unique_pair(
+            Shift,
+            Joiners.equal(lambda shift: shift.employee.name),
+            Joiners.overlapping(lambda shift: shift.start, lambda shift: shift.end),
+        )
+        .penalize(HardSoftDecimalScore.ONE_HARD, get_minute_overlap)
+        .as_constraint("Overlapping shift")
+    )
+
+
+def at_least_10_hours_between_two_shifts(constraint_factory: ConstraintFactory):
+    return (
+        constraint_factory.for_each(Shift)
+        .join(
+            Shift,
+            Joiners.equal(lambda shift: shift.employee.name),
+            Joiners.less_than_or_equal(
+                lambda shift: shift.end, lambda shift: shift.start
+            ),
+        )
+        .filter(
+            lambda first_shift, second_shift: (
+                second_shift.start - first_shift.end
+            ).total_seconds()
+            // (60 * 60)
+            < 10
+        )
+        .penalize(
+            HardSoftDecimalScore.ONE_HARD,
+            lambda first_shift, second_shift: 600
+            - ((second_shift.start - first_shift.end).total_seconds() // 60),
+        )
+        .as_constraint("At least 10 hours between 2 shifts")
+    )
+
+
+def one_shift_per_day(constraint_factory: ConstraintFactory):
+    return (
+        constraint_factory.for_each_unique_pair(
+            Shift,
+            Joiners.equal(lambda shift: shift.employee.name),
+            Joiners.equal(lambda shift: shift.start.date()),
+        )
+        .penalize(HardSoftDecimalScore.ONE_HARD)
+        .as_constraint("Max one shift per day")
+    )
+
+
+def unavailable_employee(constraint_factory: ConstraintFactory):
+    return (
+        constraint_factory.for_each(Shift)
+        .join(
+            Employee,
+            Joiners.equal(lambda shift: shift.employee, lambda employee: employee),
+        )
+        .flatten_last(lambda employee: employee.unavailable_dates)
+        .filter(lambda shift, unavailable_date: shift.is_overlapping_with_date(unavailable_date))
+        .penalize(
+            HardSoftDecimalScore.ONE_HARD,
+            lambda shift, unavailable_date: shift.get_overlapping_duration_in_minutes(unavailable_date),
+        )
+        .as_constraint("Unavailable employee")
+    )
+
+
+def max_shifts_per_employee(constraint_factory: ConstraintFactory):
+    """
+    Hard constraint: No employee can have more than 12 shifts.
+
+    The limit of 12 is chosen based on the demo data dimensions:
+    - SMALL dataset: 139 shifts / 15 employees = ~9.3 average
+    - This provides headroom while preventing extreme imbalance
+
+    Note: A limit that's too low (e.g., 5) would make the problem infeasible.
+    Always ensure your constraints are compatible with your data dimensions.
+    """
+    return (
+        constraint_factory.for_each(Shift)
+        .group_by(lambda shift: shift.employee, ConstraintCollectors.count())
+        .filter(lambda employee, shift_count: shift_count > 12)
+        .penalize(
+            HardSoftDecimalScore.ONE_HARD,
+            lambda employee, shift_count: shift_count - 12,
+        )
+        .as_constraint("Max 12 shifts per employee")
+    )
+
+
+def undesired_day_for_employee(constraint_factory: ConstraintFactory):
+    return (
+        constraint_factory.for_each(Shift)
+        .join(
+            Employee,
+            Joiners.equal(lambda shift: shift.employee, lambda employee: employee),
+        )
+        .flatten_last(lambda employee: employee.undesired_dates)
+        .filter(lambda shift, undesired_date: shift.is_overlapping_with_date(undesired_date))
+        .penalize(
+            HardSoftDecimalScore.ONE_SOFT,
+            lambda shift, undesired_date: shift.get_overlapping_duration_in_minutes(undesired_date),
+        )
+        .as_constraint("Undesired day for employee")
+    )
+
+
+def desired_day_for_employee(constraint_factory: ConstraintFactory):
+    return (
+        constraint_factory.for_each(Shift)
+        .join(
+            Employee,
+            Joiners.equal(lambda shift: shift.employee, lambda employee: employee),
+        )
+        .flatten_last(lambda employee: employee.desired_dates)
+        .filter(lambda shift, desired_date: shift.is_overlapping_with_date(desired_date))
+        .reward(
+            HardSoftDecimalScore.ONE_SOFT,
+            lambda shift, desired_date: shift.get_overlapping_duration_in_minutes(desired_date),
+        )
+        .as_constraint("Desired day for employee")
+    )
+
+
+def balance_employee_shift_assignments(constraint_factory: ConstraintFactory):
+    return (
+        constraint_factory.for_each(Shift)
+        .group_by(lambda shift: shift.employee, ConstraintCollectors.count())
+        .complement(
+            Employee, lambda e: 0
+        )  # Include all employees which are not assigned to any shift.
+        .group_by(
+            ConstraintCollectors.load_balance(
+                lambda employee, shift_count: employee,
+                lambda employee, shift_count: shift_count,
+            )
+        )
+        .penalize_decimal(
+            HardSoftDecimalScore.ONE_SOFT,
+            lambda load_balance: load_balance.unfairness(),
+        )
+        .as_constraint("Balance employee shift assignments")
+    )

src/employee_scheduling/converters.py

@@ -0,0 +1,95 @@
+from typing import List, Optional, Union
+from datetime import datetime, date
+from . import domain
+from .json_serialization import JsonDomainBase
+from pydantic import Field
+
+
+# Conversion functions from domain to API models
+def employee_to_model(employee: domain.Employee) -> domain.EmployeeModel:
+    return domain.EmployeeModel(
+        name=employee.name,
+        skills=list(employee.skills),
+        unavailable_dates=[d.isoformat() for d in employee.unavailable_dates],
+        undesired_dates=[d.isoformat() for d in employee.undesired_dates],
+        desired_dates=[d.isoformat() for d in employee.desired_dates],
+    )
+
+
+def shift_to_model(shift: domain.Shift) -> domain.ShiftModel:
+    return domain.ShiftModel(
+        id=shift.id,
+        start=shift.start.isoformat(),
+        end=shift.end.isoformat(),
+        location=shift.location,
+        required_skill=shift.required_skill,
+        employee=employee_to_model(shift.employee) if shift.employee else None,
+    )
+
+
+def schedule_to_model(
+    schedule: domain.EmployeeSchedule,
+) -> domain.EmployeeScheduleModel:
+    return domain.EmployeeScheduleModel(
+        employees=[employee_to_model(e) for e in schedule.employees],
+        shifts=[shift_to_model(s) for s in schedule.shifts],
+        score=str(schedule.score) if schedule.score else None,
+        solver_status=schedule.solver_status.name if schedule.solver_status else None,
+    )
+
+
+# Conversion functions from API models to domain
+def model_to_employee(model: domain.EmployeeModel) -> domain.Employee:
+    return domain.Employee(
+        name=model.name,
+        skills=set(model.skills),
+        unavailable_dates={date.fromisoformat(d) for d in model.unavailable_dates},
+        undesired_dates={date.fromisoformat(d) for d in model.undesired_dates},
+        desired_dates={date.fromisoformat(d) for d in model.desired_dates},
+    )
+
+
+def model_to_shift(model: domain.ShiftModel, employee_lookup: dict) -> domain.Shift:
+    # Handle employee reference
+    employee = None
+    if model.employee:
+        if isinstance(model.employee, str):
+            employee = employee_lookup[model.employee]
+        else:
+            employee = model_to_employee(model.employee)
+
+    return domain.Shift(
+        id=model.id,
+        start=datetime.fromisoformat(model.start),
+        end=datetime.fromisoformat(model.end),
+        location=model.location,
+        required_skill=model.required_skill,
+        employee=employee,
+    )
+
+
+def model_to_schedule(model: domain.EmployeeScheduleModel) -> domain.EmployeeSchedule:
+    # Convert employees first
+    employees = [model_to_employee(e) for e in model.employees]
+
+    # Create lookup dictionary for employee references
+    employee_lookup = {e.name: e for e in employees}
+
+    # Convert shifts with employee lookups
+    shifts = [model_to_shift(s, employee_lookup) for s in model.shifts]
+
+    # Handle score
+    score = None
+    if model.score:
+        from solverforge_legacy.solver.score import HardSoftDecimalScore
+
+        score = HardSoftDecimalScore.parse(model.score)
+
+    # Handle solver status
+    solver_status = domain.SolverStatus.NOT_SOLVING
+    if model.solver_status:
+        solver_status = domain.SolverStatus[model.solver_status]
+
+    return domain.EmployeeSchedule(
+        employees=employees, shifts=shifts, score=score, solver_status=solver_status
+    )

src/employee_scheduling/demo_data.py

@@ -0,0 +1,228 @@
+from datetime import date, datetime, time, timedelta
+from itertools import product
+from enum import Enum
+from random import Random
+from typing import Generator
+from dataclasses import dataclass, field
+
+from .domain import *
+
+
+class DemoData(Enum):
+    SMALL = 'SMALL'
+    LARGE = 'LARGE'
+
+
+@dataclass(frozen=True, kw_only=True)
+class CountDistribution:
+    count: int
+    weight: float
+
+
+def counts(distributions: tuple[CountDistribution, ...]) -> tuple[int, ...]:
+    return tuple(distribution.count for distribution in distributions)
+
+
+def weights(distributions: tuple[CountDistribution, ...]) -> tuple[float, ...]:
+    return tuple(distribution.weight for distribution in distributions)
+
+
+@dataclass(kw_only=True)
+class DemoDataParameters:
+    locations: tuple[str, ...]
+    required_skills: tuple[str, ...]
+    optional_skills: tuple[str, ...]
+    days_in_schedule: int
+    employee_count: int
+    optional_skill_distribution: tuple[CountDistribution, ...]
+    shift_count_distribution: tuple[CountDistribution, ...]
+    availability_count_distribution: tuple[CountDistribution, ...]
+    random_seed: int = field(default=37)
+
+
+demo_data_to_parameters: dict[DemoData, DemoDataParameters] = {
+    DemoData.SMALL: DemoDataParameters(
+        locations=("Ambulatory care", "Critical care", "Pediatric care"),
+        required_skills=("Doctor", "Nurse"),
+        optional_skills=("Anaesthetics", "Cardiology"),
+        days_in_schedule=14,
+        employee_count=15,
+        optional_skill_distribution=(
+            CountDistribution(count=1, weight=3),
+            CountDistribution(count=2, weight=1)
+        ),
+        shift_count_distribution=(
+            CountDistribution(count=1, weight=0.9),
+            CountDistribution(count=2, weight=0.1)
+        ),
+        availability_count_distribution=(
+            CountDistribution(count=1, weight=4),
+            CountDistribution(count=2, weight=3),
+            CountDistribution(count=3, weight=2),
+            CountDistribution(count=4, weight=1)
+        ),
+        random_seed=37
+    ),
+
+    DemoData.LARGE: DemoDataParameters(
+        locations=("Ambulatory care",
+                   "Neurology",
+                   "Critical care",
+                   "Pediatric care",
+                   "Surgery",
+                   "Radiology",
+                   "Outpatient"),
+        required_skills=("Doctor", "Nurse"),
+        optional_skills=("Anaesthetics", "Cardiology", "Radiology"),
+        days_in_schedule=28,
+        employee_count=50,
+        optional_skill_distribution=(
+            CountDistribution(count=1, weight=3),
+            CountDistribution(count=2, weight=1)
+        ),
+        shift_count_distribution=(
+            CountDistribution(count=1, weight=0.5),
+            CountDistribution(count=2, weight=0.3),
+            CountDistribution(count=3, weight=0.2)
+        ),
+        availability_count_distribution=(
+            CountDistribution(count=5, weight=4),
+            CountDistribution(count=10, weight=3),
+            CountDistribution(count=15, weight=2),
+            CountDistribution(count=20, weight=1)
+        ),
+        random_seed=37
+    )
+}
+
+
+FIRST_NAMES = ("Amy", "Beth", "Carl", "Dan", "Elsa", "Flo", "Gus", "Hugo", "Ivy", "Jay")
+LAST_NAMES = ("Cole", "Fox", "Green", "Jones", "King", "Li", "Poe", "Rye", "Smith", "Watt")
+SHIFT_LENGTH = timedelta(hours=8)
+MORNING_SHIFT_START_TIME = time(hour=6, minute=0)
+DAY_SHIFT_START_TIME = time(hour=9, minute=0)
+AFTERNOON_SHIFT_START_TIME = time(hour=14, minute=0)
+NIGHT_SHIFT_START_TIME = time(hour=22, minute=0)
+
+SHIFT_START_TIMES_COMBOS = (
+    (MORNING_SHIFT_START_TIME, AFTERNOON_SHIFT_START_TIME),
+    (MORNING_SHIFT_START_TIME, AFTERNOON_SHIFT_START_TIME, NIGHT_SHIFT_START_TIME),
+    (MORNING_SHIFT_START_TIME, DAY_SHIFT_START_TIME, AFTERNOON_SHIFT_START_TIME, NIGHT_SHIFT_START_TIME),
+)
+
+
+location_to_shift_start_time_list_map = dict()
+
+
+def earliest_monday_on_or_after(target_date: date):
+    """
+    Returns the date of the next given weekday after
+    the given date. For example, the date of next Monday.
+
+    NB: if it IS the day we're looking for, this returns 0.
+    consider then doing onDay(foo, day + 1).
+    """
+    days = (7 - target_date.weekday()) % 7
+    return target_date + timedelta(days=days)
+
+
+def generate_demo_data(demo_data_or_parameters: DemoData | DemoDataParameters) -> EmployeeSchedule:
+    global location_to_shift_start_time_list_map, demo_data_to_parameters
+    if isinstance(demo_data_or_parameters, DemoData):
+        parameters = demo_data_to_parameters[demo_data_or_parameters]
+    else:
+        parameters = demo_data_or_parameters
+
+    start_date = earliest_monday_on_or_after(date.today())
+    random = Random(parameters.random_seed)
+    shift_template_index = 0
+    for location in parameters.locations:
+        location_to_shift_start_time_list_map[location] = SHIFT_START_TIMES_COMBOS[shift_template_index]
+        shift_template_index = (shift_template_index + 1) % len(SHIFT_START_TIMES_COMBOS)
+
+    name_permutations = [f'{first_name} {last_name}'
+                         for first_name, last_name in product(FIRST_NAMES, LAST_NAMES)]
+    random.shuffle(name_permutations)
+
+    employees = []
+    for i in range(parameters.employee_count):
+        count, = random.choices(population=counts(parameters.optional_skill_distribution),
+                                weights=weights(parameters.optional_skill_distribution))
+        skills = []
+        skills += random.sample(parameters.optional_skills, count)
+        skills += random.sample(parameters.required_skills, 1)
+        employees.append(
+            Employee(name=name_permutations[i],
+                     skills=set(skills))
+        )
+
+    shifts: list[Shift] = []
+
+    def id_generator():
+        current_id = 0
+        while True:
+            yield str(current_id)
+            current_id += 1
+
+    ids = id_generator()
+
+    for i in range(parameters.days_in_schedule):
+        count, = random.choices(population=counts(parameters.availability_count_distribution),
+                                weights=weights(parameters.availability_count_distribution))
+        employees_with_availabilities_on_day = random.sample(employees, count)
+        current_date = start_date + timedelta(days=i)
+        for employee in employees_with_availabilities_on_day:
+            rand_num = random.randint(0, 2)
+            if rand_num == 0:
+                employee.unavailable_dates.add(current_date)
+            elif rand_num == 1:
+                employee.undesired_dates.add(current_date)
+            elif rand_num == 2:
+                employee.desired_dates.add(current_date)
+        shifts += generate_shifts_for_day(parameters, current_date, random, ids)
+
+    shift_count = 0
+    for shift in shifts:
+        shift.id = str(shift_count)
+        shift_count += 1
+
+    return EmployeeSchedule(
+        employees=employees,
+        shifts=shifts
+    )
+
+
+def generate_shifts_for_day(parameters: DemoDataParameters, current_date: date, random: Random,
+                            ids: Generator[str, any, any]) -> list[Shift]:
+    global location_to_shift_start_time_list_map
+    shifts = []
+    for location in parameters.locations:
+        shift_start_times = location_to_shift_start_time_list_map[location]
+        for start_time in shift_start_times:
+            shift_start_date_time = datetime.combine(current_date, start_time)
+            shift_end_date_time = shift_start_date_time + SHIFT_LENGTH
+            shifts += generate_shifts_for_timeslot(parameters, shift_start_date_time, shift_end_date_time,
+                                                   location, random, ids)
+
+    return shifts
+
+
+def generate_shifts_for_timeslot(parameters: DemoDataParameters, timeslot_start: datetime, timeslot_end: datetime,
+                                 location: str, random: Random, ids: Generator[str, any, any]) -> list[Shift]:
+    shift_count, = random.choices(population=counts(parameters.shift_count_distribution),
+                                  weights=weights(parameters.shift_count_distribution))
+
+    shifts = []
+    for i in range(shift_count):
+        if random.random() >= 0.5:
+            required_skill = random.choice(parameters.required_skills)
+        else:
+            required_skill = random.choice(parameters.optional_skills)
+        shifts.append(Shift(
+            id=next(ids),
+            start=timeslot_start,
+            end=timeslot_end,
+            location=location,
+            required_skill=required_skill))
+
+    return shifts

src/employee_scheduling/domain.py

@@ -0,0 +1,95 @@
+from solverforge_legacy.solver import SolverStatus
+from solverforge_legacy.solver.domain import (
+    planning_entity,
+    planning_solution,
+    PlanningId,
+    PlanningVariable,
+    PlanningEntityCollectionProperty,
+    ProblemFactCollectionProperty,
+    ValueRangeProvider,
+    PlanningScore,
+)
+from solverforge_legacy.solver.score import HardSoftDecimalScore
+from datetime import datetime, date
+from typing import Annotated, List, Optional, Union
+from dataclasses import dataclass, field
+from .json_serialization import JsonDomainBase
+from pydantic import Field
+
+
+@dataclass
+class Employee:
+    name: Annotated[str, PlanningId]
+    skills: set[str] = field(default_factory=set)
+    unavailable_dates: set[date] = field(default_factory=set)
+    undesired_dates: set[date] = field(default_factory=set)
+    desired_dates: set[date] = field(default_factory=set)
+
+
+@planning_entity
+@dataclass
+class Shift:
+    id: Annotated[str, PlanningId]
+    start: datetime
+    end: datetime
+    location: str
+    required_skill: str
+    employee: Annotated[Employee | None, PlanningVariable] = None
+
+    def has_required_skill(self) -> bool:
+        """Check if assigned employee has the required skill."""
+        if self.employee is None:
+            return False
+        return self.required_skill in self.employee.skills
+
+    def is_overlapping_with_date(self, dt: date) -> bool:
+        """Check if shift overlaps with a specific date."""
+        return self.start.date() == dt or self.end.date() == dt
+
+    def get_overlapping_duration_in_minutes(self, dt: date) -> int:
+        """Calculate overlap duration in minutes for a specific date."""
+        start_date_time = datetime.combine(dt, datetime.min.time())
+        end_date_time = datetime.combine(dt, datetime.max.time())
+
+        # Calculate overlap between date range and shift range
+        max_start_time = max(start_date_time, self.start)
+        min_end_time = min(end_date_time, self.end)
+
+        minutes = (min_end_time - max_start_time).total_seconds() / 60
+        return int(max(0, minutes))
+
+
+@planning_solution
+@dataclass
+class EmployeeSchedule:
+    employees: Annotated[
+        list[Employee], ProblemFactCollectionProperty, ValueRangeProvider
+    ]
+    shifts: Annotated[list[Shift], PlanningEntityCollectionProperty]
+    score: Annotated[HardSoftDecimalScore | None, PlanningScore] = None
+    solver_status: SolverStatus = SolverStatus.NOT_SOLVING
+
+
+# Pydantic REST models for API (used for deserialization and context)
+class EmployeeModel(JsonDomainBase):
+    name: str
+    skills: List[str] = Field(default_factory=list)
+    unavailable_dates: List[str] = Field(default_factory=list, alias="unavailableDates")
+    undesired_dates: List[str] = Field(default_factory=list, alias="undesiredDates")
+    desired_dates: List[str] = Field(default_factory=list, alias="desiredDates")
+
+
+class ShiftModel(JsonDomainBase):
+    id: str
+    start: str  # ISO datetime string
+    end: str  # ISO datetime string
+    location: str
+    required_skill: str = Field(..., alias="requiredSkill")
+    employee: Union[str, EmployeeModel, None] = None
+
+
+class EmployeeScheduleModel(JsonDomainBase):
+    employees: List[EmployeeModel]
+    shifts: List[ShiftModel]
+    score: Optional[str] = None
+    solver_status: Optional[str] = None

src/employee_scheduling/json_serialization.py

@@ -0,0 +1,27 @@
+from solverforge_legacy.solver.score import HardSoftDecimalScore
+from typing import Any
+from pydantic import BaseModel, ConfigDict, PlainSerializer, BeforeValidator
+from pydantic.alias_generators import to_camel
+
+ScoreSerializer = PlainSerializer(
+    lambda score: str(score) if score is not None else None, return_type=str | None
+)
+
+
+def validate_score(v: Any) -> Any:
+    if isinstance(v, HardSoftDecimalScore) or v is None:
+        return v
+    if isinstance(v, str):
+        return HardSoftDecimalScore.parse(v)
+    raise ValueError('"score" should be a string')
+
+
+ScoreValidator = BeforeValidator(validate_score)
+
+
+class JsonDomainBase(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )

src/employee_scheduling/rest_api.py

@@ -0,0 +1,56 @@
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from uuid import uuid4
+from dataclasses import replace
+
+from .domain import EmployeeSchedule, EmployeeScheduleModel
+from .converters import (
+    schedule_to_model, model_to_schedule
+)
+from .demo_data import DemoData, generate_demo_data
+from .solver import solver_manager, solution_manager
+
+app = FastAPI(docs_url='/q/swagger-ui')
+data_sets: dict[str, EmployeeSchedule] = {}
+
+
+@app.get("/demo-data")
+async def demo_data_list() -> list[DemoData]:
+    return [e for e in DemoData]
+
+
+@app.get("/demo-data/{dataset_id}", response_model_exclude_none=True)
+async def get_demo_data(dataset_id: str) -> EmployeeScheduleModel:
+    demo_data = getattr(DemoData, dataset_id)
+    domain_schedule = generate_demo_data(demo_data)
+    return schedule_to_model(domain_schedule)
+
+
+@app.get("/schedules/{problem_id}", response_model_exclude_none=True)
+async def get_timetable(problem_id: str) -> EmployeeScheduleModel:
+    schedule = data_sets[problem_id]
+    updated_schedule = replace(schedule, solver_status=solver_manager.get_solver_status(problem_id))
+    return schedule_to_model(updated_schedule)
+
+
+def update_schedule(problem_id: str, schedule: EmployeeSchedule):
+    global data_sets
+    data_sets[problem_id] = schedule
+
+
+@app.post("/schedules")
+async def solve_timetable(schedule_model: EmployeeScheduleModel) -> str:
+    job_id = str(uuid4())
+    schedule = model_to_schedule(schedule_model)
+    data_sets[job_id] = schedule
+    solver_manager.solve_and_listen(job_id, schedule,
+                                    lambda solution: update_schedule(job_id, solution))
+    return job_id
+
+
+@app.delete("/schedules/{problem_id}")
+async def stop_solving(problem_id: str) -> None:
+    solver_manager.terminate_early(problem_id)
+
+
+app.mount("/", StaticFiles(directory="static", html=True), name="static")

src/employee_scheduling/solver.py

@@ -0,0 +1,23 @@
+from solverforge_legacy.solver import SolverManager, SolverFactory, SolutionManager
+from solverforge_legacy.solver.config import (
+    SolverConfig,
+    ScoreDirectorFactoryConfig,
+    TerminationConfig,
+    Duration,
+)
+
+from .domain import EmployeeSchedule, Shift
+from .constraints import define_constraints
+
+
+solver_config = SolverConfig(
+    solution_class=EmployeeSchedule,
+    entity_class_list=[Shift],
+    score_director_factory_config=ScoreDirectorFactoryConfig(
+        constraint_provider_function=define_constraints
+    ),
+    termination_config=TerminationConfig(spent_limit=Duration(seconds=30)),
+)
+
+solver_manager = SolverManager.create(SolverFactory.create(solver_config))
+solution_manager = SolutionManager.create(solver_manager)

static/app.js

@@ -0,0 +1,520 @@
+let autoRefreshIntervalId = null;
+const zoomMin = 2 * 1000 * 60 * 60 * 24 // 2 day in milliseconds
+const zoomMax = 4 * 7 * 1000 * 60 * 60 * 24 // 4 weeks in milliseconds
+
+const UNAVAILABLE_COLOR = '#ef2929' // Tango Scarlet Red
+const UNDESIRED_COLOR = '#f57900' // Tango Orange
+const DESIRED_COLOR = '#73d216' // Tango Chameleon
+
+let demoDataId = null;
+let scheduleId = null;
+let loadedSchedule = null;
+
+const byEmployeePanel = document.getElementById("byEmployeePanel");
+const byEmployeeTimelineOptions = {
+    timeAxis: {scale: "hour", step: 6},
+    orientation: {axis: "top"},
+    stack: false,
+    xss: {disabled: true}, // Items are XSS safe through JQuery
+    zoomMin: zoomMin,
+    zoomMax: zoomMax,
+};
+let byEmployeeGroupDataSet = new vis.DataSet();
+let byEmployeeItemDataSet = new vis.DataSet();
+let byEmployeeTimeline = new vis.Timeline(byEmployeePanel, byEmployeeItemDataSet, byEmployeeGroupDataSet, byEmployeeTimelineOptions);
+
+const byLocationPanel = document.getElementById("byLocationPanel");
+const byLocationTimelineOptions = {
+    timeAxis: {scale: "hour", step: 6},
+    orientation: {axis: "top"},
+    xss: {disabled: true}, // Items are XSS safe through JQuery
+    zoomMin: zoomMin,
+    zoomMax: zoomMax,
+};
+let byLocationGroupDataSet = new vis.DataSet();
+let byLocationItemDataSet = new vis.DataSet();
+let byLocationTimeline = new vis.Timeline(byLocationPanel, byLocationItemDataSet, byLocationGroupDataSet, byLocationTimelineOptions);
+
+let windowStart = JSJoda.LocalDate.now().toString();
+let windowEnd = JSJoda.LocalDate.parse(windowStart).plusDays(7).toString();
+
+$(document).ready(function () {
+    let initialized = false;
+
+    function safeInitialize() {
+        if (!initialized) {
+            initialized = true;
+            initializeApp();
+        }
+    }
+
+    // Ensure all resources are loaded before initializing
+    $(window).on('load', safeInitialize);
+
+    // Fallback if window load event doesn't fire
+    setTimeout(safeInitialize, 100);
+});
+
+function initializeApp() {
+    replaceQuickstartSolverForgeAutoHeaderFooter();
+
+    $("#solveButton").click(function () {
+        solve();
+    });
+    $("#stopSolvingButton").click(function () {
+        stopSolving();
+    });
+    $("#analyzeButton").click(function () {
+        analyze();
+    });
+    // HACK to allow vis-timeline to work within Bootstrap tabs
+    $("#byEmployeeTab").on('shown.bs.tab', function (event) {
+        byEmployeeTimeline.redraw();
+    })
+    $("#byLocationTab").on('shown.bs.tab', function (event) {
+        byLocationTimeline.redraw();
+    })
+
+    setupAjax();
+    fetchDemoData();
+}
+
+function setupAjax() {
+    $.ajaxSetup({
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json,text/plain', // plain text is required by solve() returning UUID of the solver job
+        }
+    });
+    // Extend jQuery to support $.put() and $.delete()
+    jQuery.each(["put", "delete"], function (i, method) {
+        jQuery[method] = function (url, data, callback, type) {
+            if (jQuery.isFunction(data)) {
+                type = type || callback;
+                callback = data;
+                data = undefined;
+            }
+            return jQuery.ajax({
+                url: url,
+                type: method,
+                dataType: type,
+                data: data,
+                success: callback
+            });
+        };
+    });
+}
+
+function fetchDemoData() {
+    $.get("/demo-data", function (data) {
+        data.forEach(item => {
+            $("#testDataButton").append($('<a id="' + item + 'TestData" class="dropdown-item" href="#">' + item + '</a>'));
+            $("#" + item + "TestData").click(function () {
+                switchDataDropDownItemActive(item);
+                scheduleId = null;
+                demoDataId = item;
+
+                refreshSchedule();
+            });
+        });
+        demoDataId = data[0];
+        switchDataDropDownItemActive(demoDataId);
+        refreshSchedule();
+    }).fail(function (xhr, ajaxOptions, thrownError) {
+        // disable this page as there is no data
+        let $demo = $("#demo");
+        $demo.empty();
+        $demo.html("<h1><p align=\"center\">No test data available</p></h1>")
+    });
+}
+
+function switchDataDropDownItemActive(newItem) {
+    activeCssClass = "active";
+    $("#testDataButton > a." + activeCssClass).removeClass(activeCssClass);
+    $("#" + newItem + "TestData").addClass(activeCssClass);
+}
+
+function getShiftColor(shift, employee) {
+    const shiftStart = JSJoda.LocalDateTime.parse(shift.start);
+    const shiftStartDateString = shiftStart.toLocalDate().toString();
+    const shiftEnd = JSJoda.LocalDateTime.parse(shift.end);
+    const shiftEndDateString = shiftEnd.toLocalDate().toString();
+    if (employee.unavailableDates.includes(shiftStartDateString) ||
+        // The contains() check is ignored for a shift end at midnight (00:00:00).
+        (shiftEnd.isAfter(shiftStart.toLocalDate().plusDays(1).atStartOfDay()) &&
+            employee.unavailableDates.includes(shiftEndDateString))) {
+        return UNAVAILABLE_COLOR
+    } else if (employee.undesiredDates.includes(shiftStartDateString) ||
+        // The contains() check is ignored for a shift end at midnight (00:00:00).
+        (shiftEnd.isAfter(shiftStart.toLocalDate().plusDays(1).atStartOfDay()) &&
+            employee.undesiredDates.includes(shiftEndDateString))) {
+        return UNDESIRED_COLOR
+    } else if (employee.desiredDates.includes(shiftStartDateString) ||
+        // The contains() check is ignored for a shift end at midnight (00:00:00).
+        (shiftEnd.isAfter(shiftStart.toLocalDate().plusDays(1).atStartOfDay()) &&
+            employee.desiredDates.includes(shiftEndDateString))) {
+        return DESIRED_COLOR
+    } else {
+        return " #729fcf"; // Tango Sky Blue
+    }
+}
+
+function refreshSchedule() {
+    let path = "/schedules/" + scheduleId;
+    if (scheduleId === null) {
+        if (demoDataId === null) {
+            alert("Please select a test data set.");
+            return;
+        }
+
+        path = "/demo-data/" + demoDataId;
+    }
+    $.getJSON(path, function (schedule) {
+        loadedSchedule = schedule;
+        renderSchedule(schedule);
+    })
+        .fail(function (xhr, ajaxOptions, thrownError) {
+            showError("Getting the schedule has failed.", xhr);
+            refreshSolvingButtons(false);
+        });
+}
+
+function renderSchedule(schedule) {
+    console.log('Rendering schedule:', schedule);
+    
+    if (!schedule) {
+        console.error('No schedule data provided to renderSchedule');
+        return;
+    }
+    
+    refreshSolvingButtons(schedule.solverStatus != null && schedule.solverStatus !== "NOT_SOLVING");
+    $("#score").text("Score: " + (schedule.score == null ? "?" : schedule.score));
+
+    const unassignedShifts = $("#unassignedShifts");
+    const groups = [];
+
+    // Check if schedule.shifts exists and is an array
+    if (!schedule.shifts || !Array.isArray(schedule.shifts) || schedule.shifts.length === 0) {
+        console.warn('No shifts data available in schedule');
+        return;
+    }
+
+    // Show only first 7 days of draft
+    const scheduleStart = schedule.shifts.map(shift => JSJoda.LocalDateTime.parse(shift.start).toLocalDate()).sort()[0].toString();
+    const scheduleEnd = JSJoda.LocalDate.parse(scheduleStart).plusDays(7).toString();
+
+    windowStart = scheduleStart;
+    windowEnd = scheduleEnd;
+
+    unassignedShifts.children().remove();
+    let unassignedShiftsCount = 0;
+    byEmployeeGroupDataSet.clear();
+    byLocationGroupDataSet.clear();
+
+    byEmployeeItemDataSet.clear();
+    byLocationItemDataSet.clear();
+
+    // Check if schedule.employees exists and is an array
+    if (!schedule.employees || !Array.isArray(schedule.employees)) {
+        console.warn('No employees data available in schedule');
+        return;
+    }
+
+    schedule.employees.forEach((employee, index) => {
+        const employeeGroupElement = $('<div class="card-body p-2"/>')
+            .append($(`<h5 class="card-title mb-2"/>)`)
+                .append(employee.name))
+            .append($('<div/>')
+                .append($(employee.skills.map(skill => `<span class="badge me-1 mt-1" style="background-color:#d3d7cf">${skill}</span>`).join(''))));
+        byEmployeeGroupDataSet.add({id: employee.name, content: employeeGroupElement.html()});
+
+        employee.unavailableDates.forEach((rawDate, dateIndex) => {
+            const date = JSJoda.LocalDate.parse(rawDate)
+            const start = date.atStartOfDay().toString();
+            const end = date.plusDays(1).atStartOfDay().toString();
+            const byEmployeeShiftElement = $(`<div/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text("Unavailable"));
+            byEmployeeItemDataSet.add({
+                id: "employee-" + index + "-unavailability-" + dateIndex, group: employee.name,
+                content: byEmployeeShiftElement.html(),
+                start: start, end: end,
+                type: "background",
+                style: "opacity: 0.5; background-color: " + UNAVAILABLE_COLOR,
+            });
+        });
+        employee.undesiredDates.forEach((rawDate, dateIndex) => {
+            const date = JSJoda.LocalDate.parse(rawDate)
+            const start = date.atStartOfDay().toString();
+            const end = date.plusDays(1).atStartOfDay().toString();
+            const byEmployeeShiftElement = $(`<div/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text("Undesired"));
+            byEmployeeItemDataSet.add({
+                id: "employee-" + index + "-undesired-" + dateIndex, group: employee.name,
+                content: byEmployeeShiftElement.html(),
+                start: start, end: end,
+                type: "background",
+                style: "opacity: 0.5; background-color: " + UNDESIRED_COLOR,
+            });
+        });
+        employee.desiredDates.forEach((rawDate, dateIndex) => {
+            const date = JSJoda.LocalDate.parse(rawDate)
+            const start = date.atStartOfDay().toString();
+            const end = date.plusDays(1).atStartOfDay().toString();
+            const byEmployeeShiftElement = $(`<div/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text("Desired"));
+            byEmployeeItemDataSet.add({
+                id: "employee-" + index + "-desired-" + dateIndex, group: employee.name,
+                content: byEmployeeShiftElement.html(),
+                start: start, end: end,
+                type: "background",
+                style: "opacity: 0.5; background-color: " + DESIRED_COLOR,
+            });
+        });
+    });
+
+    schedule.shifts.forEach((shift, index) => {
+        if (groups.indexOf(shift.location) === -1) {
+            groups.push(shift.location);
+            byLocationGroupDataSet.add({
+                id: shift.location,
+                content: shift.location,
+            });
+        }
+
+        if (shift.employee == null) {
+            unassignedShiftsCount++;
+
+            const byLocationShiftElement = $('<div class="card-body p-2"/>')
+                .append($(`<h5 class="card-title mb-2"/>)`)
+                    .append("Unassigned"))
+                .append($('<div/>')
+                    .append($(`<span class="badge me-1 mt-1" style="background-color:#d3d7cf">${shift.requiredSkill}</span>`)));
+
+            byLocationItemDataSet.add({
+                id: 'shift-' + index, group: shift.location,
+                content: byLocationShiftElement.html(),
+                start: shift.start, end: shift.end,
+                style: "background-color: #EF292999"
+            });
+        } else {
+            const skillColor = (shift.employee.skills.indexOf(shift.requiredSkill) === -1 ? '#ef2929' : '#8ae234');
+            const byEmployeeShiftElement = $('<div class="card-body p-2"/>')
+                .append($(`<h5 class="card-title mb-2"/>)`)
+                    .append(shift.location))
+                .append($('<div/>')
+                    .append($(`<span class="badge me-1 mt-1" style="background-color:${skillColor}">${shift.requiredSkill}</span>`)));
+            const byLocationShiftElement = $('<div class="card-body p-2"/>')
+                .append($(`<h5 class="card-title mb-2"/>)`)
+                    .append(shift.employee.name))
+                .append($('<div/>')
+                    .append($(`<span class="badge me-1 mt-1" style="background-color:${skillColor}">${shift.requiredSkill}</span>`)));
+
+            const shiftColor = getShiftColor(shift, shift.employee);
+            byEmployeeItemDataSet.add({
+                id: 'shift-' + index, group: shift.employee.name,
+                content: byEmployeeShiftElement.html(),
+                start: shift.start, end: shift.end,
+                style: "background-color: " + shiftColor
+            });
+            byLocationItemDataSet.add({
+                id: 'shift-' + index, group: shift.location,
+                content: byLocationShiftElement.html(),
+                start: shift.start, end: shift.end,
+                style: "background-color: " + shiftColor
+            });
+        }
+    });
+
+
+    if (unassignedShiftsCount === 0) {
+        unassignedShifts.append($(`<p/>`).text(`There are no unassigned shifts.`));
+    } else {
+        unassignedShifts.append($(`<p/>`).text(`There are ${unassignedShiftsCount} unassigned shifts.`));
+    }
+    byEmployeeTimeline.setWindow(scheduleStart, scheduleEnd);
+    byLocationTimeline.setWindow(scheduleStart, scheduleEnd);
+}
+
+function solve() {
+    if (!loadedSchedule) {
+        showError("No schedule data loaded. Please wait for the data to load or refresh the page.");
+        return;
+    }
+    
+    console.log('Sending schedule data for solving:', loadedSchedule);
+    $.post("/schedules", JSON.stringify(loadedSchedule), function (data) {
+        scheduleId = data;
+        refreshSolvingButtons(true);
+    }).fail(function (xhr, ajaxOptions, thrownError) {
+            showError("Start solving failed.", xhr);
+            refreshSolvingButtons(false);
+        },
+        "text");
+}
+
+function analyze() {
+    new bootstrap.Modal("#scoreAnalysisModal").show()
+    const scoreAnalysisModalContent = $("#scoreAnalysisModalContent");
+    scoreAnalysisModalContent.children().remove();
+    if (loadedSchedule.score == null) {
+        scoreAnalysisModalContent.text("No score to analyze yet, please first press the 'solve' button.");
+    } else {
+        $('#scoreAnalysisScoreLabel').text(`(${loadedSchedule.score})`);
+        $.put("/schedules/analyze", JSON.stringify(loadedSchedule), function (scoreAnalysis) {
+            let constraints = scoreAnalysis.constraints;
+            constraints.sort((a, b) => {
+                let aComponents = getScoreComponents(a.score), bComponents = getScoreComponents(b.score);
+                if (aComponents.hard < 0 && bComponents.hard > 0) return -1;
+                if (aComponents.hard > 0 && bComponents.soft < 0) return 1;
+                if (Math.abs(aComponents.hard) > Math.abs(bComponents.hard)) {
+                    return -1;
+                } else {
+                    if (aComponents.medium < 0 && bComponents.medium > 0) return -1;
+                    if (aComponents.medium > 0 && bComponents.medium < 0) return 1;
+                    if (Math.abs(aComponents.medium) > Math.abs(bComponents.medium)) {
+                        return -1;
+                    } else {
+                        if (aComponents.soft < 0 && bComponents.soft > 0) return -1;
+                        if (aComponents.soft > 0 && bComponents.soft < 0) return 1;
+
+                        return Math.abs(bComponents.soft) - Math.abs(aComponents.soft);
+                    }
+                }
+            });
+            constraints.map((e) => {
+                let components = getScoreComponents(e.weight);
+                e.type = components.hard != 0 ? 'hard' : (components.medium != 0 ? 'medium' : 'soft');
+                e.weight = components[e.type];
+                let scores = getScoreComponents(e.score);
+                e.implicitScore = scores.hard != 0 ? scores.hard : (scores.medium != 0 ? scores.medium : scores.soft);
+            });
+            scoreAnalysis.constraints = constraints;
+
+            scoreAnalysisModalContent.children().remove();
+            scoreAnalysisModalContent.text("");
+
+            const analysisTable = $(`<table class="table"/>`).css({textAlign: 'center'});
+            const analysisTHead = $(`<thead/>`).append($(`<tr/>`)
+                .append($(`<th></th>`))
+                .append($(`<th>Constraint</th>`).css({textAlign: 'left'}))
+                .append($(`<th>Type</th>`))
+                .append($(`<th># Matches</th>`))
+                .append($(`<th>Weight</th>`))
+                .append($(`<th>Score</th>`))
+                .append($(`<th></th>`)));
+            analysisTable.append(analysisTHead);
+            const analysisTBody = $(`<tbody/>`)
+            $.each(scoreAnalysis.constraints, (index, constraintAnalysis) => {
+                let icon = constraintAnalysis.type == "hard" && constraintAnalysis.implicitScore < 0 ? '<span class="fas fa-exclamation-triangle" style="color: red"></span>' : '';
+                if (!icon) icon = constraintAnalysis.matches.length == 0 ? '<span class="fas fa-check-circle" style="color: green"></span>' : '';
+
+                let row = $(`<tr/>`);
+                row.append($(`<td/>`).html(icon))
+                    .append($(`<td/>`).text(constraintAnalysis.name).css({textAlign: 'left'}))
+                    .append($(`<td/>`).text(constraintAnalysis.type))
+                    .append($(`<td/>`).html(`<b>${constraintAnalysis.matches.length}</b>`))
+                    .append($(`<td/>`).text(constraintAnalysis.weight))
+                    .append($(`<td/>`).text(constraintAnalysis.implicitScore));
+                analysisTBody.append(row);
+                row.append($(`<td/>`));
+            });
+            analysisTable.append(analysisTBody);
+            scoreAnalysisModalContent.append(analysisTable);
+        }).fail(function (xhr, ajaxOptions, thrownError) {
+            showError("Analyze failed.", xhr);
+        }, "text");
+    }
+}
+
+function getScoreComponents(score) {
+    let components = {hard: 0, medium: 0, soft: 0};
+
+    $.each([...score.matchAll(/(-?\d*(\.\d+)?)(hard|medium|soft)/g)], (i, parts) => {
+        components[parts[3]] = parseFloat(parts[1], 10);
+    });
+
+    return components;
+}
+
+function refreshSolvingButtons(solving) {
+    if (solving) {
+        $("#solveButton").hide();
+        $("#stopSolvingButton").show();
+        if (autoRefreshIntervalId == null) {
+            autoRefreshIntervalId = setInterval(refreshSchedule, 2000);
+        }
+    } else {
+        $("#solveButton").show();
+        $("#stopSolvingButton").hide();
+        if (autoRefreshIntervalId != null) {
+            clearInterval(autoRefreshIntervalId);
+            autoRefreshIntervalId = null;
+        }
+    }
+}
+
+function stopSolving() {
+    $.delete(`/schedules/${scheduleId}`, function () {
+        refreshSolvingButtons(false);
+        refreshSchedule();
+    }).fail(function (xhr, ajaxOptions, thrownError) {
+        showError("Stop solving failed.", xhr);
+    });
+}
+
+function replaceQuickstartSolverForgeAutoHeaderFooter() {
+    const solverforgeHeader = $("header#solverforge-auto-header");
+    if (solverforgeHeader != null) {
+        solverforgeHeader.css("background-color", "#ffffff");
+        solverforgeHeader.append(
+            $(`<div class="container-fluid">
+        <nav class="navbar sticky-top navbar-expand-lg shadow-sm mb-3" style="background-color: #ffffff;">
+          <a class="navbar-brand" href="https://www.solverforge.org">
+            <img src="/webjars/solverforge/img/solverforge-horizontal.svg" alt="SolverForge logo" width="400">
+          </a>
+          <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
+            <span class="navbar-toggler-icon"></span>
+          </button>
+          <div class="collapse navbar-collapse" id="navbarNav">
+            <ul class="nav nav-pills">
+              <li class="nav-item active" id="navUIItem">
+                <button class="nav-link active" id="navUI" data-bs-toggle="pill" data-bs-target="#demo" type="button" style="color: #1f2937;">Demo UI</button>
+              </li>
+              <li class="nav-item" id="navRestItem">
+                <button class="nav-link" id="navRest" data-bs-toggle="pill" data-bs-target="#rest" type="button" style="color: #1f2937;">Guide</button>
+              </li>
+              <li class="nav-item" id="navOpenApiItem">
+                <button class="nav-link" id="navOpenApi" data-bs-toggle="pill" data-bs-target="#openapi" type="button" style="color: #1f2937;">REST API</button>
+              </li>
+            </ul>
+          </div>
+          <div class="ms-auto">
+              <div class="dropdown">
+                  <button class="btn dropdown-toggle" type="button" id="dropdownMenuButton" data-bs-toggle="dropdown" aria-haspopup="true" aria-expanded="false" style="background-color: #10b981; color: #ffffff; border-color: #10b981;">
+                      Data
+                  </button>
+                  <div id="testDataButton" class="dropdown-menu" aria-labelledby="dropdownMenuButton"></div>
+              </div>
+          </div>
+        </nav>
+      </div>`));
+    }
+
+    const solverforgeFooter = $("footer#solverforge-auto-footer");
+    if (solverforgeFooter != null) {
+        solverforgeFooter.append(
+            $(`<footer class="bg-black text-white-50">
+               <div class="container">
+                 <div class="hstack gap-3 p-4">
+                   <div class="ms-auto"><a class="text-white" href="https://www.solverforge.org">SolverForge</a></div>
+                   <div class="vr"></div>
+                   <div><a class="text-white" href="https://www.solverforge.org/docs">Documentation</a></div>
+                   <div class="vr"></div>
+                   <div><a class="text-white" href="https://github.com/SolverForge/solverforge-legacy">Code</a></div>
+                   <div class="vr"></div>
+                   <div class="me-auto"><a class="text-white" href="mailto:info@solverforge.org">Support</a></div>
+                 </div>
+               </div>
+             </footer>`));
+    }
+}

static/index.html

@@ -0,0 +1,133 @@
+<html lang="en">
+<head>
+    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type">
+    <meta content="width=device-width, initial-scale=1" name="viewport">
+    <title>Employee scheduling - SolverForge for Python</title>
+
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/vis-timeline@7.7.2/styles/vis-timeline-graph2d.min.css"
+          integrity="sha256-svzNasPg1yR5gvEaRei2jg+n4Pc3sVyMUWeS6xRAh6U=" crossorigin="anonymous">
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.3/css/bootstrap.min.css"/>
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.2/css/all.min.css"/>
+  <link rel="stylesheet" href="/webjars/solverforge/css/solverforge-webui.css"/>
+    <style>
+        .vis-time-axis .vis-grid.vis-saturday,
+        .vis-time-axis .vis-grid.vis-sunday {
+            background: #D3D7CFFF;
+        }
+    </style>
+    <link rel="icon" href="/webjars/solverforge/img/solverforge-favicon.svg" type="image/svg+xml">
+</head>
+
+<body>
+<header id="solverforge-auto-header">
+    <!-- Filled in by app.js -->
+</header>
+<div class="tab-content">
+    <div id="demo" class="tab-pane fade show active container-fluid">
+        <div class="sticky-top d-flex justify-content-center align-items-center" aria-live="polite"
+             aria-atomic="true">
+            <div id="notificationPanel" style="position: absolute; top: .5rem;"></div>
+        </div>
+        <h1>Employee scheduling solver</h1>
+        <p>Generate the optimal schedule for your employees.</p>
+
+        <div class="mb-4">
+            <button id="solveButton" type="button" class="btn btn-success">
+                <span class="fas fa-play"></span> Solve
+            </button>
+            <button id="stopSolvingButton" type="button" class="btn btn-danger">
+                <span class="fas fa-stop"></span> Stop solving
+            </button>
+            <span id="unassignedShifts" class="ms-2 align-middle fw-bold"></span>
+            <span id="score" class="score ms-2 align-middle fw-bold">Score: ?</span>
+
+            <div class="float-end">
+                <ul class="nav nav-pills" role="tablist">
+                    <li class="nav-item" role="presentation">
+                        <button class="nav-link active" id="byLocationTab" data-bs-toggle="tab"
+                                data-bs-target="#byLocationPanel" type="button" role="tab"
+                                aria-controls="byLocationPanel" aria-selected="true">By location
+                        </button>
+                    </li>
+                    <li class="nav-item" role="presentation">
+                        <button class="nav-link" id="byEmployeeTab" data-bs-toggle="tab"
+                                data-bs-target="#byEmployeePanel" type="button" role="tab"
+                                aria-controls="byEmployeePanel" aria-selected="false">By employee
+                        </button>
+                    </li>
+                </ul>
+            </div>
+        </div>
+        <div class="mb-4 tab-content">
+            <div class="tab-pane fade show active" id="byLocationPanel" role="tabpanel"
+                 aria-labelledby="byLocationTab">
+                <div id="locationVisualization"></div>
+            </div>
+            <div class="tab-pane fade" id="byEmployeePanel" role="tabpanel" aria-labelledby="byEmployeeTab">
+                <div id="employeeVisualization"></div>
+            </div>
+        </div>
+    </div>
+
+    <div id="rest" class="tab-pane fade  container-fluid">
+        <h1>REST API Guide</h1>
+
+        <h2>Employee Scheduling solver integration via cURL</h2>
+
+        <h3>1. Download demo data</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl1')">Copy</button>
+            <code id="curl1">curl -X GET -H 'Accept:application/json' http://localhost:8080/demo-data/SMALL -o sample.json</code>
+    </pre>
+
+        <h3>2. Post the sample data for solving</h3>
+        <p>The POST operation returns a <code>jobId</code> that should be used in subsequent commands.</p>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl2')">Copy</button>
+            <code id="curl2">curl -X POST -H 'Content-Type:application/json' http://localhost:8080/schedules -d@sample.json</code>
+    </pre>
+
+        <h3>3. Get the current status and score</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl3')">Copy</button>
+            <code id="curl3">curl -X GET -H 'Accept:application/json' http://localhost:8080/schedules/{jobId}/status</code>
+    </pre>
+
+        <h3>4. Get the complete solution</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl4')">Copy</button>
+            <code id="curl4">curl -X GET -H 'Accept:application/json' http://localhost:8080/schedules/{jobId}</code>
+    </pre>
+
+        <h3>5. Terminate solving early</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl5')">Copy</button>
+            <code id="curl5">curl -X DELETE -H 'Accept:application/json' http://localhost:8080/schedules/{id}</code>
+    </pre>
+    </div>
+
+    <div id="openapi" class="tab-pane fade container-fluid">
+        <h1>REST API Reference</h1>
+        <div class="ratio ratio-1x1">
+            <!-- "scrolling" attribute is obsolete, but e.g. Chrome does not support "overflow:hidden" -->
+            <iframe src="/q/swagger-ui" style="overflow:hidden;" scrolling="no"></iframe>
+        </div>
+    </div>
+</div>
+<footer id="solverforge-auto-footer"></footer>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/2.11.8/umd/popper.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.3/js/bootstrap.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/js-joda/1.11.0/js-joda.min.js"></script>
+<script src="/webjars/solverforge/js/solverforge-webui.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/vis-timeline@7.7.2/standalone/umd/vis-timeline-graph2d.min.js"
+        integrity="sha256-Jy2+UO7rZ2Dgik50z3XrrNpnc5+2PAx9MhL2CicodME=" crossorigin="anonymous"></script>
+<script src="/app.js"></script>
+</body>
+</html>

static/webjars/solverforge/css/solverforge-webui.css

@@ -0,0 +1,68 @@
+:root {
+    /* Keep in sync with .navbar height on a large screen. */
+    --ts-navbar-height: 109px;
+
+    --ts-green-1-rgb: #10b981;
+    --ts-green-2-rgb: #059669;
+    --ts-violet-1-rgb: #3E00FF;
+    --ts-violet-2-rgb: #3423A6;
+    --ts-violet-3-rgb: #2E1760;
+    --ts-violet-4-rgb: #200F4F;
+    --ts-violet-5-rgb: #000000; /* TODO FIXME */
+    --ts-violet-dark-1-rgb: #b6adfd;
+    --ts-violet-dark-2-rgb: #c1bbfd;
+    --ts-gray-rgb: #666666;
+    --ts-white-rgb: #FFFFFF;
+    --ts-light-rgb: #F2F2F2;
+    --ts-gray-border: #c5c5c5;
+
+    --tf-light-rgb-transparent: rgb(242,242,242,0.5); /* #F2F2F2 = rgb(242,242,242) */
+    --bs-body-bg: var(--ts-light-rgb); /* link to html bg */
+    --bs-link-color: var(--ts-violet-1-rgb);
+    --bs-link-hover-color: var(--ts-violet-2-rgb);
+
+    --bs-navbar-color: var(--ts-white-rgb);
+    --bs-navbar-hover-color: var(--ts-white-rgb);
+    --bs-nav-link-font-size: 18px;
+    --bs-nav-link-font-weight: 400;
+    --bs-nav-link-color: var(--ts-white-rgb);
+    --ts-nav-link-hover-border-color: var(--ts-violet-1-rgb);
+}
+.btn {
+    --bs-btn-border-radius: 1.5rem;
+}
+.btn-primary {
+    --bs-btn-bg: var(--ts-violet-1-rgb);
+    --bs-btn-border-color: var(--ts-violet-1-rgb);
+    --bs-btn-hover-bg: var(--ts-violet-2-rgb);
+    --bs-btn-hover-border-color: var(--ts-violet-2-rgb);
+    --bs-btn-active-bg: var(--ts-violet-2-rgb);
+    --bs-btn-active-border-bg: var(--ts-violet-2-rgb);
+    --bs-btn-disabled-bg: var(--ts-violet-1-rgb);
+    --bs-btn-disabled-border-color: var(--ts-violet-1-rgb);
+}
+.btn-outline-primary {
+    --bs-btn-color: var(--ts-violet-1-rgb);
+    --bs-btn-border-color: var(--ts-violet-1-rgb);
+    --bs-btn-hover-bg: var(--ts-violet-1-rgb);
+    --bs-btn-hover-border-color: var(--ts-violet-1-rgb);
+    --bs-btn-active-bg: var(--ts-violet-1-rgb);
+    --bs-btn-active-border-color: var(--ts-violet-1-rgb);
+    --bs-btn-disabled-color: var(--ts-violet-1-rgb);
+    --bs-btn-disabled-border-color: var(--ts-violet-1-rgb);
+}
+.navbar-dark {
+    --bs-link-color: var(--ts-violet-dark-1-rgb);
+    --bs-link-hover-color: var(--ts-violet-dark-2-rgb);
+    --bs-navbar-color: var(--ts-white-rgb);
+    --bs-navbar-hover-color: var(--ts-white-rgb);
+}
+.nav-pills {
+    --bs-nav-pills-link-active-bg: var(--ts-green-1-rgb);
+}
+.nav-pills .nav-link:hover {
+    color: var(--ts-green-1-rgb);
+}
+.nav-pills .nav-link.active:hover {
+    color: var(--ts-white-rgb);
+}

static/webjars/solverforge/js/solverforge-webui.js

@@ -0,0 +1,142 @@
+function replaceSolverForgeAutoHeaderFooter() {
+  const solverforgeHeader = $("header#solverforge-auto-header");
+  if (solverforgeHeader != null) {
+    solverforgeHeader.addClass("bg-black")
+    solverforgeHeader.append(
+      $(`<div class="container-fluid">
+        <nav class="navbar sticky-top navbar-expand-lg navbar-dark shadow mb-3">
+          <a class="navbar-brand" href="https://www.solverforge.org">
+            <img src="/solverforge/img/solverforge-horizontal-white.svg" alt="SolverForge logo" width="200">
+          </a>
+        </nav>
+      </div>`));
+  }
+  const solverforgeFooter = $("footer#solverforge-auto-footer");
+  if (solverforgeFooter != null) {
+    solverforgeFooter.append(
+      $(`<footer class="bg-black text-white-50">
+           <div class="container">
+             <div class="hstack gap-3 p-4">
+               <div class="ms-auto"><a class="text-white" href="https://www.solverforge.org">SolverForge</a></div>
+               <div class="vr"></div>
+               <div><a class="text-white" href="https://www.solverforge.org/docs">Documentation</a></div>
+               <div class="vr"></div>
+               <div><a class="text-white" href="https://github.com/SolverForge/solverforge-legacy">Code</a></div>
+               <div class="vr"></div>
+               <div class="me-auto"><a class="text-white" href="mailto:info@solverforge.org">Support</a></div>
+             </div>
+           </div>
+           <div id="applicationInfo" class="container text-center"></div>
+         </footer>`));
+
+      applicationInfo();
+  }
+
+}
+
+function showSimpleError(title) {
+    const notification = $(`<div class="toast" role="alert" aria-live="assertive" aria-atomic="true" style="min-width: 50rem"/>`)
+        .append($(`<div class="toast-header bg-danger">
+                 <strong class="me-auto text-dark">Error</strong>
+                 <button type="button" class="btn-close" data-bs-dismiss="toast" aria-label="Close"></button>
+               </div>`))
+        .append($(`<div class="toast-body"/>`)
+            .append($(`<p/>`).text(title))
+        );
+    $("#notificationPanel").append(notification);
+    notification.toast({delay: 30000});
+    notification.toast('show');
+}
+
+function showError(title, xhr) {
+  var serverErrorMessage = !xhr.responseJSON ? `${xhr.status}: ${xhr.statusText}` : xhr.responseJSON.message;
+  var serverErrorCode = !xhr.responseJSON ? `unknown` : xhr.responseJSON.code;
+  var serverErrorId = !xhr.responseJSON ? `----` : xhr.responseJSON.id;
+  var serverErrorDetails = !xhr.responseJSON ? `no details provided` : xhr.responseJSON.details;
+
+  if (xhr.responseJSON && !serverErrorMessage) {
+	  serverErrorMessage = JSON.stringify(xhr.responseJSON);
+	  serverErrorCode = xhr.statusText + '(' + xhr.status + ')';
+	  serverErrorId = `----`;
+  }
+
+  console.error(title + "\n" + serverErrorMessage + " : " + serverErrorDetails);
+  const notification = $(`<div class="toast" role="alert" aria-live="assertive" aria-atomic="true" style="min-width: 50rem"/>`)
+    .append($(`<div class="toast-header bg-danger">
+                 <strong class="me-auto text-dark">Error</strong>
+                 <button type="button" class="btn-close" data-bs-dismiss="toast" aria-label="Close"></button>
+               </div>`))
+    .append($(`<div class="toast-body"/>`)
+      .append($(`<p/>`).text(title))
+      .append($(`<pre/>`)
+        .append($(`<code/>`).text(serverErrorMessage + "\n\nCode: " + serverErrorCode + "\nError id: " + serverErrorId))
+      )
+    );
+  $("#notificationPanel").append(notification);
+  notification.toast({delay: 30000});
+  notification.toast('show');
+}
+
+// ****************************************************************************
+// Application info
+// ****************************************************************************
+
+function applicationInfo() {
+  $.getJSON("info", function (info) {
+       $("#applicationInfo").append("<small>" + info.application + " (version: " + info.version + ", built at: " + info.built + ")</small>");
+   }).fail(function (xhr, ajaxOptions, thrownError) {
+       console.warn("Unable to collect application information");
+   });
+}
+
+// ****************************************************************************
+// TangoColorFactory
+// ****************************************************************************
+
+const SEQUENCE_1 = [0x8AE234, 0xFCE94F, 0x729FCF, 0xE9B96E, 0xAD7FA8];
+const SEQUENCE_2 = [0x73D216, 0xEDD400, 0x3465A4, 0xC17D11, 0x75507B];
+
+var colorMap = new Map;
+var nextColorCount = 0;
+
+function pickColor(object) {
+  let color = colorMap[object];
+  if (color !== undefined) {
+    return color;
+  }
+  color = nextColor();
+  colorMap[object] = color;
+  return color;
+}
+
+function nextColor() {
+  let color;
+  let colorIndex = nextColorCount % SEQUENCE_1.length;
+  let shadeIndex = Math.floor(nextColorCount / SEQUENCE_1.length);
+  if (shadeIndex === 0) {
+    color = SEQUENCE_1[colorIndex];
+  } else if (shadeIndex === 1) {
+    color = SEQUENCE_2[colorIndex];
+  } else {
+    shadeIndex -= 3;
+    let floorColor = SEQUENCE_2[colorIndex];
+    let ceilColor = SEQUENCE_1[colorIndex];
+    let base = Math.floor((shadeIndex / 2) + 1);
+    let divisor = 2;
+    while (base >= divisor) {
+      divisor *= 2;
+    }
+    base = (base * 2) - divisor + 1;
+    let shadePercentage = base / divisor;
+    color = buildPercentageColor(floorColor, ceilColor, shadePercentage);
+  }
+  nextColorCount++;
+  return "#" + color.toString(16);
+}
+
+function buildPercentageColor(floorColor, ceilColor, shadePercentage) {
+  let red = (floorColor & 0xFF0000) + Math.floor(shadePercentage * ((ceilColor & 0xFF0000) - (floorColor & 0xFF0000))) & 0xFF0000;
+  let green = (floorColor & 0x00FF00) + Math.floor(shadePercentage * ((ceilColor & 0x00FF00) - (floorColor & 0x00FF00))) & 0x00FF00;
+  let blue = (floorColor & 0x0000FF) + Math.floor(shadePercentage * ((ceilColor & 0x0000FF) - (floorColor & 0x0000FF))) & 0x0000FF;
+  return red | green | blue;
+}