Upload 31 files

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,89 @@
 ---
-title: Meeting Scheduling Python
-emoji: 📊
-colorFrom: green
-colorTo: purple
+title: Meeting Scheduling (Python)
+emoji: 👀
+colorFrom: gray
+colorTo: green
 sdk: docker
+app_port: 8080
 pinned: false
 license: apache-2.0
 short_description: SolverForge Quickstart for the Meeting Scheduling problem
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Meeting Scheduling (Python)
+
+Schedule meetings between employees, where each meeting has a topic, duration, required and preferred attendees.
+
+- [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-quickstarts repo and navigate to this directory:
+
+   ```sh
+   $ git clone https://github.com/SolverForge/solverforge-quickstarts.git
+   ...
+   $ cd solverforge-quickstarts/fast/meeting-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
+   ```
+
+## Problem Description
+
+Schedule meetings between employees, where:
+
+* Each meeting has a topic, duration, required and preferred attendees.
+* Each meeting needs a room with sufficient capacity.
+* Meetings should not overlap with other meetings if they share resources (room or attendees).
+* Meetings should be scheduled as soon as possible.
+* Preferred attendees should be able to attend if possible.
+
+## More information
+
+Visit [solverforge.org](https://www.solverforge.org).

input.json

@@ -0,0 +1,1978 @@
+{
+  "people": [
+    {
+      "id": "0",
+      "fullName": "Flo Green"
+    },
+    {
+      "id": "1",
+      "fullName": "Jay Carr"
+    },
+    {
+      "id": "2",
+      "fullName": "Amy Smith"
+    },
+    {
+      "id": "3",
+      "fullName": "Jay Green"
+    },
+    {
+      "id": "4",
+      "fullName": "Avis Carr"
+    },
+    {
+      "id": "5",
+      "fullName": "Lino Howe"
+    },
+    {
+      "id": "6",
+      "fullName": "Lino Cole"
+    },
+    {
+      "id": "7",
+      "fullName": "Hugo Howe"
+    },
+    {
+      "id": "8",
+      "fullName": "Russ Wise"
+    },
+    {
+      "id": "9",
+      "fullName": "Hugo Jones"
+    },
+    {
+      "id": "10",
+      "fullName": "Dino Green"
+    },
+    {
+      "id": "11",
+      "fullName": "Lyle Poe"
+    },
+    {
+      "id": "12",
+      "fullName": "Nick Li"
+    },
+    {
+      "id": "13",
+      "fullName": "Josh Clay"
+    },
+    {
+      "id": "14",
+      "fullName": "Josh Smith"
+    },
+    {
+      "id": "15",
+      "fullName": "Flo Cole"
+    },
+    {
+      "id": "16",
+      "fullName": "Lino Green"
+    },
+    {
+      "id": "17",
+      "fullName": "Flo Poe"
+    },
+    {
+      "id": "18",
+      "fullName": "Josh Jones"
+    },
+    {
+      "id": "19",
+      "fullName": "Beth Horn"
+    }
+  ],
+  "timeGrains": [
+    {
+      "id": "1",
+      "grainIndex": 1,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 480
+    },
+    {
+      "id": "2",
+      "grainIndex": 2,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 495
+    },
+    {
+      "id": "3",
+      "grainIndex": 3,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 510
+    },
+    {
+      "id": "4",
+      "grainIndex": 4,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 525
+    },
+    {
+      "id": "5",
+      "grainIndex": 5,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 540
+    },
+    {
+      "id": "6",
+      "grainIndex": 6,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 555
+    },
+    {
+      "id": "7",
+      "grainIndex": 7,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 570
+    },
+    {
+      "id": "8",
+      "grainIndex": 8,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 585
+    },
+    {
+      "id": "9",
+      "grainIndex": 9,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 600
+    },
+    {
+      "id": "10",
+      "grainIndex": 10,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 615
+    },
+    {
+      "id": "11",
+      "grainIndex": 11,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 630
+    },
+    {
+      "id": "12",
+      "grainIndex": 12,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 645
+    },
+    {
+      "id": "13",
+      "grainIndex": 13,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 660
+    },
+    {
+      "id": "14",
+      "grainIndex": 14,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 675
+    },
+    {
+      "id": "15",
+      "grainIndex": 15,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 690
+    },
+    {
+      "id": "16",
+      "grainIndex": 16,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 705
+    },
+    {
+      "id": "17",
+      "grainIndex": 17,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 720
+    },
+    {
+      "id": "18",
+      "grainIndex": 18,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 735
+    },
+    {
+      "id": "19",
+      "grainIndex": 19,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 750
+    },
+    {
+      "id": "20",
+      "grainIndex": 20,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 765
+    },
+    {
+      "id": "21",
+      "grainIndex": 21,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 780
+    },
+    {
+      "id": "22",
+      "grainIndex": 22,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 795
+    },
+    {
+      "id": "23",
+      "grainIndex": 23,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 810
+    },
+    {
+      "id": "24",
+      "grainIndex": 24,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 825
+    },
+    {
+      "id": "25",
+      "grainIndex": 25,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 840
+    },
+    {
+      "id": "26",
+      "grainIndex": 26,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 855
+    },
+    {
+      "id": "27",
+      "grainIndex": 27,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 870
+    },
+    {
+      "id": "28",
+      "grainIndex": 28,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 885
+    },
+    {
+      "id": "29",
+      "grainIndex": 29,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 900
+    },
+    {
+      "id": "30",
+      "grainIndex": 30,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 915
+    },
+    {
+      "id": "31",
+      "grainIndex": 31,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 930
+    },
+    {
+      "id": "32",
+      "grainIndex": 32,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 945
+    },
+    {
+      "id": "33",
+      "grainIndex": 33,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 960
+    },
+    {
+      "id": "34",
+      "grainIndex": 34,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 975
+    },
+    {
+      "id": "35",
+      "grainIndex": 35,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 990
+    },
+    {
+      "id": "36",
+      "grainIndex": 36,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 1005
+    },
+    {
+      "id": "37",
+      "grainIndex": 37,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 1020
+    },
+    {
+      "id": "38",
+      "grainIndex": 38,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 1035
+    },
+    {
+      "id": "39",
+      "grainIndex": 39,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 1050
+    },
+    {
+      "id": "40",
+      "grainIndex": 40,
+      "dayOfYear": 175,
+      "startingMinuteOfDay": 1065
+    },
+    {
+      "id": "41",
+      "grainIndex": 41,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 480
+    },
+    {
+      "id": "42",
+      "grainIndex": 42,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 495
+    },
+    {
+      "id": "43",
+      "grainIndex": 43,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 510
+    },
+    {
+      "id": "44",
+      "grainIndex": 44,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 525
+    },
+    {
+      "id": "45",
+      "grainIndex": 45,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 540
+    },
+    {
+      "id": "46",
+      "grainIndex": 46,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 555
+    },
+    {
+      "id": "47",
+      "grainIndex": 47,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 570
+    },
+    {
+      "id": "48",
+      "grainIndex": 48,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 585
+    },
+    {
+      "id": "49",
+      "grainIndex": 49,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 600
+    },
+    {
+      "id": "50",
+      "grainIndex": 50,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 615
+    },
+    {
+      "id": "51",
+      "grainIndex": 51,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 630
+    },
+    {
+      "id": "52",
+      "grainIndex": 52,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 645
+    },
+    {
+      "id": "53",
+      "grainIndex": 53,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 660
+    },
+    {
+      "id": "54",
+      "grainIndex": 54,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 675
+    },
+    {
+      "id": "55",
+      "grainIndex": 55,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 690
+    },
+    {
+      "id": "56",
+      "grainIndex": 56,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 705
+    },
+    {
+      "id": "57",
+      "grainIndex": 57,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 720
+    },
+    {
+      "id": "58",
+      "grainIndex": 58,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 735
+    },
+    {
+      "id": "59",
+      "grainIndex": 59,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 750
+    },
+    {
+      "id": "60",
+      "grainIndex": 60,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 765
+    },
+    {
+      "id": "61",
+      "grainIndex": 61,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 780
+    },
+    {
+      "id": "62",
+      "grainIndex": 62,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 795
+    },
+    {
+      "id": "63",
+      "grainIndex": 63,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 810
+    },
+    {
+      "id": "64",
+      "grainIndex": 64,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 825
+    },
+    {
+      "id": "65",
+      "grainIndex": 65,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 840
+    },
+    {
+      "id": "66",
+      "grainIndex": 66,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 855
+    },
+    {
+      "id": "67",
+      "grainIndex": 67,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 870
+    },
+    {
+      "id": "68",
+      "grainIndex": 68,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 885
+    },
+    {
+      "id": "69",
+      "grainIndex": 69,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 900
+    },
+    {
+      "id": "70",
+      "grainIndex": 70,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 915
+    },
+    {
+      "id": "71",
+      "grainIndex": 71,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 930
+    },
+    {
+      "id": "72",
+      "grainIndex": 72,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 945
+    },
+    {
+      "id": "73",
+      "grainIndex": 73,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 960
+    },
+    {
+      "id": "74",
+      "grainIndex": 74,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 975
+    },
+    {
+      "id": "75",
+      "grainIndex": 75,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 990
+    },
+    {
+      "id": "76",
+      "grainIndex": 76,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 1005
+    },
+    {
+      "id": "77",
+      "grainIndex": 77,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 1020
+    },
+    {
+      "id": "78",
+      "grainIndex": 78,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 1035
+    },
+    {
+      "id": "79",
+      "grainIndex": 79,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 1050
+    },
+    {
+      "id": "80",
+      "grainIndex": 80,
+      "dayOfYear": 176,
+      "startingMinuteOfDay": 1065
+    },
+    {
+      "id": "81",
+      "grainIndex": 81,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 480
+    },
+    {
+      "id": "82",
+      "grainIndex": 82,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 495
+    },
+    {
+      "id": "83",
+      "grainIndex": 83,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 510
+    },
+    {
+      "id": "84",
+      "grainIndex": 84,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 525
+    },
+    {
+      "id": "85",
+      "grainIndex": 85,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 540
+    },
+    {
+      "id": "86",
+      "grainIndex": 86,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 555
+    },
+    {
+      "id": "87",
+      "grainIndex": 87,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 570
+    },
+    {
+      "id": "88",
+      "grainIndex": 88,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 585
+    },
+    {
+      "id": "89",
+      "grainIndex": 89,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 600
+    },
+    {
+      "id": "90",
+      "grainIndex": 90,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 615
+    },
+    {
+      "id": "91",
+      "grainIndex": 91,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 630
+    },
+    {
+      "id": "92",
+      "grainIndex": 92,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 645
+    },
+    {
+      "id": "93",
+      "grainIndex": 93,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 660
+    },
+    {
+      "id": "94",
+      "grainIndex": 94,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 675
+    },
+    {
+      "id": "95",
+      "grainIndex": 95,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 690
+    },
+    {
+      "id": "96",
+      "grainIndex": 96,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 705
+    },
+    {
+      "id": "97",
+      "grainIndex": 97,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 720
+    },
+    {
+      "id": "98",
+      "grainIndex": 98,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 735
+    },
+    {
+      "id": "99",
+      "grainIndex": 99,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 750
+    },
+    {
+      "id": "100",
+      "grainIndex": 100,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 765
+    },
+    {
+      "id": "101",
+      "grainIndex": 101,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 780
+    },
+    {
+      "id": "102",
+      "grainIndex": 102,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 795
+    },
+    {
+      "id": "103",
+      "grainIndex": 103,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 810
+    },
+    {
+      "id": "104",
+      "grainIndex": 104,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 825
+    },
+    {
+      "id": "105",
+      "grainIndex": 105,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 840
+    },
+    {
+      "id": "106",
+      "grainIndex": 106,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 855
+    },
+    {
+      "id": "107",
+      "grainIndex": 107,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 870
+    },
+    {
+      "id": "108",
+      "grainIndex": 108,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 885
+    },
+    {
+      "id": "109",
+      "grainIndex": 109,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 900
+    },
+    {
+      "id": "110",
+      "grainIndex": 110,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 915
+    },
+    {
+      "id": "111",
+      "grainIndex": 111,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 930
+    },
+    {
+      "id": "112",
+      "grainIndex": 112,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 945
+    },
+    {
+      "id": "113",
+      "grainIndex": 113,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 960
+    },
+    {
+      "id": "114",
+      "grainIndex": 114,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 975
+    },
+    {
+      "id": "115",
+      "grainIndex": 115,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 990
+    },
+    {
+      "id": "116",
+      "grainIndex": 116,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 1005
+    },
+    {
+      "id": "117",
+      "grainIndex": 117,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 1020
+    },
+    {
+      "id": "118",
+      "grainIndex": 118,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 1035
+    },
+    {
+      "id": "119",
+      "grainIndex": 119,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 1050
+    },
+    {
+      "id": "120",
+      "grainIndex": 120,
+      "dayOfYear": 177,
+      "startingMinuteOfDay": 1065
+    },
+    {
+      "id": "121",
+      "grainIndex": 121,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 480
+    },
+    {
+      "id": "122",
+      "grainIndex": 122,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 495
+    },
+    {
+      "id": "123",
+      "grainIndex": 123,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 510
+    },
+    {
+      "id": "124",
+      "grainIndex": 124,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 525
+    },
+    {
+      "id": "125",
+      "grainIndex": 125,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 540
+    },
+    {
+      "id": "126",
+      "grainIndex": 126,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 555
+    },
+    {
+      "id": "127",
+      "grainIndex": 127,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 570
+    },
+    {
+      "id": "128",
+      "grainIndex": 128,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 585
+    },
+    {
+      "id": "129",
+      "grainIndex": 129,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 600
+    },
+    {
+      "id": "130",
+      "grainIndex": 130,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 615
+    },
+    {
+      "id": "131",
+      "grainIndex": 131,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 630
+    },
+    {
+      "id": "132",
+      "grainIndex": 132,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 645
+    },
+    {
+      "id": "133",
+      "grainIndex": 133,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 660
+    },
+    {
+      "id": "134",
+      "grainIndex": 134,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 675
+    },
+    {
+      "id": "135",
+      "grainIndex": 135,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 690
+    },
+    {
+      "id": "136",
+      "grainIndex": 136,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 705
+    },
+    {
+      "id": "137",
+      "grainIndex": 137,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 720
+    },
+    {
+      "id": "138",
+      "grainIndex": 138,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 735
+    },
+    {
+      "id": "139",
+      "grainIndex": 139,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 750
+    },
+    {
+      "id": "140",
+      "grainIndex": 140,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 765
+    },
+    {
+      "id": "141",
+      "grainIndex": 141,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 780
+    },
+    {
+      "id": "142",
+      "grainIndex": 142,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 795
+    },
+    {
+      "id": "143",
+      "grainIndex": 143,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 810
+    },
+    {
+      "id": "144",
+      "grainIndex": 144,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 825
+    },
+    {
+      "id": "145",
+      "grainIndex": 145,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 840
+    },
+    {
+      "id": "146",
+      "grainIndex": 146,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 855
+    },
+    {
+      "id": "147",
+      "grainIndex": 147,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 870
+    },
+    {
+      "id": "148",
+      "grainIndex": 148,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 885
+    },
+    {
+      "id": "149",
+      "grainIndex": 149,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 900
+    },
+    {
+      "id": "150",
+      "grainIndex": 150,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 915
+    },
+    {
+      "id": "151",
+      "grainIndex": 151,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 930
+    },
+    {
+      "id": "152",
+      "grainIndex": 152,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 945
+    },
+    {
+      "id": "153",
+      "grainIndex": 153,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 960
+    },
+    {
+      "id": "154",
+      "grainIndex": 154,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 975
+    },
+    {
+      "id": "155",
+      "grainIndex": 155,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 990
+    },
+    {
+      "id": "156",
+      "grainIndex": 156,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 1005
+    },
+    {
+      "id": "157",
+      "grainIndex": 157,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 1020
+    },
+    {
+      "id": "158",
+      "grainIndex": 158,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 1035
+    },
+    {
+      "id": "159",
+      "grainIndex": 159,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 1050
+    },
+    {
+      "id": "160",
+      "grainIndex": 160,
+      "dayOfYear": 178,
+      "startingMinuteOfDay": 1065
+    }
+  ],
+  "rooms": [
+    {
+      "id": "R1",
+      "name": "Room 1",
+      "capacity": 30
+    },
+    {
+      "id": "R2",
+      "name": "Room 2",
+      "capacity": 20
+    },
+    {
+      "id": "R3",
+      "name": "Room 3",
+      "capacity": 16
+    }
+  ],
+  "meetings": [
+    {
+      "id": "0",
+      "topic": "Strategize B2B",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [
+        {
+          "id": "0-1",
+          "person": "14",
+          "meeting": "0"
+        },
+        {
+          "id": "0-2",
+          "person": "19",
+          "meeting": "0"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "1",
+      "topic": "Fast track e-business",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 16,
+      "requiredAttendances": [
+        {
+          "id": "1-1",
+          "person": "15",
+          "meeting": "1"
+        },
+        {
+          "id": "1-2",
+          "person": "17",
+          "meeting": "1"
+        },
+        {
+          "id": "1-3",
+          "person": "16",
+          "meeting": "1"
+        },
+        {
+          "id": "1-4",
+          "person": "6",
+          "meeting": "1"
+        },
+        {
+          "id": "1-5",
+          "person": "4",
+          "meeting": "1"
+        },
+        {
+          "id": "1-6",
+          "person": "11",
+          "meeting": "1"
+        },
+        {
+          "id": "1-7",
+          "person": "10",
+          "meeting": "1"
+        }
+      ],
+      "preferredAttendances": [
+        {
+          "id": "1-8",
+          "person": "3",
+          "meeting": "1"
+        },
+        {
+          "id": "1-9",
+          "person": "8",
+          "meeting": "1"
+        },
+        {
+          "id": "1-10",
+          "person": "1",
+          "meeting": "1"
+        }
+      ]
+    },
+    {
+      "id": "2",
+      "topic": "Cross sell virtualization",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [
+        {
+          "id": "2-1",
+          "person": "3",
+          "meeting": "2"
+        },
+        {
+          "id": "2-2",
+          "person": "2",
+          "meeting": "2"
+        },
+        {
+          "id": "2-3",
+          "person": "15",
+          "meeting": "2"
+        },
+        {
+          "id": "2-4",
+          "person": "8",
+          "meeting": "2"
+        },
+        {
+          "id": "2-5",
+          "person": "1",
+          "meeting": "2"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "3",
+      "topic": "Profitize multitasking",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 16,
+      "requiredAttendances": [
+        {
+          "id": "3-1",
+          "person": "0",
+          "meeting": "3"
+        },
+        {
+          "id": "3-2",
+          "person": "18",
+          "meeting": "3"
+        }
+      ],
+      "preferredAttendances": [
+        {
+          "id": "3-3",
+          "person": "12",
+          "meeting": "3"
+        },
+        {
+          "id": "3-4",
+          "person": "19",
+          "meeting": "3"
+        }
+      ]
+    },
+    {
+      "id": "4",
+      "topic": "Transform one stop shop",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 12,
+      "requiredAttendances": [
+        {
+          "id": "4-1",
+          "person": "19",
+          "meeting": "4"
+        },
+        {
+          "id": "4-2",
+          "person": "18",
+          "meeting": "4"
+        },
+        {
+          "id": "4-3",
+          "person": "11",
+          "meeting": "4"
+        },
+        {
+          "id": "4-4",
+          "person": "0",
+          "meeting": "4"
+        },
+        {
+          "id": "4-5",
+          "person": "9",
+          "meeting": "4"
+        },
+        {
+          "id": "4-6",
+          "person": "17",
+          "meeting": "4"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "5",
+      "topic": "Engage braindumps",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 12,
+      "requiredAttendances": [],
+      "preferredAttendances": []
+    },
+    {
+      "id": "6",
+      "topic": "Downsize data mining",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [
+        {
+          "id": "6-1",
+          "person": "15",
+          "meeting": "6"
+        },
+        {
+          "id": "6-2",
+          "person": "4",
+          "meeting": "6"
+        }
+      ],
+      "preferredAttendances": [
+        {
+          "id": "6-3",
+          "person": "6",
+          "meeting": "6"
+        },
+        {
+          "id": "6-4",
+          "person": "14",
+          "meeting": "6"
+        },
+        {
+          "id": "6-5",
+          "person": "16",
+          "meeting": "6"
+        }
+      ]
+    },
+    {
+      "id": "7",
+      "topic": "Ramp up policies",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 16,
+      "requiredAttendances": [
+        {
+          "id": "7-1",
+          "person": "0",
+          "meeting": "7"
+        },
+        {
+          "id": "7-2",
+          "person": "14",
+          "meeting": "7"
+        },
+        {
+          "id": "7-3",
+          "person": "7",
+          "meeting": "7"
+        },
+        {
+          "id": "7-4",
+          "person": "3",
+          "meeting": "7"
+        },
+        {
+          "id": "7-5",
+          "person": "6",
+          "meeting": "7"
+        },
+        {
+          "id": "7-6",
+          "person": "12",
+          "meeting": "7"
+        },
+        {
+          "id": "7-7",
+          "person": "4",
+          "meeting": "7"
+        },
+        {
+          "id": "7-8",
+          "person": "18",
+          "meeting": "7"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "8",
+      "topic": "On board synergies",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 12,
+      "requiredAttendances": [],
+      "preferredAttendances": [
+        {
+          "id": "8-1",
+          "person": "1",
+          "meeting": "8"
+        },
+        {
+          "id": "8-2",
+          "person": "2",
+          "meeting": "8"
+        },
+        {
+          "id": "8-3",
+          "person": "6",
+          "meeting": "8"
+        },
+        {
+          "id": "8-4",
+          "person": "18",
+          "meeting": "8"
+        }
+      ]
+    },
+    {
+      "id": "9",
+      "topic": "Reinvigorate user experience",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 16,
+      "requiredAttendances": [],
+      "preferredAttendances": [
+        {
+          "id": "9-1",
+          "person": "14",
+          "meeting": "9"
+        },
+        {
+          "id": "9-2",
+          "person": "9",
+          "meeting": "9"
+        },
+        {
+          "id": "9-3",
+          "person": "18",
+          "meeting": "9"
+        }
+      ]
+    },
+    {
+      "id": "10",
+      "topic": "Strategize e-business",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 16,
+      "requiredAttendances": [],
+      "preferredAttendances": [
+        {
+          "id": "10-1",
+          "person": "17",
+          "meeting": "10"
+        },
+        {
+          "id": "10-2",
+          "person": "13",
+          "meeting": "10"
+        }
+      ]
+    },
+    {
+      "id": "11",
+      "topic": "Fast track virtualization",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 12,
+      "requiredAttendances": [],
+      "preferredAttendances": [
+        {
+          "id": "11-1",
+          "person": "15",
+          "meeting": "11"
+        },
+        {
+          "id": "11-2",
+          "person": "6",
+          "meeting": "11"
+        },
+        {
+          "id": "11-3",
+          "person": "2",
+          "meeting": "11"
+        },
+        {
+          "id": "11-4",
+          "person": "9",
+          "meeting": "11"
+        },
+        {
+          "id": "11-5",
+          "person": "7",
+          "meeting": "11"
+        },
+        {
+          "id": "11-6",
+          "person": "8",
+          "meeting": "11"
+        },
+        {
+          "id": "11-7",
+          "person": "11",
+          "meeting": "11"
+        },
+        {
+          "id": "11-8",
+          "person": "0",
+          "meeting": "11"
+        },
+        {
+          "id": "11-9",
+          "person": "13",
+          "meeting": "11"
+        }
+      ]
+    },
+    {
+      "id": "12",
+      "topic": "Cross sell multitasking",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 16,
+      "requiredAttendances": [
+        {
+          "id": "12-1",
+          "person": "12",
+          "meeting": "12"
+        },
+        {
+          "id": "12-2",
+          "person": "11",
+          "meeting": "12"
+        }
+      ],
+      "preferredAttendances": [
+        {
+          "id": "12-3",
+          "person": "9",
+          "meeting": "12"
+        },
+        {
+          "id": "12-4",
+          "person": "2",
+          "meeting": "12"
+        }
+      ]
+    },
+    {
+      "id": "13",
+      "topic": "Profitize one stop shop",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 12,
+      "requiredAttendances": [],
+      "preferredAttendances": [
+        {
+          "id": "13-1",
+          "person": "16",
+          "meeting": "13"
+        },
+        {
+          "id": "13-2",
+          "person": "0",
+          "meeting": "13"
+        }
+      ]
+    },
+    {
+      "id": "14",
+      "topic": "Transform braindumps",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 16,
+      "requiredAttendances": [
+        {
+          "id": "14-1",
+          "person": "4",
+          "meeting": "14"
+        },
+        {
+          "id": "14-2",
+          "person": "17",
+          "meeting": "14"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "15",
+      "topic": "Engage data mining",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [
+        {
+          "id": "15-1",
+          "person": "6",
+          "meeting": "15"
+        },
+        {
+          "id": "15-2",
+          "person": "18",
+          "meeting": "15"
+        }
+      ],
+      "preferredAttendances": [
+        {
+          "id": "15-3",
+          "person": "7",
+          "meeting": "15"
+        }
+      ]
+    },
+    {
+      "id": "16",
+      "topic": "Downsize policies",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [],
+      "preferredAttendances": []
+    },
+    {
+      "id": "17",
+      "topic": "Ramp up synergies",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [
+        {
+          "id": "17-1",
+          "person": "6",
+          "meeting": "17"
+        },
+        {
+          "id": "17-2",
+          "person": "11",
+          "meeting": "17"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "18",
+      "topic": "On board user experience",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 12,
+      "requiredAttendances": [
+        {
+          "id": "18-1",
+          "person": "11",
+          "meeting": "18"
+        },
+        {
+          "id": "18-2",
+          "person": "6",
+          "meeting": "18"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "19",
+      "topic": "Reinvigorate B2B",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [],
+      "preferredAttendances": [
+        {
+          "id": "19-1",
+          "person": "12",
+          "meeting": "19"
+        },
+        {
+          "id": "19-2",
+          "person": "16",
+          "meeting": "19"
+        },
+        {
+          "id": "19-3",
+          "person": "18",
+          "meeting": "19"
+        }
+      ]
+    },
+    {
+      "id": "20",
+      "topic": "Strategize virtualization",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [],
+      "preferredAttendances": []
+    },
+    {
+      "id": "21",
+      "topic": "Fast track multitasking",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 12,
+      "requiredAttendances": [
+        {
+          "id": "21-1",
+          "person": "5",
+          "meeting": "21"
+        },
+        {
+          "id": "21-2",
+          "person": "4",
+          "meeting": "21"
+        },
+        {
+          "id": "21-3",
+          "person": "17",
+          "meeting": "21"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "22",
+      "topic": "Cross sell one stop shop",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [
+        {
+          "id": "22-1",
+          "person": "3",
+          "meeting": "22"
+        },
+        {
+          "id": "22-2",
+          "person": "8",
+          "meeting": "22"
+        },
+        {
+          "id": "22-3",
+          "person": "1",
+          "meeting": "22"
+        },
+        {
+          "id": "22-4",
+          "person": "0",
+          "meeting": "22"
+        },
+        {
+          "id": "22-5",
+          "person": "6",
+          "meeting": "22"
+        },
+        {
+          "id": "22-6",
+          "person": "14",
+          "meeting": "22"
+        },
+        {
+          "id": "22-7",
+          "person": "13",
+          "meeting": "22"
+        },
+        {
+          "id": "22-8",
+          "person": "2",
+          "meeting": "22"
+        },
+        {
+          "id": "22-9",
+          "person": "16",
+          "meeting": "22"
+        },
+        {
+          "id": "22-10",
+          "person": "18",
+          "meeting": "22"
+        }
+      ],
+      "preferredAttendances": []
+    },
+    {
+      "id": "23",
+      "topic": "Reinvigorate multitasking",
+      "speakers": [],
+      "content": "",
+      "entireGroupMeeting": false,
+      "durationInGrains": 8,
+      "requiredAttendances": [
+        {
+          "id": "23-1",
+          "person": "16",
+          "meeting": "23"
+        },
+        {
+          "id": "23-2",
+          "person": "12",
+          "meeting": "23"
+        },
+        {
+          "id": "23-3",
+          "person": "3",
+          "meeting": "23"
+        },
+        {
+          "id": "23-4",
+          "person": "13",
+          "meeting": "23"
+        },
+        {
+          "id": "23-5",
+          "person": "18",
+          "meeting": "23"
+        },
+        {
+          "id": "23-6",
+          "person": "10",
+          "meeting": "23"
+        }
+      ],
+      "preferredAttendances": []
+    }
+  ],
+  "meetingAssignments": [
+    {
+      "id": "0",
+      "meeting": "0",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "1",
+      "meeting": "1",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "2",
+      "meeting": "2",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "3",
+      "meeting": "3",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "4",
+      "meeting": "4",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "5",
+      "meeting": "5",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "6",
+      "meeting": "6",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "7",
+      "meeting": "7",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "8",
+      "meeting": "8",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "9",
+      "meeting": "9",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "10",
+      "meeting": "10",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "11",
+      "meeting": "11",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "12",
+      "meeting": "12",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "13",
+      "meeting": "13",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "14",
+      "meeting": "14",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "15",
+      "meeting": "15",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "16",
+      "meeting": "16",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "17",
+      "meeting": "17",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "18",
+      "meeting": "18",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "19",
+      "meeting": "19",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "20",
+      "meeting": "20",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "21",
+      "meeting": "21",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "22",
+      "meeting": "22",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    },
+    {
+      "id": "23",
+      "meeting": "23",
+      "pinned": false,
+      "startingTimeGrain": null,
+      "room": null
+    }
+  ],
+  "score": null,
+  "solverStatus": null
+}

logging.conf

@@ -0,0 +1,28 @@
+[loggers]
+keys=root,timefold
+
+[handlers]
+keys=consoleHandler
+
+[formatters]
+keys=simpleFormatter
+
+[logger_root]
+level=INFO
+handlers=consoleHandler
+
+[logger_timefold]
+level=INFO
+handlers=consoleHandler
+qualname=timefold
+propagate=0
+
+[handler_consoleHandler]
+class=StreamHandler
+level=INFO
+formatter=simpleFormatter
+args=(sys.stdout,)
+
+[formatter_simpleFormatter]
+format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+datefmt=%Y-%m-%d %H:%M:%S

pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "meeting_scheduling"
+version = "1.0.0"
+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',
+    'httpx == 0.27.0',
+]
+
+[project.scripts]
+run-app = "meeting_scheduling:main"

src/meeting_scheduling/__init__.py

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

src/meeting_scheduling/constraints.py

@@ -0,0 +1,527 @@
+from solverforge_legacy.solver.score import (
+    constraint_provider,
+    HardMediumSoftScore,
+    Joiners,
+    ConstraintFactory,
+    Constraint,
+)
+
+from .domain import (
+    Attendance,
+    MeetingAssignment,
+    PreferredAttendance,
+    RequiredAttendance,
+    Room,
+    TimeGrain,
+)
+
+
+@constraint_provider
+def define_constraints(constraint_factory: ConstraintFactory):
+    """
+    Defines all constraints for the meeting scheduling problem, organized by priority (hard, medium, soft).
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        List[Constraint]: All defined constraints.
+    """
+    return [
+        # Hard constraints
+        room_conflict(constraint_factory),
+        avoid_overtime(constraint_factory),
+        required_attendance_conflict(constraint_factory),
+        required_room_capacity(constraint_factory),
+        start_and_end_on_same_day(constraint_factory),
+        # Medium constraints
+        required_and_preferred_attendance_conflict(constraint_factory),
+        preferred_attendance_conflict(constraint_factory),
+        # Soft constraints
+        do_meetings_as_soon_as_possible(constraint_factory),
+        one_break_between_consecutive_meetings(constraint_factory),
+        overlapping_meetings(constraint_factory),
+        assign_larger_rooms_first(constraint_factory),
+        room_stability(constraint_factory),
+    ]
+
+
+# ************************************************************************
+# Hard constraints
+# ************************************************************************
+
+
+def room_conflict(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Hard constraint: Prevents overlapping meetings in the same room.
+
+    Penalizes pairs of meetings scheduled in the same room whose time slots overlap, with penalty proportional to the overlap duration.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_unique_pair(
+            MeetingAssignment,
+            Joiners.equal(lambda assignment: assignment.room),
+            Joiners.overlapping(
+                lambda assignment: assignment.get_grain_index(),
+                lambda assignment: assignment.get_last_time_grain_index() + 1,
+            ),
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_HARD,
+            lambda left_assignment,
+            right_assignment: right_assignment.calculate_overlap(left_assignment),
+        )
+        .as_constraint("Room conflict")
+    )
+
+
+def avoid_overtime(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Hard constraint: Prevents meetings from extending beyond available time slots.
+
+    Penalizes meetings that end after the last available time grain, based on how far they extend beyond the schedule.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_including_unassigned(MeetingAssignment)
+        .filter(
+            lambda meeting_assignment: meeting_assignment.starting_time_grain
+            is not None
+        )
+        .if_not_exists(
+            TimeGrain,
+            Joiners.equal(
+                lambda assignment: assignment.get_last_time_grain_index(),
+                lambda time_grain: time_grain.grain_index,
+            ),
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_HARD,
+            lambda meeting_assignment: meeting_assignment.get_last_time_grain_index(),
+        )
+        .as_constraint("Don't go in overtime")
+    )
+
+
+def required_attendance_conflict(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Hard constraint: Prevents required attendees from having overlapping meetings.
+
+    Penalizes when a person required at multiple meetings is scheduled for overlapping meetings, proportional to the overlap duration.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_unique_pair(
+            RequiredAttendance, Joiners.equal(lambda attendance: attendance.person)
+        )
+        .join(
+            MeetingAssignment,
+            Joiners.equal(
+                lambda left_required, right_required: left_required.meeting_id,
+                lambda assignment: assignment.meeting.id,
+            ),
+        )
+        .join(
+            MeetingAssignment,
+            Joiners.equal(
+                lambda left_required,
+                right_required,
+                left_assignment: right_required.meeting_id,
+                lambda assignment: assignment.meeting.id,
+            ),
+            Joiners.overlapping(
+                lambda attendee1, attendee2, assignment: assignment.get_grain_index(),
+                lambda attendee1,
+                attendee2,
+                assignment: assignment.get_last_time_grain_index() + 1,
+                lambda assignment: assignment.get_grain_index(),
+                lambda assignment: assignment.get_last_time_grain_index() + 1,
+            ),
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_HARD,
+            lambda left_required,
+            right_required,
+            left_assignment,
+            right_assignment: right_assignment.calculate_overlap(left_assignment),
+        )
+        .as_constraint("Required attendance conflict")
+    )
+
+
+def required_room_capacity(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Hard constraint: Ensures rooms have enough capacity for required attendees.
+
+    Penalizes meetings assigned to rooms with insufficient capacity, proportional to the shortfall.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_including_unassigned(MeetingAssignment)
+        .filter(
+            lambda meeting_assignment: meeting_assignment.get_required_capacity()
+            > meeting_assignment.get_room_capacity()
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_HARD,
+            lambda meeting_assignment: meeting_assignment.get_required_capacity()
+            - meeting_assignment.get_room_capacity(),
+        )
+        .as_constraint("Required room capacity")
+    )
+
+
+def start_and_end_on_same_day(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Hard constraint: Ensures meetings start and end on the same day.
+
+    Penalizes meetings that span multiple days.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_including_unassigned(MeetingAssignment)
+        .filter(
+            lambda meeting_assignment: meeting_assignment.starting_time_grain
+            is not None
+        )
+        .join(
+            TimeGrain,
+            Joiners.equal(
+                lambda meeting_assignment: meeting_assignment.get_last_time_grain_index(),
+                lambda time_grain: time_grain.grain_index,
+            ),
+            Joiners.filtering(
+                lambda meeting_assignment,
+                time_grain: meeting_assignment.starting_time_grain.day_of_year
+                != time_grain.day_of_year
+            ),
+        )
+        .penalize(HardMediumSoftScore.ONE_HARD)
+        .as_constraint("Start and end on same day")
+    )
+
+
+# ************************************************************************
+# Medium constraints
+# ************************************************************************
+
+
+def required_and_preferred_attendance_conflict(
+    constraint_factory: ConstraintFactory,
+) -> Constraint:
+    """
+    Medium constraint: Discourages conflicts between required and preferred attendance for the same person.
+
+    Penalizes when a person required at one meeting and preferred at another is scheduled for overlapping meetings, proportional to the overlap duration.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each(RequiredAttendance)
+        .join(
+            PreferredAttendance,
+            Joiners.equal(
+                lambda required: required.person, lambda preferred: preferred.person
+            ),
+        )
+        .join(
+            constraint_factory.for_each_including_unassigned(MeetingAssignment).filter(
+                lambda assignment: assignment.starting_time_grain is not None
+            ),
+            Joiners.equal(
+                lambda required, preferred: required.meeting_id,
+                lambda assignment: assignment.meeting.id,
+            ),
+        )
+        .join(
+            constraint_factory.for_each_including_unassigned(MeetingAssignment).filter(
+                lambda assignment: assignment.starting_time_grain is not None
+            ),
+            Joiners.equal(
+                lambda required, preferred, left_assignment: preferred.meeting_id,
+                lambda assignment: assignment.meeting.id,
+            ),
+            Joiners.overlapping(
+                lambda required, preferred, assignment: assignment.get_grain_index(),
+                lambda required,
+                preferred,
+                assignment: assignment.get_last_time_grain_index() + 1,
+                lambda assignment: assignment.get_grain_index(),
+                lambda assignment: assignment.get_last_time_grain_index() + 1,
+            ),
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_MEDIUM,
+            lambda required,
+            preferred,
+            left_assignment,
+            right_assignment: right_assignment.calculate_overlap(left_assignment),
+        )
+        .as_constraint("Required and preferred attendance conflict")
+    )
+
+
+def preferred_attendance_conflict(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Medium constraint: Discourages conflicts between preferred attendees.
+
+    Penalizes when a person preferred at multiple meetings is scheduled for overlapping meetings, proportional to the overlap duration.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_unique_pair(
+            PreferredAttendance, Joiners.equal(lambda attendance: attendance.person)
+        )
+        .join(
+            constraint_factory.for_each_including_unassigned(MeetingAssignment).filter(
+                lambda assignment: assignment.starting_time_grain is not None
+            ),
+            Joiners.equal(
+                lambda left_attendance, right_attendance: left_attendance.meeting_id,
+                lambda assignment: assignment.meeting.id,
+            ),
+        )
+        .join(
+            constraint_factory.for_each_including_unassigned(MeetingAssignment).filter(
+                lambda assignment: assignment.starting_time_grain is not None
+            ),
+            Joiners.equal(
+                lambda left_attendance,
+                right_attendance,
+                left_assignment: right_attendance.meeting_id,
+                lambda assignment: assignment.meeting.id,
+            ),
+            Joiners.overlapping(
+                lambda attendee1, attendee2, assignment: assignment.get_grain_index(),
+                lambda attendee1,
+                attendee2,
+                assignment: assignment.get_last_time_grain_index() + 1,
+                lambda assignment: assignment.get_grain_index(),
+                lambda assignment: assignment.get_last_time_grain_index() + 1,
+            ),
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_MEDIUM,
+            lambda left_attendance,
+            right_attendance,
+            left_assignment,
+            right_assignment: right_assignment.calculate_overlap(left_assignment),
+        )
+        .as_constraint("Preferred attendance conflict")
+    )
+
+
+# ************************************************************************
+# Soft constraints
+# ************************************************************************
+
+
+def do_meetings_as_soon_as_possible(
+    constraint_factory: ConstraintFactory,
+) -> Constraint:
+    """
+    Soft constraint: Encourages scheduling meetings earlier in the available time slots.
+
+    Penalizes meetings scheduled later in the available time grains, proportional to their end time.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_including_unassigned(MeetingAssignment)
+        .filter(
+            lambda meeting_assignment: meeting_assignment.starting_time_grain
+            is not None
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_SOFT,
+            lambda meeting_assignment: meeting_assignment.get_last_time_grain_index(),
+        )
+        .as_constraint("Do all meetings as soon as possible")
+    )
+
+
+def one_break_between_consecutive_meetings(
+    constraint_factory: ConstraintFactory,
+) -> Constraint:
+    """
+    Soft constraint: Penalizes consecutive meetings without a break.
+
+    Penalizes pairs of meetings that are scheduled consecutively without at least one time grain break between them.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_including_unassigned(MeetingAssignment)
+        .filter(
+            lambda meeting_assignment: meeting_assignment.starting_time_grain
+            is not None
+        )
+        .join(
+            constraint_factory.for_each_including_unassigned(MeetingAssignment).filter(
+                lambda assignment: assignment.starting_time_grain is not None
+            ),
+            Joiners.equal(
+                lambda left_assignment: left_assignment.get_last_time_grain_index(),
+                lambda right_assignment: right_assignment.get_grain_index() - 1,
+            ),
+        )
+        .penalize(HardMediumSoftScore.of_soft(100))
+        .as_constraint("One TimeGrain break between two consecutive meetings")
+    )
+
+
+def overlapping_meetings(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Soft constraint: Discourages overlapping meetings, even in different rooms.
+
+    Penalizes pairs of meetings that overlap in time, regardless of room, proportional to the overlap duration.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_including_unassigned(MeetingAssignment)
+        .filter(
+            lambda meeting_assignment: meeting_assignment.starting_time_grain
+            is not None
+        )
+        .join(
+            constraint_factory.for_each_including_unassigned(MeetingAssignment).filter(
+                lambda meeting_assignment: meeting_assignment.starting_time_grain
+                is not None
+            ),
+            Joiners.greater_than(
+                lambda left_assignment: left_assignment.meeting.id,
+                lambda right_assignment: right_assignment.meeting.id,
+            ),
+            Joiners.overlapping(
+                lambda assignment: assignment.get_grain_index(),
+                lambda assignment: assignment.get_last_time_grain_index() + 1,
+            ),
+        )
+        .penalize(
+            HardMediumSoftScore.of_soft(10),
+            lambda left_assignment, right_assignment: left_assignment.calculate_overlap(
+                right_assignment
+            ),
+        )
+        .as_constraint("Overlapping meetings")
+    )
+
+
+def assign_larger_rooms_first(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Soft constraint: Penalizes using smaller rooms when larger rooms are available.
+
+    Penalizes when a meeting is assigned to a room while larger rooms exist, proportional to the capacity difference.
+
+    Args:
+        constraint_factory (ConstraintFactory): The constraint factory.
+    Returns:
+        Constraint: The defined constraint.
+    """
+    return (
+        constraint_factory.for_each_including_unassigned(MeetingAssignment)
+        .filter(lambda meeting_assignment: meeting_assignment.room is not None)
+        .join(
+            Room,
+            Joiners.less_than(
+                lambda meeting_assignment: meeting_assignment.get_room_capacity(),
+                lambda room: room.capacity,
+            ),
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_SOFT,
+            lambda meeting_assignment, room: room.capacity
+            - meeting_assignment.get_room_capacity(),
+        )
+        .as_constraint("Assign larger rooms first")
+    )
+
+
+def room_stability(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Soft constraint: Encourages room stability for people attending multiple meetings.
+
+    Penalizes when a person attends meetings in different rooms that are close in time.
+    Uses weighted penalty: back-to-back room switches cost more than switches with gaps.
+    """
+    return (
+        constraint_factory.for_each(Attendance)
+        .join(
+            Attendance,
+            Joiners.equal(lambda a: a.person),
+            Joiners.filtering(lambda left, right: left.meeting_id != right.meeting_id),
+        )
+        .join(
+            MeetingAssignment,
+            Joiners.equal(
+                lambda left, right: left.meeting_id,
+                lambda assignment: assignment.meeting.id,
+            ),
+        )
+        .join(
+            MeetingAssignment,
+            Joiners.equal(
+                lambda left, right, left_assignment: right.meeting_id,
+                lambda assignment: assignment.meeting.id,
+            ),
+            Joiners.less_than(
+                lambda left, right, left_assignment: left_assignment.get_grain_index(),
+                lambda assignment: assignment.get_grain_index(),
+            ),
+            Joiners.filtering(
+                lambda left, right, left_assignment, right_assignment: left_assignment.room != right_assignment.room
+            ),
+            Joiners.filtering(
+                lambda left, right, left_assignment, right_assignment: right_assignment.get_grain_index()
+                - left_assignment.meeting.duration_in_grains
+                - left_assignment.get_grain_index()
+                <= 2
+            ),
+        )
+        .penalize(
+            HardMediumSoftScore.ONE_SOFT,
+            lambda left, right, left_assignment, right_assignment: 3 - (
+                right_assignment.get_grain_index()
+                - left_assignment.meeting.duration_in_grains
+                - left_assignment.get_grain_index()
+            ),
+        )
+        .as_constraint("Room stability")
+    )

src/meeting_scheduling/converters.py

@@ -0,0 +1,325 @@
+from typing import List, Optional, Union
+from . import domain
+from .json_serialization import JsonDomainBase
+from pydantic import Field
+
+
+# Pydantic models for API boundary
+class PersonModel(JsonDomainBase):
+    id: str
+    full_name: str
+
+
+class TimeGrainModel(JsonDomainBase):
+    id: str
+    grain_index: int
+    day_of_year: int
+    starting_minute_of_day: int
+
+
+class RoomModel(JsonDomainBase):
+    id: str
+    name: str
+    capacity: int
+
+
+class RequiredAttendanceModel(JsonDomainBase):
+    id: str
+    person: PersonModel
+    meeting_id: str = Field(..., alias="meeting")
+
+
+class PreferredAttendanceModel(JsonDomainBase):
+    id: str
+    person: PersonModel
+    meeting_id: str = Field(..., alias="meeting")
+
+
+class MeetingModel(JsonDomainBase):
+    id: str
+    topic: str
+    duration_in_grains: int
+    speakers: Optional[List[PersonModel]] = None
+    content: Optional[str] = None
+    entire_group_meeting: bool = False
+    required_attendances: List[RequiredAttendanceModel] = Field(
+        default_factory=list, alias="requiredAttendances"
+    )
+    preferred_attendances: List[PreferredAttendanceModel] = Field(
+        default_factory=list, alias="preferredAttendances"
+    )
+
+
+class MeetingAssignmentModel(JsonDomainBase):
+    id: str
+    meeting: Union[str, MeetingModel]
+    pinned: bool = False
+    starting_time_grain: Union[str, TimeGrainModel, None] = None
+    room: Union[str, RoomModel, None] = None
+
+
+class MeetingScheduleModel(JsonDomainBase):
+    people: List[PersonModel]
+    time_grains: List[TimeGrainModel] = Field(..., alias="timeGrains")
+    rooms: List[RoomModel]
+    meetings: List[MeetingModel]
+    required_attendances: List[RequiredAttendanceModel] = Field(
+        default_factory=list, alias="requiredAttendances"
+    )
+    preferred_attendances: List[PreferredAttendanceModel] = Field(
+        default_factory=list, alias="preferredAttendances"
+    )
+    meeting_assignments: List[MeetingAssignmentModel] = Field(
+        default_factory=list, alias="meetingAssignments"
+    )
+    score: Optional[str] = None
+    solver_status: Optional[str] = None
+
+
+# Conversion functions from domain to API models
+def person_to_model(person: domain.Person) -> PersonModel:
+    return PersonModel(id=person.id, full_name=person.full_name)
+
+
+def time_grain_to_model(time_grain: domain.TimeGrain) -> TimeGrainModel:
+    return TimeGrainModel(
+        id=time_grain.id,
+        grain_index=time_grain.grain_index,
+        day_of_year=time_grain.day_of_year,
+        starting_minute_of_day=time_grain.starting_minute_of_day,
+    )
+
+
+def room_to_model(room: domain.Room) -> RoomModel:
+    return RoomModel(id=room.id, name=room.name, capacity=room.capacity)
+
+
+def required_attendance_to_model(
+    attendance: domain.RequiredAttendance,
+) -> RequiredAttendanceModel:
+    return RequiredAttendanceModel(
+        id=attendance.id,
+        person=person_to_model(attendance.person),
+        meeting_id=attendance.meeting_id,
+    )
+
+
+def preferred_attendance_to_model(
+    attendance: domain.PreferredAttendance,
+) -> PreferredAttendanceModel:
+    return PreferredAttendanceModel(
+        id=attendance.id,
+        person=person_to_model(attendance.person),
+        meeting_id=attendance.meeting_id,
+    )
+
+
+def meeting_to_model(meeting: domain.Meeting) -> MeetingModel:
+    return MeetingModel(
+        id=meeting.id,
+        topic=meeting.topic,
+        duration_in_grains=meeting.duration_in_grains,
+        speakers=[person_to_model(p) for p in meeting.speakers]
+        if meeting.speakers
+        else None,
+        content=meeting.content,
+        entire_group_meeting=meeting.entire_group_meeting,
+        required_attendances=[
+            required_attendance_to_model(ra) for ra in meeting.required_attendances
+        ],
+        preferred_attendances=[
+            preferred_attendance_to_model(pa) for pa in meeting.preferred_attendances
+        ],
+    )
+
+
+def meeting_assignment_to_model(
+    assignment: domain.MeetingAssignment,
+) -> MeetingAssignmentModel:
+    return MeetingAssignmentModel(
+        id=assignment.id,
+        meeting=meeting_to_model(assignment.meeting),
+        pinned=assignment.pinned,
+        starting_time_grain=time_grain_to_model(assignment.starting_time_grain)
+        if assignment.starting_time_grain
+        else None,
+        room=room_to_model(assignment.room) if assignment.room else None,
+    )
+
+
+def schedule_to_model(schedule: domain.MeetingSchedule) -> MeetingScheduleModel:
+    return MeetingScheduleModel(
+        people=[person_to_model(p) for p in schedule.people],
+        time_grains=[time_grain_to_model(tg) for tg in schedule.time_grains],
+        rooms=[room_to_model(r) for r in schedule.rooms],
+        meetings=[meeting_to_model(m) for m in schedule.meetings],
+        required_attendances=[
+            required_attendance_to_model(ra) for ra in schedule.required_attendances
+        ],
+        preferred_attendances=[
+            preferred_attendance_to_model(pa) for pa in schedule.preferred_attendances
+        ],
+        meeting_assignments=[
+            meeting_assignment_to_model(ma) for ma in schedule.meeting_assignments
+        ],
+        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_person(model: PersonModel) -> domain.Person:
+    return domain.Person(id=model.id, full_name=model.full_name)
+
+
+def model_to_time_grain(model: TimeGrainModel) -> domain.TimeGrain:
+    return domain.TimeGrain(
+        id=model.id,
+        grain_index=model.grain_index,
+        day_of_year=model.day_of_year,
+        starting_minute_of_day=model.starting_minute_of_day,
+    )
+
+
+def model_to_room(model: RoomModel) -> domain.Room:
+    return domain.Room(id=model.id, name=model.name, capacity=model.capacity)
+
+
+def model_to_required_attendance(
+    model: RequiredAttendanceModel,
+) -> domain.RequiredAttendance:
+    return domain.RequiredAttendance(
+        id=model.id, person=model_to_person(model.person), meeting_id=model.meeting_id
+    )
+
+
+def model_to_preferred_attendance(
+    model: PreferredAttendanceModel,
+) -> domain.PreferredAttendance:
+    return domain.PreferredAttendance(
+        id=model.id, person=model_to_person(model.person), meeting_id=model.meeting_id
+    )
+
+
+def model_to_meeting(model: MeetingModel) -> domain.Meeting:
+    return domain.Meeting(
+        id=model.id,
+        topic=model.topic,
+        duration_in_grains=model.duration_in_grains,
+        speakers=[model_to_person(p) for p in model.speakers]
+        if model.speakers
+        else None,
+        content=model.content,
+        entire_group_meeting=model.entire_group_meeting,
+        required_attendances=[
+            model_to_required_attendance(ra) for ra in model.required_attendances
+        ],
+        preferred_attendances=[
+            model_to_preferred_attendance(pa) for pa in model.preferred_attendances
+        ],
+    )
+
+
+def model_to_meeting_assignment(
+    model: MeetingAssignmentModel,
+    meeting_lookup: dict,
+    room_lookup: dict,
+    time_grain_lookup: dict,
+) -> domain.MeetingAssignment:
+    # Handle meeting reference
+    if isinstance(model.meeting, str):
+        meeting = meeting_lookup[model.meeting]
+    else:
+        meeting = model_to_meeting(model.meeting)
+
+    # Handle room reference
+    room = None
+    if model.room:
+        if isinstance(model.room, str):
+            room = room_lookup[model.room]
+        else:
+            room = model_to_room(model.room)
+
+    # Handle time grain reference
+    starting_time_grain = None
+    if model.starting_time_grain:
+        if isinstance(model.starting_time_grain, str):
+            starting_time_grain = time_grain_lookup[model.starting_time_grain]
+        else:
+            starting_time_grain = model_to_time_grain(model.starting_time_grain)
+
+    return domain.MeetingAssignment(
+        id=model.id,
+        meeting=meeting,
+        pinned=model.pinned,
+        starting_time_grain=starting_time_grain,
+        room=room,
+    )
+
+
+def model_to_schedule(model: MeetingScheduleModel) -> domain.MeetingSchedule:
+    # Convert basic collections first
+    people = [model_to_person(p) for p in model.people]
+    time_grains = [model_to_time_grain(tg) for tg in model.time_grains]
+    rooms = [model_to_room(r) for r in model.rooms]
+    meetings = [model_to_meeting(m) for m in model.meetings]
+
+    # Create lookup dictionaries for references
+    meeting_lookup = {m.id: m for m in meetings}
+    room_lookup = {r.id: r for r in rooms}
+    time_grain_lookup = {tg.id: tg for tg in time_grains}
+
+    # Convert meeting assignments with lookups
+    meeting_assignments = [
+        model_to_meeting_assignment(ma, meeting_lookup, room_lookup, time_grain_lookup)
+        for ma in model.meeting_assignments
+    ]
+
+    # Convert attendances
+    required_attendances = [
+        model_to_required_attendance(ra) for ra in model.required_attendances
+    ]
+    preferred_attendances = [
+        model_to_preferred_attendance(pa) for pa in model.preferred_attendances
+    ]
+
+    # Build combined attendances list for room_stability constraint
+    people_lookup = {p.id: p for p in people}
+    attendances = []
+    for ra in required_attendances:
+        attendances.append(domain.Attendance(
+            id=ra.id,
+            person=ra.person,
+            meeting_id=ra.meeting_id,
+        ))
+    for pa in preferred_attendances:
+        attendances.append(domain.Attendance(
+            id=pa.id,
+            person=pa.person,
+            meeting_id=pa.meeting_id,
+        ))
+
+    # Handle score
+    score = None
+    if model.score:
+        from solverforge_legacy.solver.score import HardMediumSoftScore
+
+        score = HardMediumSoftScore.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.MeetingSchedule(
+        people=people,
+        time_grains=time_grains,
+        rooms=rooms,
+        meetings=meetings,
+        required_attendances=required_attendances,
+        preferred_attendances=preferred_attendances,
+        attendances=attendances,
+        meeting_assignments=meeting_assignments,
+        score=score,
+        solver_status=solver_status,
+    )

src/meeting_scheduling/demo_data.py

@@ -0,0 +1,225 @@
+from random import Random
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import List
+from dataclasses import dataclass
+
+from .domain import Person, TimeGrain, Room, Meeting, MeetingAssignment, MeetingSchedule, RequiredAttendance, PreferredAttendance
+
+class DemoData(str, Enum):
+    SMALL = "SMALL"
+    MEDIUM = "MEDIUM"
+    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)
+
+def generate_demo_data() -> MeetingSchedule:
+    """Generate demo data for the meeting scheduling problem."""
+    rnd = Random(0)  # For reproducible results
+    
+    # People
+    people = generate_people(20, rnd)
+    
+    # Time grains
+    time_grains = generate_time_grains()
+    
+    # Rooms
+    rooms = [
+        Room(id="R1", name="Room 1", capacity=30),
+        Room(id="R2", name="Room 2", capacity=20),
+        Room(id="R3", name="Room 3", capacity=16)
+    ]
+    
+    # Meetings
+    meetings = generate_meetings(people, rnd)
+    
+    # Rebuild meetings with correct attendances
+    all_required_attendances = [ra for meeting in meetings for ra in meeting.required_attendances]
+    all_preferred_attendances = [pa for meeting in meetings for pa in meeting.preferred_attendances]
+    new_meetings = []
+    for m in meetings:
+        new_meetings.append(
+            type(m)(
+                id=m.id,
+                topic=m.topic,
+                duration_in_grains=m.duration_in_grains,
+                speakers=m.speakers,
+                content=m.content or "",
+                entire_group_meeting=m.entire_group_meeting,
+                required_attendances=[a for a in all_required_attendances if a.meeting_id == m.id],
+                preferred_attendances=[a for a in all_preferred_attendances if a.meeting_id == m.id],
+            )
+        )
+    meetings = new_meetings
+    
+    # Meeting assignments
+    meeting_assignments = generate_meeting_assignments(meetings)
+    
+    # Create schedule
+    schedule = MeetingSchedule(
+        people=people,
+        time_grains=time_grains,
+        rooms=rooms,
+        meetings=meetings,
+        meeting_assignments=meeting_assignments,
+        required_attendances=[ra for meeting in meetings for ra in meeting.required_attendances],
+        preferred_attendances=[pa for meeting in meetings for pa in meeting.preferred_attendances],
+    )
+    
+    return schedule
+
+
+def generate_people(count_people: int, rnd: Random) -> List[Person]:
+    """Generate a list of people."""
+    FIRST_NAMES = ["Amy", "Beth", "Carl", "Dan", "Elsa", "Flo", "Gus", "Hugo", "Ivy", "Jay",
+                  "Jeri", "Hope", "Avis", "Lino", "Lyle", "Nick", "Dino", "Otha", "Gwen", "Jose", 
+                  "Dena", "Jana", "Dave", "Russ", "Josh", "Dana", "Katy"]
+    LAST_NAMES = ["Cole", "Fox", "Green", "Jones", "King", "Li", "Poe", "Rye", "Smith", "Watt", 
+                 "Howe", "Lowe", "Wise", "Clay", "Carr", "Hood", "Long", "Horn", "Haas", "Meza"]
+    
+    def generate_name() -> str:
+        first_name = rnd.choice(FIRST_NAMES)
+        last_name = rnd.choice(LAST_NAMES)
+        return f"{first_name} {last_name}"
+    
+    return [Person(id=str(i), full_name=generate_name()) for i in range(count_people)]
+
+
+def generate_time_grains() -> List[TimeGrain]:
+    """Generate time grains for the next 4 days starting from tomorrow."""
+    time_grains = []
+    current_date = datetime.now().date() + timedelta(days=1)
+    count = 0
+    
+    while current_date < datetime.now().date() + timedelta(days=5):  # Match Java: from +1 to +5 (4 days)
+        current_time = datetime.combine(current_date, datetime.min.time()) + timedelta(hours=8)  # Start at 8:00
+        end_time = datetime.combine(current_date, datetime.min.time()) + timedelta(hours=17, minutes=45)  # End at 17:45
+        
+        while current_time <= end_time:
+            day_of_year = current_date.timetuple().tm_yday
+            minutes_of_day = current_time.hour * 60 + current_time.minute
+            
+            count += 1  # Pre-increment like Java ++count
+            time_grains.append(TimeGrain(
+                id=str(count),
+                grain_index=count,
+                day_of_year=day_of_year,
+                starting_minute_of_day=minutes_of_day
+            ))
+            current_time += timedelta(minutes=15)  # 15-minute increments
+        
+        current_date += timedelta(days=1)
+    
+    return time_grains
+
+
+def generate_meetings(people: List[Person], rnd: Random) -> List[Meeting]:
+    """Generate meetings with topics and attendees."""
+    meeting_topics = [
+        "Strategize B2B", "Fast track e-business", "Cross sell virtualization",
+        "Profitize multitasking", "Transform one stop shop", "Engage braindumps",
+        "Downsize data mining", "Ramp up policies", "On board synergies",
+        "Reinvigorate user experience", "Strategize e-business", "Fast track virtualization",
+        "Cross sell multitasking", "Profitize one stop shop", "Transform braindumps",
+        "Engage data mining", "Downsize policies", "Ramp up synergies",
+        "On board user experience", "Reinvigorate B2B", "Strategize virtualization",
+        "Fast track multitasking", "Cross sell one stop shop", "Reinvigorate multitasking"
+    ]
+    
+    meetings = []
+    for i, topic in enumerate(meeting_topics):
+        meeting = Meeting(id=str(i), topic=topic, duration_in_grains=0)
+        meetings.append(meeting)
+    
+    # Set durations using CountDistribution and random.choices
+    duration_distribution = (
+        CountDistribution(count=8, weight=1),   # 33% with 8 time grains
+        CountDistribution(count=12, weight=1),  # 33% with 12 time grains
+        CountDistribution(count=16, weight=1)   # 33% with 16 time grains
+    )
+
+    for meeting in meetings:
+        duration_time_grains, = rnd.choices(population=counts(duration_distribution),
+                                           weights=weights(duration_distribution))
+        meeting.duration_in_grains = duration_time_grains
+    
+    # Add required attendees using CountDistribution - slightly reduced to make more feasible
+    required_attendees_distribution = (
+        CountDistribution(count=2, weight=0.45),  # More 2-person meetings
+        CountDistribution(count=3, weight=0.15),  # More 3-person meetings
+        CountDistribution(count=4, weight=0.10),  # Increased 4-person
+        CountDistribution(count=5, weight=0.10),  # Slightly more 5-person
+        CountDistribution(count=6, weight=0.08),  # Reduced larger meetings
+        CountDistribution(count=7, weight=0.05),
+        CountDistribution(count=8, weight=0.04),
+        CountDistribution(count=10, weight=0.03)  # Reduced 10-person meetings
+    )
+
+    def add_required_attendees(meeting: Meeting, count: int) -> None:
+        # Use random.sample to avoid duplicates
+        selected_people = rnd.sample(people, count)
+        for person in selected_people:
+            meeting.required_attendances.append(
+                RequiredAttendance(
+                    id=f"{meeting.id}-{len(meeting.required_attendances) + 1}",
+                    person=person,
+                    meeting_id=meeting.id
+                )
+            )
+
+    for meeting in meetings:
+        count, = rnd.choices(population=counts(required_attendees_distribution),
+                            weights=weights(required_attendees_distribution))
+        add_required_attendees(meeting, count)
+    
+    # Add preferred attendees using CountDistribution - reduced to make more feasible
+    preferred_attendees_distribution = (
+        CountDistribution(count=1, weight=0.25),  # More 1-person preferred
+        CountDistribution(count=2, weight=0.30),  # More 2-person preferred
+        CountDistribution(count=3, weight=0.20),  # More 3-person preferred
+        CountDistribution(count=4, weight=0.10),  # Increased 4-person
+        CountDistribution(count=5, weight=0.06),  # Slightly more 5-person
+        CountDistribution(count=6, weight=0.04),  # Reduced larger groups
+        CountDistribution(count=7, weight=0.02),  # Reduced
+        CountDistribution(count=8, weight=0.02),  # Reduced
+        CountDistribution(count=9, weight=0.01),  # Minimal large groups
+        CountDistribution(count=10, weight=0.00) # Eliminated 10-person preferred
+    )
+
+    def add_preferred_attendees(meeting: Meeting, count: int) -> None:
+        # Get people not already required for this meeting
+        required_people_ids = {ra.person.id for ra in meeting.required_attendances}
+        available_people = [person for person in people if person.id not in required_people_ids]
+        
+        # Use random.sample to avoid duplicates, but only if we have enough people
+        if len(available_people) >= count:
+            selected_people = rnd.sample(available_people, count)
+            for person in selected_people:
+                meeting.preferred_attendances.append(
+                    PreferredAttendance(
+                        id=f"{meeting.id}-{len(meeting.required_attendances) + len(meeting.preferred_attendances) + 1}",
+                        person=person,
+                        meeting_id=meeting.id
+                    )
+                )
+            
+    for meeting in meetings:
+        count, = rnd.choices(population=counts(preferred_attendees_distribution),
+                            weights=weights(preferred_attendees_distribution))
+        add_preferred_attendees(meeting, count)
+    
+    return meetings
+
+
+def generate_meeting_assignments(meetings: List[Meeting]) -> List[MeetingAssignment]:
+    """Generate meeting assignments for each meeting."""
+    return [MeetingAssignment(id=str(i), meeting=meeting) for i, meeting in enumerate(meetings)]

src/meeting_scheduling/domain.py

@@ -0,0 +1,247 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Annotated, Union
+from solverforge_legacy.solver.domain import (
+    planning_entity,
+    planning_solution,
+    PlanningId,
+    PlanningVariable,
+    PlanningEntityCollectionProperty,
+    ProblemFactCollectionProperty,
+    ValueRangeProvider,
+    PlanningScore,
+    PlanningPin,
+)
+from solverforge_legacy.solver import SolverStatus
+from solverforge_legacy.solver.score import HardMediumSoftScore
+from .json_serialization import JsonDomainBase
+from pydantic import Field
+
+# Time granularity is 15 minutes (which is often recommended when dealing with humans for practical purposes).
+GRAIN_LENGTH_IN_MINUTES = 15
+
+
+@dataclass
+class Person:
+    id: Annotated[str, PlanningId]
+    full_name: str
+
+
+@dataclass
+class TimeGrain:
+    id: Annotated[str, PlanningId]
+    grain_index: int
+    day_of_year: int
+    starting_minute_of_day: int
+
+
+@dataclass
+class Room:
+    id: Annotated[str, PlanningId]
+    name: str
+    capacity: int
+
+
+# Define Attendance base class and subclasses before Meeting to avoid forward references
+@dataclass
+class Attendance:
+    id: Annotated[str, PlanningId]
+    person: Person
+    meeting_id: str
+
+
+@dataclass
+class RequiredAttendance:
+    id: Annotated[str, PlanningId]
+    person: Person
+    meeting_id: str
+
+
+@dataclass
+class PreferredAttendance:
+    id: Annotated[str, PlanningId]
+    person: Person
+    meeting_id: str
+
+
+@dataclass
+class Meeting:
+    id: Annotated[str, PlanningId]
+    topic: str
+    duration_in_grains: int
+    speakers: Optional[List[Person]] = None
+    content: Optional[str] = None
+    entire_group_meeting: bool = False
+    required_attendances: List[RequiredAttendance] = field(default_factory=list)
+    preferred_attendances: List[PreferredAttendance] = field(default_factory=list)
+
+    def get_required_capacity(self) -> int:
+        return len(self.required_attendances) + len(self.preferred_attendances)
+
+    def add_required_attendant(self, person: Person) -> None:
+        person_id = person.id
+        for r in self.required_attendances:
+            if r.person.id == person_id:
+                raise ValueError(
+                    f"The person {person_id} is already assigned to the meeting {self.id}."
+                )
+        self.required_attendances.append(
+            RequiredAttendance(
+                id=f"{self.id}-{self.get_required_capacity() + 1}",
+                meeting_id=self.id,
+                person=person,
+            )
+        )
+
+    def add_preferred_attendant(self, person: Person) -> None:
+        person_id = person.id
+        for p in self.preferred_attendances:
+            if p.person.id == person_id:
+                raise ValueError(
+                    f"The person {person_id} is already assigned to the meeting {self.id}."
+                )
+        self.preferred_attendances.append(
+            PreferredAttendance(
+                id=f"{self.id}-{self.get_required_capacity() + 1}",
+                meeting_id=self.id,
+                person=person,
+            )
+        )
+
+
+@planning_entity
+@dataclass
+class MeetingAssignment:
+    id: Annotated[str, PlanningId]
+    meeting: Meeting
+    pinned: Annotated[bool, PlanningPin] = False
+    starting_time_grain: Annotated[Optional[TimeGrain], PlanningVariable] = None
+    room: Annotated[Optional[Room], PlanningVariable] = None
+
+    def get_grain_index(self) -> Optional[int]:
+        if self.starting_time_grain is None:
+            return None
+        return self.starting_time_grain.grain_index
+
+    def calculate_overlap(self, other: "MeetingAssignment") -> int:
+        if self.starting_time_grain is None or other.starting_time_grain is None:
+            return 0
+        # start is inclusive, end is exclusive
+        start = self.starting_time_grain.grain_index
+        end = self.get_last_time_grain_index() + 1
+        other_start = other.starting_time_grain.grain_index
+        other_end = other.get_last_time_grain_index() + 1
+
+        if other_end < start or end < other_start:
+            return 0
+
+        return min(end, other_end) - max(start, other_start)
+
+    def get_last_time_grain_index(self) -> Optional[int]:
+        if self.starting_time_grain is None:
+            return None
+        return (
+            self.starting_time_grain.grain_index + self.meeting.duration_in_grains - 1
+        )
+
+    def get_room_capacity(self) -> int:
+        if self.room is None:
+            return 0
+        return self.room.capacity
+
+    def get_required_capacity(self) -> int:
+        return self.meeting.get_required_capacity()
+
+
+@planning_solution
+@dataclass
+class MeetingSchedule:
+    people: Annotated[List[Person], ProblemFactCollectionProperty]
+    time_grains: Annotated[
+        List[TimeGrain], ProblemFactCollectionProperty, ValueRangeProvider
+    ]
+    rooms: Annotated[List[Room], ProblemFactCollectionProperty, ValueRangeProvider]
+    meetings: Annotated[List[Meeting], ProblemFactCollectionProperty]
+    required_attendances: Annotated[
+        List[RequiredAttendance], ProblemFactCollectionProperty
+    ] = field(default_factory=list)
+    preferred_attendances: Annotated[
+        List[PreferredAttendance], ProblemFactCollectionProperty
+    ] = field(default_factory=list)
+    attendances: Annotated[
+        List[Attendance], ProblemFactCollectionProperty
+    ] = field(default_factory=list)
+    meeting_assignments: Annotated[
+        List[MeetingAssignment], PlanningEntityCollectionProperty
+    ] = field(default_factory=list)
+    score: Annotated[Optional[HardMediumSoftScore], PlanningScore] = None
+    solver_status: SolverStatus = SolverStatus.NOT_SOLVING
+
+
+# Pydantic REST models for API (used for deserialization and context)
+class PersonModel(JsonDomainBase):
+    id: str
+    full_name: str
+
+
+class TimeGrainModel(JsonDomainBase):
+    id: str
+    grain_index: int
+    day_of_year: int
+    starting_minute_of_day: int
+
+
+class RoomModel(JsonDomainBase):
+    id: str
+    name: str
+    capacity: int
+
+
+class RequiredAttendanceModel(JsonDomainBase):
+    id: str
+    person: PersonModel
+    meeting_id: str = Field(..., alias="meeting")
+
+
+class PreferredAttendanceModel(JsonDomainBase):
+    id: str
+    person: PersonModel
+    meeting_id: str = Field(..., alias="meeting")
+
+
+class MeetingModel(JsonDomainBase):
+    id: str
+    topic: str
+    duration_in_grains: int
+    speakers: Optional[List[PersonModel]] = None
+    content: Optional[str] = None
+    entire_group_meeting: bool = False
+    required_attendances: List[RequiredAttendanceModel] = Field(
+        default_factory=list, alias="requiredAttendances"
+    )
+    preferred_attendances: List[PreferredAttendanceModel] = Field(
+        default_factory=list, alias="preferredAttendances"
+    )
+
+
+class MeetingAssignmentModel(JsonDomainBase):
+    id: str
+    meeting: Union[str, MeetingModel]
+    pinned: bool = False
+    starting_time_grain: Union[str, TimeGrainModel, None] = None
+    room: Union[str, RoomModel, None] = None
+
+
+class MeetingScheduleModel(JsonDomainBase):
+    people: List[PersonModel]
+    time_grains: List[TimeGrainModel]
+    rooms: List[RoomModel]
+    meetings: List[MeetingModel]
+    required_attendances: List[RequiredAttendanceModel] = Field(
+        default_factory=list, alias="requiredAttendances"
+    )
+    preferred_attendances: List[PreferredAttendanceModel] = Field(
+        default_factory=list, alias="preferredAttendances"
+    )
+    meeting_assignments: List[MeetingAssignmentModel] = Field(default_factory=list)
+    score: Optional[str] = None
+    solver_status: Optional[str] = None

src/meeting_scheduling/json_serialization.py

@@ -0,0 +1,55 @@
+from solverforge_legacy.solver.score import HardMediumSoftScore
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    PlainSerializer,
+    BeforeValidator,
+    ValidationInfo,
+)
+from pydantic.alias_generators import to_camel
+from typing import Any
+
+
+def make_list_item_validator(key: str):
+    def validator(v: Any, info: ValidationInfo) -> Any:
+        if v is None:
+            return None
+
+        if not isinstance(v, str) or not info.context:
+            return v
+
+        return info.context.get(key, {}).get(v, v)
+
+    return BeforeValidator(validator)
+
+
+# Validators for foreign key references
+MeetingDeserializer = make_list_item_validator("meetings")
+RoomDeserializer = make_list_item_validator("rooms")
+TimeGrainDeserializer = make_list_item_validator("timeGrains")
+
+IdSerializer = PlainSerializer(
+    lambda item: item.id if item is not None else None, return_type=str | None
+)
+ScoreSerializer = PlainSerializer(
+    lambda score: str(score) if score is not None else None, return_type=str | None
+)
+
+
+def validate_score(v: Any, info: ValidationInfo) -> Any:
+    if isinstance(v, HardMediumSoftScore) or v is None:
+        return v
+    if isinstance(v, str):
+        return HardMediumSoftScore.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/meeting_scheduling/rest_api.py

@@ -0,0 +1,163 @@
+from fastapi import FastAPI, Request
+from fastapi.staticfiles import StaticFiles
+from typing import Dict, List
+from uuid import uuid4
+
+from .domain import MeetingSchedule
+from .converters import MeetingScheduleModel, schedule_to_model, model_to_schedule
+from .demo_data import generate_demo_data
+from .solver import solver_manager, solution_manager
+from .score_analysis import ConstraintAnalysisDTO, MatchAnalysisDTO
+
+app = FastAPI(docs_url="/q/swagger-ui")
+
+# Dictionary to store submitted data sets (using domain models internally)
+data_sets: Dict[str, MeetingSchedule] = {}
+
+
+@app.get("/demo-data")
+async def list_demo_data() -> List[str]:
+    """List available demo data sets."""
+    return ["SMALL", "MEDIUM", "LARGE"]
+
+
+@app.get("/demo-data/{dataset_id}")
+async def get_demo_data(dataset_id: str) -> MeetingScheduleModel:
+    """Get a demo data set by ID."""
+    domain_schedule = generate_demo_data()
+    return schedule_to_model(domain_schedule)
+
+
+@app.get("/schedules")
+async def list_schedules() -> List[str]:
+    """List all job IDs of submitted schedules."""
+    return list(data_sets.keys())
+
+
+@app.get("/schedules/{schedule_id}")
+async def get_schedule(schedule_id: str) -> MeetingScheduleModel:
+    """Get the solution and score for a given job ID."""
+    if schedule_id not in data_sets:
+        raise ValueError(f"No schedule found with ID {schedule_id}")
+
+    schedule = data_sets[schedule_id]
+    solver_status = solver_manager.get_solver_status(schedule_id)
+    schedule.solver_status = solver_status
+
+    return schedule_to_model(schedule)
+
+
+@app.get("/schedules/{problem_id}/status")
+async def get_status(problem_id: str) -> Dict:
+    """Get the schedule status and score for a given job ID."""
+    if problem_id not in data_sets:
+        raise ValueError(f"No schedule found with ID {problem_id}")
+
+    schedule = data_sets[problem_id]
+    solver_status = solver_manager.get_solver_status(problem_id)
+
+    return {
+        "score": {
+            "hardScore": schedule.score.hard_score if schedule.score else 0,
+            "mediumScore": schedule.score.medium_score if schedule.score else 0,
+            "softScore": schedule.score.soft_score if schedule.score else 0,
+        },
+        "solverStatus": solver_status.name,
+    }
+
+
+@app.delete("/schedules/{problem_id}")
+async def terminate_solving(problem_id: str) -> MeetingScheduleModel:
+    """Terminate solving for a given job ID."""
+    if problem_id not in data_sets:
+        raise ValueError(f"No schedule found with ID {problem_id}")
+
+    try:
+        solver_manager.terminate_early(problem_id)
+    except Exception as e:
+        print(f"Warning: terminate_early failed for {problem_id}: {e}")
+
+    return await get_schedule(problem_id)
+
+
+def update_schedule(problem_id: str, schedule: MeetingSchedule) -> None:
+    """Update the schedule in the data sets."""
+    global data_sets
+    data_sets[problem_id] = schedule
+
+
+@app.post("/schedules")
+async def solve_schedule(request: Request) -> str:
+    json_data = await request.json()
+    job_id = str(uuid4())
+
+    # Parse the incoming JSON using Pydantic models
+    schedule_model = MeetingScheduleModel.model_validate(json_data)
+
+    # Convert to domain model for solver
+    domain_schedule = model_to_schedule(schedule_model)
+
+    data_sets[job_id] = domain_schedule
+    solver_manager.solve_and_listen(
+        job_id, domain_schedule, lambda solution: update_schedule(job_id, solution)
+    )
+    return job_id
+
+
+@app.put("/schedules/analyze")
+async def analyze_schedule(request: Request) -> Dict:
+    """Submit a schedule to analyze its score."""
+    json_data = await request.json()
+
+    # Parse the incoming JSON using Pydantic models
+    schedule_model = MeetingScheduleModel.model_validate(json_data)
+
+    # Convert to domain model for analysis
+    domain_schedule = model_to_schedule(schedule_model)
+
+    analysis = solution_manager.analyze(domain_schedule)
+
+    def serialize_justification(justification):
+        """Convert justification facts to serializable dicts."""
+        if justification is None:
+            return None
+        facts = []
+        for fact in getattr(justification, 'facts', []):
+            fact_dict = {'id': getattr(fact, 'id', None)}
+            # MeetingAssignment - has meeting attribute
+            if hasattr(fact, 'meeting'):
+                fact_dict['type'] = 'assignment'
+                fact_dict['meeting'] = getattr(fact.meeting, 'id', None) if fact.meeting else None
+            # RequiredAttendance/PreferredAttendance - has person and meeting_id
+            elif hasattr(fact, 'person') and hasattr(fact, 'meeting_id'):
+                fact_dict['type'] = 'attendance'
+                fact_dict['personId'] = getattr(fact.person, 'id', None) if fact.person else None
+                fact_dict['meetingId'] = fact.meeting_id
+            facts.append(fact_dict)
+        return {'facts': facts}
+
+    # Convert to proper DTOs for correct serialization
+    constraints = []
+    for constraint in analysis.constraint_analyses:
+        matches = [
+            MatchAnalysisDTO(
+                name=match.constraint_ref.constraint_name,
+                score=match.score,
+                justification=serialize_justification(match.justification),
+            )
+            for match in constraint.matches
+        ]
+
+        constraint_dto = ConstraintAnalysisDTO(
+            name=constraint.constraint_name,
+            weight=constraint.weight,
+            score=constraint.score,
+            matches=matches,
+        )
+        constraints.append(constraint_dto)
+
+    return {"constraints": [constraint.model_dump() for constraint in constraints]}
+
+
+# Mount static files
+app.mount("/", StaticFiles(directory="static", html=True), name="static")

src/meeting_scheduling/score_analysis.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+from typing import List, Any, Annotated
+from solverforge_legacy.solver.score import HardMediumSoftScore
+from .json_serialization import ScoreSerializer
+
+
+class MatchAnalysisDTO(BaseModel):
+    name: str
+    score: Annotated[HardMediumSoftScore, ScoreSerializer]
+    justification: Any
+
+
+class ConstraintAnalysisDTO(BaseModel):
+    name: str
+    weight: Annotated[HardMediumSoftScore, ScoreSerializer]
+    score: Annotated[HardMediumSoftScore, ScoreSerializer]
+    matches: List[MatchAnalysisDTO]

src/meeting_scheduling/solver.py

@@ -0,0 +1,22 @@
+from solverforge_legacy.solver import SolverManager, SolverFactory, SolutionManager
+from solverforge_legacy.solver.config import (
+    SolverConfig,
+    ScoreDirectorFactoryConfig,
+    TerminationConfig,
+    Duration,
+)
+
+from .domain import MeetingSchedule, MeetingAssignment
+from .constraints import define_constraints
+
+solver_config = SolverConfig(
+    solution_class=MeetingSchedule,
+    entity_class_list=[MeetingAssignment],
+    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,1023 @@
+let autoRefreshIntervalId = null;
+const formatter = JSJoda.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+const startTime = formatter.format(JSJoda.LocalDateTime.now().withHour(20).withMinute(0).withSecond(0));
+const endTime = formatter.format(JSJoda.LocalDateTime.now().plusDays(1).withHour(8).withMinute(0).withSecond(0));
+const zoomMin = 1000 * 60 * 60 // one hour in milliseconds
+const zoomMax = 4 * 1000 * 60 * 60 * 24 // 5 days in milliseconds
+
+const byTimelineOptions = {
+    timeAxis: {scale: "hour", step: 1},
+    orientation: {axis: "top"},
+    stack: false,
+    xss: {disabled: true}, // Items are XSS safe through JQuery
+    zoomMin: zoomMin,
+    zoomMax: zoomMax,
+    showCurrentTime: false,
+    hiddenDates: [
+        {
+            start: startTime,
+            end: endTime,
+            repeat: 'daily'
+        }
+    ],
+};
+
+const byRoomPanel = document.getElementById("byRoomPanel");
+let byRoomGroupData = new vis.DataSet();
+let byRoomItemData = new vis.DataSet();
+let byRoomTimeline = new vis.Timeline(byRoomPanel, byRoomItemData, byRoomGroupData, byTimelineOptions);
+
+const byPersonPanel = document.getElementById("byPersonPanel");
+let byPersonGroupData = new vis.DataSet();
+let byPersonItemData = new vis.DataSet();
+let byPersonTimeline = new vis.Timeline(byPersonPanel, byPersonItemData, byPersonGroupData, byTimelineOptions);
+
+let scheduleId = null;
+let loadedSchedule = null;
+let viewType = "R";
+let selectedDemoData = "MEDIUM"; // Default demo data size
+let analyzeCache = null; // Cache for solver's constraint analysis (assignmentId -> violations)
+
+
+let appInitialized = false;
+
+$(document).ready(function () {
+    // Ensure all resources are loaded before initializing
+    $(window).on('load', function() {
+        if (!appInitialized) {
+            appInitialized = true;
+            initializeApp();
+        }
+    });
+
+    // Fallback if window load event doesn't fire
+    setTimeout(function() {
+        if (!appInitialized) {
+            appInitialized = true;
+            initializeApp();
+        }
+    }, 100);
+});
+
+function initializeApp() {
+    replaceQuickstartSolverForgeAutoHeaderFooter();
+
+    $("#solveButton").click(function () {
+        solve();
+    });
+    $("#stopSolvingButton").click(function () {
+        stopSolving();
+    });
+    $("#analyzeButton").click(function () {
+        analyze();
+    });
+    $("#byRoomTab").click(function () {
+        viewType = "R";
+        byRoomTimeline.redraw();
+        refreshSchedule();
+    });
+    $("#byPersonTab").click(function () {
+        viewType = "P";
+        byPersonTimeline.redraw();
+        refreshSchedule();
+    });
+    setupAjax();
+    loadDemoDataDropdown();
+    refreshSchedule();
+}
+
+
+function loadDemoDataDropdown() {
+    $.getJSON("/demo-data", function (demoDataList) {
+        const dropdown = $("#testDataButton");
+        dropdown.empty();
+
+        demoDataList.forEach(function (name) {
+            const isSelected = name === selectedDemoData;
+            const item = $(`<a class="dropdown-item" href="#"></a>`)
+                .text(name)
+                .css("font-weight", isSelected ? "bold" : "normal")
+                .click(function (e) {
+                    e.preventDefault();
+                    selectDemoData(name);
+                });
+            dropdown.append(item);
+        });
+    });
+}
+
+
+function selectDemoData(name) {
+    selectedDemoData = name;
+    scheduleId = null; // Reset solver job
+    loadDemoDataDropdown(); // Refresh dropdown to show selection
+    refreshSchedule();
+}
+
+
+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 refreshSchedule() {
+    let path;
+    if (scheduleId === null) {
+        path = "/demo-data/" + selectedDemoData;
+    } else {
+        path = "/schedules/" + scheduleId;
+    }
+
+    $.getJSON(path, function (schedule) {
+        loadedSchedule = schedule;
+        $('#exportData').attr('href', 'data:text/plain;charset=utf-8,' + JSON.stringify(loadedSchedule));
+        renderSchedule(schedule);
+    })
+        .fail(function (xhr, ajaxOptions, thrownError) {
+            showError("Getting the schedule has failed.", xhr);
+            refreshSolvingButtons(false);
+        });
+}
+
+
+function renderSchedule(schedule) {
+    refreshSolvingButtons(schedule.solverStatus != null && schedule.solverStatus !== "NOT_SOLVING");
+    $("#score").text("Score: " + (schedule.score == null ? "?" : schedule.score));
+
+    // Fetch constraint analysis from solver if we have a score
+    if (schedule.score) {
+        fetchConstraintAnalysis(schedule);
+    } else {
+        // No score yet - clear cache and render with no violations
+        analyzeCache = null;
+        renderViews(schedule);
+    }
+}
+
+
+function renderViews(schedule) {
+    if (viewType === "R") {
+        renderScheduleByRoom(schedule);
+    }
+    if (viewType === "P") {
+        renderScheduleByPerson(schedule);
+    }
+}
+
+
+function fetchConstraintAnalysis(schedule) {
+    $.ajax({
+        url: "/schedules/analyze",
+        type: "PUT",
+        data: JSON.stringify(schedule),
+        contentType: "application/json",
+        success: function(response) {
+            // Build mapping: assignmentId -> { hard: [], medium: [], soft: [] }
+            analyzeCache = new Map();
+
+            for (const constraint of response.constraints) {
+                const type = getConstraintType(constraint.weight);
+
+                for (const match of constraint.matches) {
+                    const assignmentIds = extractAssignmentIds(match.justification, loadedSchedule);
+
+                    for (const id of assignmentIds) {
+                        if (!analyzeCache.has(id)) {
+                            analyzeCache.set(id, { hard: [], medium: [], soft: [] });
+                        }
+                        analyzeCache.get(id)[type].push({
+                            constraint: constraint.name,
+                            score: match.score
+                        });
+                    }
+                }
+            }
+
+            // Re-render with new analysis data
+            renderViews(loadedSchedule);
+        },
+        error: function(xhr, status, error) {
+            console.warn("Failed to fetch constraint analysis:", error);
+            analyzeCache = null;
+            renderViews(schedule);
+        }
+    });
+}
+
+
+function getConstraintType(weight) {
+    // Weight format: "0hard/0medium/-1soft" or "1hard/0medium/0soft"
+    // Extract the non-zero component
+    const hardMatch = weight.match(/(-?\d+)hard/);
+    const mediumMatch = weight.match(/(-?\d+)medium/);
+    const softMatch = weight.match(/(-?\d+)soft/);
+
+    if (hardMatch && parseInt(hardMatch[1], 10) !== 0) return 'hard';
+    if (mediumMatch && parseInt(mediumMatch[1], 10) !== 0) return 'medium';
+    if (softMatch && parseInt(softMatch[1], 10) !== 0) return 'soft';
+
+    return 'soft'; // Default
+}
+
+
+function extractAssignmentIds(justification, schedule) {
+    const ids = new Set();
+    if (!justification?.facts) return [...ids];
+
+    // Build meeting-to-assignment lookup
+    const meetingToAssignment = new Map();
+    if (schedule?.meetingAssignments) {
+        for (const a of schedule.meetingAssignments) {
+            const meetingId = typeof a.meeting === 'object' ? a.meeting.id : a.meeting;
+            meetingToAssignment.set(meetingId, a.id);
+        }
+    }
+
+    for (const fact of justification.facts) {
+        if (fact.type === 'assignment' && fact.id) {
+            ids.add(fact.id);
+        } else if (fact.type === 'attendance' && fact.meetingId) {
+            const assignmentId = meetingToAssignment.get(fact.meetingId);
+            if (assignmentId) ids.add(assignmentId);
+        }
+    }
+    return [...ids];
+}
+
+
+function getConflictStatus(assignmentId) {
+    // Use solver's constraint analysis if available (per-assignment violations)
+    if (analyzeCache && analyzeCache.has(assignmentId)) {
+        const violations = analyzeCache.get(assignmentId);
+
+        if (violations.hard.length > 0) {
+            return {
+                status: 'hard',
+                icon: '<span class="fas fa-exclamation-triangle text-danger me-1"></span>',
+                style: 'background-color: #fee2e2; border-left: 4px solid #dc3545;',
+                reason: violations.hard.map(v => v.constraint).join(', ')
+            };
+        }
+
+        if (violations.medium.length > 0) {
+            return {
+                status: 'medium',
+                icon: '<span class="fas fa-exclamation-circle text-warning me-1"></span>',
+                style: 'background-color: #fef3c7; border-left: 4px solid #ffc107;',
+                reason: violations.medium.map(v => v.constraint).join(', ')
+            };
+        }
+
+        // Don't show soft violations in timeline - they're optimization trade-offs
+        // (e.g., "Overlapping meetings" fires for ANY parallel meetings, even in different rooms)
+        // Users can see soft violations in the "Analyze" modal instead
+    }
+
+    // No hard/medium violations - show green (feasible solution)
+    return {
+        status: 'ok',
+        icon: '<span class="fas fa-check-circle text-success me-1"></span>',
+        style: 'background-color: #d1fae5; border-left: 4px solid #10b981;',
+        reason: ''
+    };
+}
+
+
+function calculatePersonWorkload(schedule) {
+    const personMeetingCount = new Map();
+
+    if (!schedule.meetingAssignments || !schedule.meetings) {
+        return personMeetingCount;
+    }
+
+    const meetingMap = new Map();
+    schedule.meetings.forEach(m => meetingMap.set(m.id, m));
+
+    // Count meetings per person (assigned meetings only)
+    schedule.meetingAssignments.forEach(assignment => {
+        if (assignment.room == null || assignment.startingTimeGrain == null) return;
+
+        const meeting = typeof assignment.meeting === 'string'
+            ? meetingMap.get(assignment.meeting)
+            : assignment.meeting;
+        if (!meeting) return;
+
+        // Count required attendees
+        (meeting.requiredAttendances || []).forEach(att => {
+            const personId = att.person?.id || att.person;
+            personMeetingCount.set(personId, (personMeetingCount.get(personId) || 0) + 1);
+        });
+
+        // Count preferred attendees
+        (meeting.preferredAttendances || []).forEach(att => {
+            const personId = att.person?.id || att.person;
+            personMeetingCount.set(personId, (personMeetingCount.get(personId) || 0) + 1);
+        });
+    });
+
+    return personMeetingCount;
+}
+
+
+function getWorkloadBadge(meetingCount) {
+    if (meetingCount === 0) {
+        return '<span class="badge bg-secondary ms-2" title="No meetings">0</span>';
+    } else if (meetingCount <= 5) {
+        return `<span class="badge bg-primary ms-2" title="${meetingCount} meetings">${meetingCount}</span>`;
+    } else if (meetingCount <= 9) {
+        return `<span class="badge bg-info text-dark ms-2" title="${meetingCount} meetings">${meetingCount}</span>`;
+    } else {
+        return `<span class="badge bg-dark ms-2" title="${meetingCount} meetings - Heavy workload">${meetingCount}</span>`;
+    }
+}
+
+
+function analyzeUnassignedReason(meeting, schedule) {
+    const reasons = [];
+
+    const totalAttendees = (meeting.requiredAttendances?.length || 0) + (meeting.preferredAttendances?.length || 0);
+
+    // Check room capacity
+    const largestRoomCapacity = Math.max(...schedule.rooms.map(r => r.capacity));
+    if (totalAttendees > largestRoomCapacity) {
+        reasons.push(`Needs ${totalAttendees} capacity, largest room has ${largestRoomCapacity}`);
+    }
+
+    // Check if meeting duration is very long
+    const durationHours = ((meeting.durationInGrains ?? meeting.duration_in_grains) * 15) / 60;
+    if (durationHours > 3) {
+        reasons.push(`Long meeting (${durationHours}h) - fewer available slots`);
+    }
+
+    // Check if required attendees are heavily booked
+    const meetingMap = new Map();
+    schedule.meetings.forEach(m => meetingMap.set(m.id, m));
+
+    const requiredAttendeeIds = new Set((meeting.requiredAttendances || []).map(a => a.person?.id || a.person));
+    let busyAttendeesCount = 0;
+
+    schedule.meetingAssignments.forEach(assignment => {
+        if (assignment.room == null || assignment.startingTimeGrain == null) return;
+        if (assignment.meeting === meeting.id) return;
+
+        const otherMeeting = typeof assignment.meeting === 'string'
+            ? meetingMap.get(assignment.meeting)
+            : assignment.meeting;
+        if (!otherMeeting) return;
+
+        const otherRequiredIds = new Set((otherMeeting.requiredAttendances || []).map(a => a.person?.id || a.person));
+        for (const id of requiredAttendeeIds) {
+            if (otherRequiredIds.has(id)) {
+                busyAttendeesCount++;
+                break;
+            }
+        }
+    });
+
+    if (busyAttendeesCount > 0 && requiredAttendeeIds.size > 0) {
+        const percentBusy = Math.round((busyAttendeesCount / schedule.meetingAssignments.filter(a => a.room && a.startingTimeGrain).length) * 100);
+        if (percentBusy > 30) {
+            reasons.push(`Required attendees have many existing meetings`);
+        }
+    }
+
+    // If still solving, add generic reason
+    if (reasons.length === 0) {
+        reasons.push(`Being optimized by solver`);
+    }
+
+    return reasons;
+}
+
+
+function renderScheduleByRoom(schedule) {
+    const unassigned = $("#unassigned");
+    unassigned.children().remove();
+    byRoomGroupData.clear();
+    byRoomItemData.clear();
+
+    // Check if schedule.rooms exists and is an array
+    if (!schedule.rooms || !Array.isArray(schedule.rooms)) {
+        console.warn('schedule.rooms is not available or not an array:', schedule.rooms);
+        return;
+    }
+
+    $.each(schedule.rooms.sort((e1, e2) => e1.name.localeCompare(e2.name)), (_, room) => {
+        let content = `<div class="d-flex flex-column"><div><h5 class="card-title mb-1">${room.name}</h5></div>`;
+        byRoomGroupData.add({
+            id: room.id,
+            content: content,
+        });
+    });
+
+    const meetingMap = new Map();
+    if (schedule.meetings && Array.isArray(schedule.meetings)) {
+        schedule.meetings.forEach(m => meetingMap.set(m.id, m));
+    }
+    const timeGrainMap = new Map();
+    if (schedule.timeGrains && Array.isArray(schedule.timeGrains)) {
+        schedule.timeGrains.forEach(t => timeGrainMap.set(t.id, t));
+    }
+    const roomMap = new Map();
+    if (schedule.rooms && Array.isArray(schedule.rooms)) {
+        schedule.rooms.forEach(r => roomMap.set(r.id, r));
+    }
+    
+    if (!schedule.meetingAssignments || !Array.isArray(schedule.meetingAssignments)) {
+        console.warn('schedule.meetingAssignments is not available or not an array:', schedule.meetingAssignments);
+        return;
+    }
+    
+    $.each(schedule.meetingAssignments, (_, assignment) => {
+        // Handle both string ID and full object for meeting reference
+        const meet = typeof assignment.meeting === 'string' ? meetingMap.get(assignment.meeting) : assignment.meeting;
+        // Handle both string ID and full object for room reference
+        const room = typeof assignment.room === 'string' ? roomMap.get(assignment.room) : assignment.room;
+        // Handle both string ID and full object for timeGrain reference
+        const timeGrain = typeof assignment.startingTimeGrain === 'string' ? timeGrainMap.get(assignment.startingTimeGrain) : assignment.startingTimeGrain;
+        
+        // Skip if meeting is not found
+        if (!meet) {
+            console.warn(`Meeting not found for assignment ${assignment.id}`);
+            return;
+        }
+        
+        if (room == null || timeGrain == null) {
+            const durationHours = ((meet.durationInGrains ?? meet.duration_in_grains) * 15) / 60;
+            const requiredCount = meet.requiredAttendances?.length || 0;
+            const preferredCount = meet.preferredAttendances?.length || 0;
+            const totalAttendees = requiredCount + preferredCount;
+
+            // Analyze why unassigned
+            const reasons = analyzeUnassignedReason(meet, schedule);
+
+            const unassignedElement = $(`<div class="card-body"/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text(meet.topic))
+                .append($(`<p class="card-text mb-1"/>`).html(`<span class="fas fa-clock me-1"></span>${durationHours} hour(s)`))
+                .append($(`<p class="card-text mb-1"/>`).html(`<span class="fas fa-users me-1"></span>${totalAttendees} attendees (${requiredCount} required, ${preferredCount} preferred)`));
+
+            if (reasons.length > 0) {
+                const reasonsList = $(`<div class="mt-2 small"/>`);
+                reasonsList.append($(`<span class="text-muted">Possible issues:</span>`));
+                reasons.forEach(reason => {
+                    reasonsList.append($(`<div class="text-warning"/>`).html(`<span class="fas fa-exclamation-circle me-1"></span>${reason}`));
+                });
+                unassignedElement.append(reasonsList);
+            }
+
+            unassigned.append($(`<div class="col"/>`).append($(`<div class="card h-100"/>`).append(unassignedElement)));
+        } else {
+            const conflictStatus = getConflictStatus(assignment.id);
+            const byRoomElement = $("<div />")
+                .append($("<div class='d-flex justify-content-center align-items-center' />")
+                    .append($(conflictStatus.icon))
+                    .append($(`<h5 class="card-title mb-1"/>`).text(meet.topic)));
+            const startDate = JSJoda.LocalDate.now().withDayOfYear(timeGrain.dayOfYear ?? timeGrain.day_of_year);
+            const startTime = JSJoda.LocalTime.of(0, 0, 0, 0)
+                .plusMinutes((timeGrain.startingMinuteOfDay ?? timeGrain.starting_minute_of_day));
+            const startDateTime = JSJoda.LocalDateTime.of(startDate, startTime);
+            const endDateTime = startTime.plusMinutes((meet.durationInGrains ?? meet.duration_in_grains) * 15);
+            byRoomItemData.add({
+                id: assignment.id,
+                group: typeof room === 'string' ? room : room.id,
+                content: byRoomElement.html(),
+                start: startDateTime.toString(),
+                end: endDateTime.toString(),
+                style: `min-height: 50px; ${conflictStatus.style}`,
+                title: conflictStatus.reason || undefined
+            });
+        }
+    });
+
+    byRoomTimeline.setWindow(JSJoda.LocalDateTime.now().plusDays(1).withHour(8).toString(),
+        JSJoda.LocalDateTime.now().plusDays(1).withHour(17).withMinute(45).toString());
+}
+
+
+function renderScheduleByPerson(schedule) {
+    const unassigned = $("#unassigned");
+    unassigned.children().remove();
+    byPersonGroupData.clear();
+    byPersonItemData.clear();
+
+    // Check if schedule.people exists and is an array
+    if (!schedule.people || !Array.isArray(schedule.people)) {
+        console.warn('schedule.people is not available or not an array:', schedule.people);
+        return;
+    }
+
+    // Calculate meeting count per person for workload indicators
+    const personMeetingCount = calculatePersonWorkload(schedule);
+
+    $.each(schedule.people.sort((e1, e2) => e1.fullName.localeCompare(e2.fullName)), (_, person) => {
+        const meetingCount = personMeetingCount.get(person.id) || 0;
+        const workloadBadge = getWorkloadBadge(meetingCount);
+        let content = `<div class="d-flex flex-column">
+            <div class="d-flex align-items-center">
+                <h5 class="card-title mb-1">${person.fullName}</h5>
+                ${workloadBadge}
+            </div>
+        </div>`;
+        byPersonGroupData.add({
+            id: person.id,
+            content: content,
+        });
+    });
+    const meetingMap = new Map();
+    if (schedule.meetings && Array.isArray(schedule.meetings)) {
+        schedule.meetings.forEach(m => meetingMap.set(m.id, m));
+    }
+    const timeGrainMap = new Map();
+    if (schedule.timeGrains && Array.isArray(schedule.timeGrains)) {
+        schedule.timeGrains.forEach(t => timeGrainMap.set(t.id, t));
+    }
+    const roomMap = new Map();
+    if (schedule.rooms && Array.isArray(schedule.rooms)) {
+        schedule.rooms.forEach(r => roomMap.set(r.id, r));
+    }
+    
+    if (!schedule.meetingAssignments || !Array.isArray(schedule.meetingAssignments)) {
+        console.warn('schedule.meetingAssignments is not available or not an array:', schedule.meetingAssignments);
+        return;
+    }
+    
+    $.each(schedule.meetingAssignments, (_, assignment) => {
+        // Handle both string ID and full object for meeting reference
+        const meet = typeof assignment.meeting === 'string' ? meetingMap.get(assignment.meeting) : assignment.meeting;
+        // Handle both string ID and full object for room reference
+        const room = typeof assignment.room === 'string' ? roomMap.get(assignment.room) : assignment.room;
+        // Handle both string ID and full object for timeGrain reference
+        const timeGrain = typeof assignment.startingTimeGrain === 'string' ? timeGrainMap.get(assignment.startingTimeGrain) : assignment.startingTimeGrain;
+        
+        // Skip if meeting is not found
+        if (!meet) {
+            console.warn(`Meeting not found for assignment ${assignment.id}`);
+            return;
+        }
+        
+        if (room == null || timeGrain == null) {
+            const durationHours = ((meet.durationInGrains ?? meet.duration_in_grains) * 15) / 60;
+            const requiredCount = meet.requiredAttendances?.length || 0;
+            const preferredCount = meet.preferredAttendances?.length || 0;
+            const totalAttendees = requiredCount + preferredCount;
+
+            // Analyze why unassigned
+            const reasons = analyzeUnassignedReason(meet, schedule);
+
+            const unassignedElement = $(`<div class="card-body"/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text(meet.topic))
+                .append($(`<p class="card-text mb-1"/>`).html(`<span class="fas fa-clock me-1"></span>${durationHours} hour(s)`))
+                .append($(`<p class="card-text mb-1"/>`).html(`<span class="fas fa-users me-1"></span>${totalAttendees} attendees (${requiredCount} required, ${preferredCount} preferred)`));
+
+            if (reasons.length > 0) {
+                const reasonsList = $(`<div class="mt-2 small"/>`);
+                reasonsList.append($(`<span class="text-muted">Possible issues:</span>`));
+                reasons.forEach(reason => {
+                    reasonsList.append($(`<div class="text-warning"/>`).html(`<span class="fas fa-exclamation-circle me-1"></span>${reason}`));
+                });
+                unassignedElement.append(reasonsList);
+            }
+
+            unassigned.append($(`<div class="col"/>`).append($(`<div class="card h-100"/>`).append(unassignedElement)));
+        } else {
+            const conflictStatus = getConflictStatus(assignment.id);
+            const startDate = JSJoda.LocalDate.now().withDayOfYear(timeGrain.dayOfYear ?? timeGrain.day_of_year);
+            const startTime = JSJoda.LocalTime.of(0, 0, 0, 0)
+                .plusMinutes((timeGrain.startingMinuteOfDay ?? timeGrain.starting_minute_of_day));
+            const startDateTime = JSJoda.LocalDateTime.of(startDate, startTime);
+            const endDateTime = startTime.plusMinutes((meet.durationInGrains ?? meet.duration_in_grains) * 15);
+            meet.requiredAttendances.forEach(attendance => {
+                const byPersonElement = $("<div />")
+                    .append($("<div class='d-flex justify-content-center align-items-center' />")
+                        .append($(conflictStatus.icon))
+                        .append($(`<h5 class="card-title mb-1"/>`).text(meet.topic)));
+                byPersonElement.append($("<div class='d-flex justify-content-center' />").append($(`<span class="badge text-bg-success m-1" style="background-color: ${pickColor(meet.id)}" />`).text("Required")));
+                if (meet.preferredAttendances.map(a => a.person).indexOf(attendance.person) >= 0) {
+                    byPersonElement.append($("<div class='d-flex justify-content-center' />").append($(`<span class="badge text-bg-info m-1" style="background-color: ${pickColor(meet.id)}" />`).text("Preferred")));
+                }
+                byPersonItemData.add({
+                    id: `${assignment.id}-${attendance.person.id}`,
+                    group: attendance.person.id,
+                    content: byPersonElement.html(),
+                    start: startDateTime.toString(),
+                    end: endDateTime.toString(),
+                    style: `min-height: 50px; ${conflictStatus.style}`,
+                    title: conflictStatus.reason || undefined
+                });
+            });
+            meet.preferredAttendances.forEach(attendance => {
+                if (meet.requiredAttendances.map(a => a.person).indexOf(attendance.person) === -1) {
+                    const byPersonElement = $("<div />")
+                        .append($("<div class='d-flex justify-content-center align-items-center' />")
+                            .append($(conflictStatus.icon))
+                            .append($(`<h5 class="card-title mb-1"/>`).text(meet.topic)));
+                    byPersonElement.append($("<div class='d-flex justify-content-center' />").append($(`<span class="badge text-bg-info m-1" style="background-color: ${pickColor(meet.id)}" />`).text("Preferred")));
+                    byPersonItemData.add({
+                        id: `${assignment.id}-${attendance.person.id}`,
+                        group: attendance.person.id,
+                        content: byPersonElement.html(),
+                        start: startDateTime.toString(),
+                        end: endDateTime.toString(),
+                        style: `min-height: 50px; ${conflictStatus.style}`,
+                        title: conflictStatus.reason || undefined
+                    });
+                }
+            });
+        }
+    });
+
+    byPersonTimeline.setWindow(JSJoda.LocalDateTime.now().plusDays(1).withHour(8).toString(),
+        JSJoda.LocalDateTime.now().plusDays(1).withHour(17).withMinute(45).toString());
+}
+
+
+// Click handlers for timeline items
+byRoomTimeline.on('select', function (properties) {
+    if (properties.items.length > 0) {
+        showMeetingDetails(properties.items[0]);
+    }
+});
+
+byPersonTimeline.on('select', function (properties) {
+    if (properties.items.length > 0) {
+        // For person view, item id is "assignmentId-personId", extract assignmentId
+        const itemId = properties.items[0];
+        const assignmentId = itemId.includes('-') ? itemId.split('-').slice(0, -1).join('-') : itemId;
+        showMeetingDetails(assignmentId);
+    }
+});
+
+
+function showMeetingDetails(assignmentId) {
+    if (!loadedSchedule) return;
+
+    // Find the assignment
+    const assignment = loadedSchedule.meetingAssignments.find(a => a.id === assignmentId);
+    if (!assignment) {
+        console.warn('Assignment not found:', assignmentId);
+        return;
+    }
+
+    // Build lookup maps
+    const meetingMap = new Map();
+    loadedSchedule.meetings.forEach(m => meetingMap.set(m.id, m));
+    const roomMap = new Map();
+    loadedSchedule.rooms.forEach(r => roomMap.set(r.id, r));
+    const personMap = new Map();
+    loadedSchedule.people.forEach(p => personMap.set(p.id, p));
+
+    // Get meeting and room details
+    const meeting = typeof assignment.meeting === 'string' ? meetingMap.get(assignment.meeting) : assignment.meeting;
+    const room = typeof assignment.room === 'string' ? roomMap.get(assignment.room) : assignment.room;
+    const timeGrain = typeof assignment.startingTimeGrain === 'string'
+        ? loadedSchedule.timeGrains.find(t => t.id === assignment.startingTimeGrain)
+        : assignment.startingTimeGrain;
+
+    if (!meeting) {
+        console.warn('Meeting not found for assignment:', assignmentId);
+        return;
+    }
+
+    // Get conflict status
+    const conflictStatus = getConflictStatus(assignmentId);
+
+    // Build modal content
+    const content = $("#meetingDetailsModalContent");
+    content.empty();
+
+    // Meeting title and status
+    const statusBadge = conflictStatus.status === 'hard'
+        ? '<span class="badge bg-danger ms-2">Hard Conflict</span>'
+        : conflictStatus.status === 'medium'
+            ? '<span class="badge bg-warning ms-2">Medium Issue</span>'
+            : conflictStatus.status === 'soft'
+                ? '<span class="badge bg-info ms-2">Soft Issue</span>'
+                : '<span class="badge bg-success ms-2">OK</span>';
+
+    content.append($('<h4/>').html(meeting.topic + statusBadge));
+
+    // Show reason if any
+    if (conflictStatus.reason) {
+        content.append($('<div class="alert alert-info py-2"/>').text(conflictStatus.reason));
+    }
+
+    // Details table
+    const detailsTable = $('<table class="table table-sm"/>');
+    const tbody = $('<tbody/>');
+
+    // Duration
+    const durationHours = ((meeting.durationInGrains ?? meeting.duration_in_grains) * 15) / 60;
+    tbody.append($('<tr/>')
+        .append($('<th scope="row" style="width: 150px"/>').text('Duration'))
+        .append($('<td/>').text(`${durationHours} hour(s) (${(meeting.durationInGrains ?? meeting.duration_in_grains)} time grains)`)));
+
+    // Room
+    if (room) {
+        tbody.append($('<tr/>')
+            .append($('<th scope="row"/>').text('Room'))
+            .append($('<td/>').text(`${room.name} (capacity: ${room.capacity})`)));
+    } else {
+        tbody.append($('<tr/>')
+            .append($('<th scope="row"/>').text('Room'))
+            .append($('<td/>').html('<span class="text-danger">Not assigned</span>')));
+    }
+
+    // Time
+    if (timeGrain) {
+        const startDate = JSJoda.LocalDate.now().withDayOfYear(timeGrain.dayOfYear ?? timeGrain.day_of_year);
+        const startTime = JSJoda.LocalTime.of(0, 0, 0, 0).plusMinutes((timeGrain.startingMinuteOfDay ?? timeGrain.starting_minute_of_day));
+        const endTime = startTime.plusMinutes((meeting.durationInGrains ?? meeting.duration_in_grains) * 15);
+        tbody.append($('<tr/>')
+            .append($('<th scope="row"/>').text('Time'))
+            .append($('<td/>').text(`${startDate.toString()} ${startTime.toString()} - ${endTime.toString()}`)));
+    } else {
+        tbody.append($('<tr/>')
+            .append($('<th scope="row"/>').text('Time'))
+            .append($('<td/>').html('<span class="text-danger">Not scheduled</span>')));
+    }
+
+    detailsTable.append(tbody);
+    content.append(detailsTable);
+
+    // Required Attendees section
+    content.append($('<h5 class="mt-3"/>').text('Required Attendees'));
+    if (meeting.requiredAttendances && meeting.requiredAttendances.length > 0) {
+        const reqList = $('<ul class="list-group list-group-flush"/>');
+        meeting.requiredAttendances.forEach(att => {
+            const person = att.person?.fullName || (personMap.get(att.person)?.fullName) || att.person;
+            reqList.append($('<li class="list-group-item py-1"/>')
+                .html(`<span class="fas fa-user me-2 text-success"></span>${person}`));
+        });
+        content.append(reqList);
+    } else {
+        content.append($('<p class="text-muted"/>').text('No required attendees'));
+    }
+
+    // Preferred Attendees section
+    content.append($('<h5 class="mt-3"/>').text('Preferred Attendees'));
+    if (meeting.preferredAttendances && meeting.preferredAttendances.length > 0) {
+        const prefList = $('<ul class="list-group list-group-flush"/>');
+        meeting.preferredAttendances.forEach(att => {
+            const person = att.person?.fullName || (personMap.get(att.person)?.fullName) || att.person;
+            prefList.append($('<li class="list-group-item py-1"/>')
+                .html(`<span class="fas fa-user me-2 text-info"></span>${person}`));
+        });
+        content.append(prefList);
+    } else {
+        content.append($('<p class="text-muted"/>').text('No preferred attendees'));
+    }
+
+    // Conflict details section
+    if (conflictStatus.status !== 'ok' && analyzeCache && analyzeCache.has(assignmentId)) {
+        content.append($('<h5 class="mt-3 text-danger"/>').text('Conflicts'));
+        const conflictList = $('<ul class="list-group list-group-flush"/>');
+
+        const violations = analyzeCache.get(assignmentId);
+
+        // Show hard violations
+        violations.hard.forEach(v => {
+            conflictList.append($('<li class="list-group-item py-1 text-danger"/>')
+                .html(`<span class="fas fa-exclamation-triangle me-2"></span>${v.constraint}`));
+        });
+
+        // Show medium violations
+        violations.medium.forEach(v => {
+            conflictList.append($('<li class="list-group-item py-1 text-warning"/>')
+                .html(`<span class="fas fa-exclamation-circle me-2"></span>${v.constraint}`));
+        });
+
+        // Show soft violations
+        violations.soft.forEach(v => {
+            conflictList.append($('<li class="list-group-item py-1 text-info"/>')
+                .html(`<span class="fas fa-info-circle me-2"></span>${v.constraint}`));
+        });
+
+        content.append(conflictList);
+    }
+
+    // Update modal title
+    $("#meetingDetailsModalLabel").text("Meeting Details: " + meeting.topic);
+
+    // Show modal
+    new bootstrap.Modal("#meetingDetailsModal").show();
+}
+
+
+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(/(-?[0-9]+)(hard|medium|soft)/g)], (i, parts) => {
+        components[parts[2]] = parseInt(parts[1], 10);
+    });
+
+    return components;
+}
+
+
+function refreshSolvingButtons(solving) {
+    if (solving) {
+        $("#solveButton").hide();
+        $("#stopSolvingButton").show();
+        $("#solvingSpinner").addClass("active");
+        if (autoRefreshIntervalId == null) {
+            autoRefreshIntervalId = setInterval(refreshSchedule, 2000);
+        }
+    } else {
+        $("#solveButton").show();
+        $("#stopSolvingButton").hide();
+        $("#solvingSpinner").removeClass("active");
+        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 copyTextToClipboard(id) {
+    var text = $("#" + id).text().trim();
+
+    var dummy = document.createElement("textarea");
+    document.body.appendChild(dummy);
+    dummy.value = text;
+    dummy.select();
+    document.execCommand("copy");
+    document.body.removeChild(dummy);
+}
+
+
+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,177 @@
+<!DOCTYPE html>
+<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>Meeting 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;
+        }
+        .vis-item-content {
+            width: 100%;
+        }
+        #byPersonPanel, #byRoomPanel {
+            min-height: 300px;
+        }
+    </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>Meeting Scheduling Solver</h1>
+        <p>Generate the optimal schedule for your meeting scheduling.</p>
+
+        <div class="mb-2">
+            <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="score" class="score ms-2 align-middle fw-bold">Score: ?</span>
+            <button id="analyzeButton" type="button" class="ms-2 btn btn-secondary">
+                <span class="fas fa-question"></span>
+            </button>
+
+            <div class="float-end">
+                <ul class="nav nav-pills" role="tablist">
+                    <li class="nav-item" role="presentation">
+                        <button class="nav-link active" id="byRoomTab" data-bs-toggle="tab"
+                                data-bs-target="#byRoomPanel" type="button" role="tab" aria-controls="byRoomPanel"
+                                aria-selected="true">By Room
+                        </button>
+                    </li>
+                    <li class="nav-item" role="presentation">
+                        <button class="nav-link" id="byPersonTab" data-bs-toggle="tab"
+                                data-bs-target="#byPersonPanel" type="button" role="tab" aria-controls="byPersonPanel"
+                                aria-selected="true">By Person
+                        </button>
+                    </li>
+                </ul>
+            </div>
+        </div>
+        <div class="tab-content">
+            <div class="tab-pane fade show active" id="byRoomPanel" role="tabpanel" aria-labelledby="byRoomTab">
+                <!-- Timeline will be rendered directly here -->
+            </div>
+            <div class="tab-pane fade" id="byPersonPanel" role="tabpanel" aria-labelledby="byPersonTab">
+                <!-- Timeline will be rendered directly here -->
+            </div>
+        </div>
+
+        <h2>Unassigned</h2>
+        <div id="unassigned" class="row row-cols-4 g-3 mb-4"></div>
+    </div>
+
+    <div id="rest" class="tab-pane fade  container-fluid">
+        <h1>REST API Guide</h1>
+
+        <h2>Meeting 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 -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} -o solution.json</code>
+    </pre>
+
+        <h3>5. Fetch the analysis of the solution</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl5')">Copy</button>
+            <code id="curl5">curl -X PUT -H 'Content-Type:application/json' http://localhost:8080/schedules/analyze -d@solution.json</code>
+    </pre>
+
+        <h3>6. Terminate solving early</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl6')">Copy</button>
+            <code id="curl6">curl -X DELETE -H 'Accept:application/json' http://localhost:8080/schedules/{jobId}</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>
+
+<!-- Meeting Details Modal -->
+<div class="modal fade" id="meetingDetailsModal" tabindex="-1" aria-labelledby="meetingDetailsModalLabel" aria-hidden="true">
+  <div class="modal-dialog modal-lg">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h5 class="modal-title" id="meetingDetailsModalLabel">Meeting Details</h5>
+        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+      </div>
+      <div class="modal-body" id="meetingDetailsModalContent">
+      </div>
+    </div>
+  </div>
+</div>
+
+<!-- Score Analysis Modal -->
+<div class="modal fade" id="scoreAnalysisModal" tabindex="-1" aria-labelledby="scoreAnalysisModalLabel" aria-hidden="true">
+  <div class="modal-dialog modal-lg">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h5 class="modal-title" id="scoreAnalysisModalLabel">Score Analysis <span id="scoreAnalysisScoreLabel"></span></h5>
+        <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+      </div>
+      <div class="modal-body" id="scoreAnalysisModalContent">
+      </div>
+    </div>
+  </div>
+</div>
+</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;
+}

static/webjars/timefold/css/timefold-webui.css

@@ -0,0 +1,60 @@
+:root {
+    /* Keep in sync with .navbar height on a large screen. */
+    --ts-navbar-height: 109px;
+
+    --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-violet-1-rgb);
+}

static/webjars/timefold/js/timefold-webui.js

@@ -0,0 +1,142 @@
+function replaceTimefoldAutoHeaderFooter() {
+  const timefoldHeader = $("header#timefold-auto-header");
+  if (timefoldHeader != null) {
+    timefoldHeader.addClass("bg-black")
+    timefoldHeader.append(
+      $(`<div class="container-fluid">
+        <nav class="navbar sticky-top navbar-expand-lg navbar-dark shadow mb-3">
+          <a class="navbar-brand" href="https://timefold.ai">
+            <img src="/timefold/img/timefold-logo-horizontal-negative.svg" alt="Timefold logo" width="200">
+          </a>
+        </nav>
+      </div>`));
+  }
+  const timefoldFooter = $("footer#timefold-auto-footer");
+  if (timefoldFooter != null) {
+    timefoldFooter.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://timefold.ai">Timefold</a></div>
+               <div class="vr"></div>
+               <div><a class="text-white" href="https://timefold.ai/docs">Documentation</a></div>
+               <div class="vr"></div>
+               <div><a class="text-white" href="https://github.com/TimefoldAI/timefold-solver-python">Code</a></div>
+               <div class="vr"></div>
+               <div class="me-auto"><a class="text-white" href="https://timefold.ai/product/support/">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;
+}

tests/__init__.py

@@ -0,0 +1 @@
+# Test package initialization

tests/test_constraints.py

@@ -0,0 +1,562 @@
+from solverforge_legacy.solver.test import ConstraintVerifier
+
+from meeting_scheduling.domain import (
+    Meeting,
+    MeetingAssignment,
+    MeetingSchedule,
+    Person,
+    PreferredAttendance,
+    RequiredAttendance,
+    Room,
+    TimeGrain,
+)
+from meeting_scheduling.constraints import (
+    define_constraints,
+    room_conflict,
+    avoid_overtime,
+    required_attendance_conflict,
+    required_room_capacity,
+    start_and_end_on_same_day,
+    required_and_preferred_attendance_conflict,
+    preferred_attendance_conflict,
+    room_stability,
+)
+
+
+DEFAULT_TIME_GRAINS = [
+    TimeGrain(
+        id=str(i + 1), grain_index=i, day_of_year=1, starting_minute_of_day=480 + i * 15
+    )
+    for i in range(8)
+]
+
+DEFAULT_ROOM = Room(id="1", name="Room 1", capacity=10)
+SMALL_ROOM = Room(id="2", name="Small Room", capacity=1)
+LARGE_ROOM = Room(id="3", name="Large Room", capacity=2)
+ROOM_A = Room(id="4", name="Room A", capacity=10)
+ROOM_B = Room(id="5", name="Room B", capacity=10)
+
+
+constraint_verifier = ConstraintVerifier.build(
+    define_constraints, MeetingSchedule, MeetingAssignment
+)
+
+
+def test_room_conflict_unpenalized():
+    """Test that no penalty is applied when meetings in the same room do not overlap."""
+    meeting1 = create_meeting(1)
+    left_assignment = create_meeting_assignment(
+        0, meeting1, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM
+    )
+
+    meeting2 = create_meeting(2)
+    right_assignment = create_meeting_assignment(
+        1, meeting2, DEFAULT_TIME_GRAINS[4], DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(room_conflict).given(
+        left_assignment, right_assignment
+    ).penalizes(0)
+
+
+def test_room_conflict_penalized():
+    """Test that a penalty is applied when meetings in the same room overlap."""
+    meeting1 = create_meeting(1)
+    left_assignment = create_meeting_assignment(
+        0, meeting1, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM
+    )
+
+    meeting2 = create_meeting(2)
+    right_assignment = create_meeting_assignment(
+        1, meeting2, DEFAULT_TIME_GRAINS[2], DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(room_conflict).given(
+        left_assignment, right_assignment
+    ).penalizes_by(2)
+
+
+def test_avoid_overtime_unpenalized():
+    """Test that no penalty is applied when a meeting fits within available time grains (no overtime)."""
+    meeting = create_meeting(1)
+    meeting_assignment = create_meeting_assignment(
+        0, meeting, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(avoid_overtime).given(
+        meeting_assignment, *DEFAULT_TIME_GRAINS
+    ).penalizes(0)
+
+
+def test_avoid_overtime_penalized():
+    """Test that a penalty is applied when a meeting exceeds available time grains (overtime)."""
+    meeting = create_meeting(1)
+    meeting_assignment = create_meeting_assignment(
+        0, meeting, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(avoid_overtime).given(
+        meeting_assignment
+    ).penalizes_by(3)
+
+
+def test_required_attendance_conflict_unpenalized():
+    """Test that no penalty is applied when a person does not have overlapping required meetings."""
+    person = create_person(1)
+
+    left_meeting = create_meeting(1, duration=2)
+    required_attendance1 = create_required_attendance(0, person, left_meeting)
+
+    right_meeting = create_meeting(2, duration=2)
+    required_attendance2 = create_required_attendance(1, person, right_meeting)
+
+    left_assignment = create_meeting_assignment(
+        0, left_meeting, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM
+    )
+    right_assignment = create_meeting_assignment(
+        1, right_meeting, DEFAULT_TIME_GRAINS[2], DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(required_attendance_conflict).given(
+        required_attendance1, required_attendance2, left_assignment, right_assignment
+    ).penalizes(0)
+
+
+def test_required_attendance_conflict_penalized():
+    """Test that a penalty is applied when a person has overlapping required meetings."""
+    person = create_person(1)
+
+    left_meeting = create_meeting(1, duration=2)
+    required_attendance1 = create_required_attendance(0, person, left_meeting)
+
+    right_meeting = create_meeting(2, duration=2)
+    required_attendance2 = create_required_attendance(1, person, right_meeting)
+
+    left_assignment = create_meeting_assignment(
+        0, left_meeting, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM
+    )
+    right_assignment = create_meeting_assignment(
+        1, right_meeting, DEFAULT_TIME_GRAINS[1], DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(required_attendance_conflict).given(
+        required_attendance1, required_attendance2, left_assignment, right_assignment
+    ).penalizes_by(1)
+
+
+def test_required_room_capacity_unpenalized():
+    """Test that no penalty is applied when the room has enough capacity for all required and preferred attendees."""
+    person1 = create_person(1)
+    person2 = create_person(2)
+
+    meeting = create_meeting(1, duration=2)
+    create_required_attendance(0, person1, meeting)
+    create_preferred_attendance(1, person2, meeting)
+
+    meeting_assignment = create_meeting_assignment(
+        0, meeting, DEFAULT_TIME_GRAINS[0], LARGE_ROOM
+    )
+
+    constraint_verifier.verify_that(required_room_capacity).given(
+        meeting_assignment
+    ).penalizes(0)
+
+
+def test_required_room_capacity_penalized():
+    """Test that a penalty is applied when the room does not have enough capacity for all required and preferred attendees."""
+    person1 = create_person(1)
+    person2 = create_person(2)
+
+    meeting = create_meeting(1, duration=2)
+    create_required_attendance(0, person1, meeting)
+    create_preferred_attendance(1, person2, meeting)
+
+    meeting_assignment = create_meeting_assignment(
+        0, meeting, DEFAULT_TIME_GRAINS[0], SMALL_ROOM
+    )
+
+    constraint_verifier.verify_that(required_room_capacity).given(
+        meeting_assignment
+    ).penalizes_by(1)
+
+
+def test_start_and_end_on_same_day_unpenalized():
+    """Test that no penalty is applied when a meeting starts and ends on the same day."""
+    # Need custom time grains with day_of_year=0 (DEFAULT_TIME_GRAINS use day_of_year=1)
+    start_time_grain = TimeGrain(
+        id="1", grain_index=0, day_of_year=0, starting_minute_of_day=480
+    )
+    end_time_grain = TimeGrain(
+        id="2", grain_index=3, day_of_year=0, starting_minute_of_day=525
+    )  # Same day
+
+    meeting = create_meeting(1)
+    meeting_assignment = create_meeting_assignment(
+        0, meeting, start_time_grain, DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(start_and_end_on_same_day).given(
+        meeting_assignment, end_time_grain
+    ).penalizes(0)
+
+
+def test_start_and_end_on_same_day_penalized():
+    """Test that a penalty is applied when a meeting starts and ends on different days."""
+    # Need custom time grains to test different days (start=day 0, end=day 1)
+    start_time_grain = TimeGrain(
+        id="1", grain_index=0, day_of_year=0, starting_minute_of_day=480
+    )
+    end_time_grain = TimeGrain(
+        id="2", grain_index=3, day_of_year=1, starting_minute_of_day=525
+    )  # Different day
+
+    meeting = create_meeting(1)
+    meeting_assignment = create_meeting_assignment(
+        0, meeting, start_time_grain, DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(start_and_end_on_same_day).given(
+        meeting_assignment, end_time_grain
+    ).penalizes_by(1)
+
+
+def test_multiple_constraint_violations():
+    """Test that multiple constraints can be violated simultaneously."""
+    person = create_person(1)
+
+    left_meeting = create_meeting(1)
+    required_attendance1 = create_required_attendance(0, person, left_meeting)
+    left_assignment = create_meeting_assignment(
+        0, left_meeting, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM
+    )
+
+    right_meeting = create_meeting(2)
+    required_attendance2 = create_required_attendance(1, person, right_meeting)
+    right_assignment = create_meeting_assignment(
+        1, right_meeting, DEFAULT_TIME_GRAINS[2], DEFAULT_ROOM
+    )
+
+    constraint_verifier.verify_that(room_conflict).given(
+        left_assignment, right_assignment
+    ).penalizes_by(2)
+    constraint_verifier.verify_that(required_attendance_conflict).given(
+        required_attendance1, required_attendance2, left_assignment, right_assignment
+    ).penalizes_by(2)
+
+
+### Helper functions ###
+
+
+def create_meeting(id, topic="Meeting", duration=4):
+    """Helper to create a meeting with standard parameters."""
+    return Meeting(id=str(id), topic=f"{topic} {id}", duration_in_grains=duration)
+
+
+def create_meeting_assignment(id, meeting, time_grain, room):
+    """Helper to create a meeting assignment."""
+    return MeetingAssignment(
+        id=str(id), meeting=meeting, starting_time_grain=time_grain, room=room
+    )
+
+
+def create_person(id):
+    """Helper to create a person."""
+    return Person(id=str(id), full_name=f"Person {id}")
+
+
+def create_required_attendance(id, person, meeting):
+    """Helper to create and link required attendance."""
+    attendance = RequiredAttendance(id=str(id), person=person, meeting_id=meeting.id)
+    meeting.required_attendances = [attendance]
+    return attendance
+
+
+def create_preferred_attendance(id, person, meeting):
+    """Helper to create and link preferred attendance."""
+    attendance = PreferredAttendance(id=str(id), person=person, meeting_id=meeting.id)
+    meeting.preferred_attendances = [attendance]
+    return attendance
+
+
+# ========================================
+# Required and Preferred Attendance Conflict Tests
+# ========================================
+
+
+def test_required_and_preferred_attendance_conflict_unpenalized():
+    """Test no penalty when required and preferred meetings don't overlap."""
+    person = create_person(1)
+
+    # Meeting 1: grain 0-3 (duration=4), person required
+    meeting1 = create_meeting(1, duration=4)
+    attendance1 = create_required_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM)
+
+    # Meeting 2: grain 4-7 (duration=4), person preferred
+    meeting2 = create_meeting(2, duration=4)
+    attendance2 = create_preferred_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[4], ROOM_A)
+
+    constraint_verifier.verify_that(required_and_preferred_attendance_conflict).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes_by(0)
+
+
+def test_required_and_preferred_attendance_conflict_penalized():
+    """Test penalty when person required at one meeting and preferred at overlapping meeting."""
+    person = create_person(1)
+
+    # Meeting 1: grain 0-3 (duration=4), person required
+    meeting1 = create_meeting(1, duration=4)
+    attendance1 = create_required_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM)
+
+    # Meeting 2: grain 2-5 (duration=4), person preferred, overlaps grains 2-3 (2 grains)
+    meeting2 = create_meeting(2, duration=4)
+    attendance2 = create_preferred_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[2], ROOM_A)
+
+    # Overlap: grains 2-3 = 2 grains
+    constraint_verifier.verify_that(required_and_preferred_attendance_conflict).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes_by(2)
+
+
+# ========================================
+# Preferred Attendance Conflict Tests
+# ========================================
+
+
+def test_preferred_attendance_conflict_unpenalized():
+    """Test no penalty when preferred attendee has non-overlapping meetings."""
+    person = create_person(1)
+
+    # Meeting 1: grain 0-3 (duration=4), person preferred
+    meeting1 = create_meeting(1, duration=4)
+    attendance1 = create_preferred_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM)
+
+    # Meeting 2: grain 4-7 (duration=4), person preferred
+    meeting2 = create_meeting(2, duration=4)
+    attendance2 = create_preferred_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[4], ROOM_A)
+
+    constraint_verifier.verify_that(preferred_attendance_conflict).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes_by(0)
+
+
+def test_preferred_attendance_conflict_penalized():
+    """Test penalty when person preferred at multiple overlapping meetings."""
+    person = create_person(1)
+
+    # Meeting 1: grain 0-3 (duration=4), person preferred
+    meeting1 = create_meeting(1, duration=4)
+    attendance1 = create_preferred_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[0], DEFAULT_ROOM)
+
+    # Meeting 2: grain 1-4 (duration=4), person preferred, overlaps grains 1-3 (3 grains)
+    meeting2 = create_meeting(2, duration=4)
+    attendance2 = create_preferred_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[1], ROOM_A)
+
+    # Overlap: grains 1-3 = 3 grains
+    constraint_verifier.verify_that(preferred_attendance_conflict).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes_by(3)
+
+
+# ========================================
+# Room Stability Tests
+# ========================================
+
+
+def test_room_stability_same_room_no_penalty():
+    """
+    Test that no penalty is applied when a person attends consecutive
+    meetings in the same room (stability is maintained).
+    """
+    person = create_person(1)
+
+    # Meeting 1: time grain 0-1 (duration=2) in ROOM_A
+    meeting1 = create_meeting(1, duration=2)
+    attendance1 = create_required_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[0], ROOM_A)
+
+    # Meeting 2: time grain 3-4 (duration=2) in ROOM_A (same room, gap of 1)
+    meeting2 = create_meeting(2, duration=2)
+    attendance2 = create_required_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[3], ROOM_A)
+
+    # Same room should not penalize
+    constraint_verifier.verify_that(room_stability).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes(0)
+
+
+def test_room_stability_different_room_with_required_attendance():
+    """
+    Test that a penalty is applied when a person with required attendance
+    has to change rooms between closely scheduled meetings.
+    Weighted penalty: back-to-back switches cost more than switches with gaps.
+    """
+    person = create_person(1)
+
+    # Meeting 1: time grain 0-1 (duration=2) in ROOM_A
+    left_grain_index = 0
+    left_duration = 2
+    meeting1 = create_meeting(1, duration=left_duration)
+    attendance1 = create_required_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[left_grain_index], ROOM_A)
+
+    # Meeting 2: time grain 3-4 (duration=2) in ROOM_B (different room)
+    right_grain_index = 3
+    meeting2 = create_meeting(2, duration=2)
+    attendance2 = create_required_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[right_grain_index], ROOM_B)
+
+    # Weighted penalty: 3 - gap, where gap = right_grain - left_duration - left_grain
+    gap = right_grain_index - left_duration - left_grain_index
+    expected_penalty = 3 - gap
+
+    constraint_verifier.verify_that(room_stability).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes_by(expected_penalty)
+
+
+def test_room_stability_different_room_with_preferred_attendance():
+    """
+    Test that a penalty is applied when a person with preferred attendance
+    has to change rooms between closely scheduled meetings.
+    Weighted penalty applies to preferred attendance too.
+    """
+    person = create_person(1)
+
+    # Meeting 1: time grain 0-1 (duration=2) in ROOM_A
+    left_grain_index = 0
+    left_duration = 2
+    meeting1 = create_meeting(1, duration=left_duration)
+    attendance1 = create_preferred_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[left_grain_index], ROOM_A)
+
+    # Meeting 2: time grain 3-4 (duration=2) in ROOM_B (different room)
+    right_grain_index = 3
+    meeting2 = create_meeting(2, duration=2)
+    attendance2 = create_preferred_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[right_grain_index], ROOM_B)
+
+    # Weighted penalty: 3 - gap
+    gap = right_grain_index - left_duration - left_grain_index
+    expected_penalty = 3 - gap
+
+    constraint_verifier.verify_that(room_stability).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes_by(expected_penalty)
+
+
+def test_room_stability_mixed_attendance_types():
+    """
+    Test that room stability penalty applies when mixing required and preferred
+    attendance types for the same person.
+    """
+    person = create_person(1)
+
+    # Meeting 1 with required attendance
+    left_grain_index = 0
+    left_duration = 2
+    meeting1 = create_meeting(1, duration=left_duration)
+    required_attendance = create_required_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[left_grain_index], ROOM_A)
+
+    # Meeting 2 with preferred attendance
+    right_grain_index = 3
+    meeting2 = create_meeting(2, duration=2)
+    preferred_attendance = create_preferred_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[right_grain_index], ROOM_B)
+
+    # Weighted penalty: 3 - gap
+    gap = right_grain_index - left_duration - left_grain_index
+    expected_penalty = 3 - gap
+
+    constraint_verifier.verify_that(room_stability).given(
+        required_attendance, preferred_attendance, assignment1, assignment2
+    ).penalizes_by(expected_penalty)
+
+
+def test_room_stability_far_apart_meetings_no_penalty():
+    """
+    Test that no penalty is applied when meetings are far apart in time,
+    even if they're in different rooms.
+    """
+    person = create_person(1)
+
+    # Meeting 1: time grain 0-1 (duration=2) in ROOM_A
+    meeting1 = create_meeting(1, duration=2)
+    attendance1 = create_required_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[0], ROOM_A)
+
+    # Meeting 2: time grain 6-7 (duration=2) in ROOM_B
+    # gap = grain_index(6) - duration_in_grains(2) - grain_index(0) = 6 - 2 - 0 = 4 > 2
+    meeting2 = create_meeting(2, duration=2)
+    attendance2 = create_required_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[6], ROOM_B)
+
+    # Far apart meetings should not penalize even with room change
+    constraint_verifier.verify_that(room_stability).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes(0)
+
+
+def test_room_stability_different_people_no_penalty():
+    """
+    Test that no penalty is applied when different people have meetings
+    in different rooms (room stability is per-person).
+    """
+    person1 = create_person(1)
+    person2 = create_person(2)
+
+    # Person 1's meeting in ROOM_A
+    meeting1 = create_meeting(1, duration=2)
+    attendance1 = create_required_attendance(0, person1, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[0], ROOM_A)
+
+    # Person 2's meeting in ROOM_B (different person, should not affect stability)
+    meeting2 = create_meeting(2, duration=2)
+    attendance2 = create_required_attendance(1, person2, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[3], ROOM_B)
+
+    # Different people should not trigger room stability penalty
+    constraint_verifier.verify_that(room_stability).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes(0)
+
+
+def test_room_stability_back_to_back_highest_penalty():
+    """
+    Test that back-to-back room switches (gap=0) incur the highest penalty (3).
+    This verifies the weighted penalty gradient: closer switches cost more.
+    """
+    person = create_person(1)
+
+    # Meeting 1: grain 0-1 (duration=2) in ROOM_A
+    left_grain_index = 0
+    left_duration = 2
+    meeting1 = create_meeting(1, duration=left_duration)
+    attendance1 = create_required_attendance(0, person, meeting1)
+    assignment1 = create_meeting_assignment(0, meeting1, DEFAULT_TIME_GRAINS[left_grain_index], ROOM_A)
+
+    # Meeting 2: grain 2-3 (immediately after) in ROOM_B
+    right_grain_index = 2  # Starts right after meeting1 ends
+    meeting2 = create_meeting(2, duration=2)
+    attendance2 = create_required_attendance(1, person, meeting2)
+    assignment2 = create_meeting_assignment(1, meeting2, DEFAULT_TIME_GRAINS[right_grain_index], ROOM_B)
+
+    # gap = 2 - 2 - 0 = 0, penalty = 3 - 0 = 3
+    gap = right_grain_index - left_duration - left_grain_index
+    expected_penalty = 3 - gap
+    assert gap == 0, f"Test setup error: expected gap=0, got {gap}"
+    assert expected_penalty == 3, f"Test setup error: expected penalty=3, got {expected_penalty}"
+
+    constraint_verifier.verify_that(room_stability).given(
+        attendance1, attendance2, assignment1, assignment2
+    ).penalizes_by(expected_penalty)

tests/test_feasible.py

@@ -0,0 +1,143 @@
+from meeting_scheduling.rest_api import app
+from meeting_scheduling.converters import MeetingScheduleModel, model_to_schedule
+
+from fastapi.testclient import TestClient
+from time import sleep
+from pytest import fail
+import json
+
+client = TestClient(app)
+
+
+def json_to_meeting_schedule(schedule_json):
+    """Convert JSON response to MeetingSchedule domain object with proper score."""
+    # Parse JSON to Pydantic model first
+    schedule_model = MeetingScheduleModel.model_validate(schedule_json)
+
+    # Convert to domain model
+    schedule = model_to_schedule(schedule_model)
+
+    return schedule
+
+
+def test_feasible():
+    demo_data_response = client.get("/demo-data")
+    assert demo_data_response.status_code == 200
+
+    job_id_response = client.post("/schedules", json=demo_data_response.json())
+    assert job_id_response.status_code == 200
+    job_id = job_id_response.text[1:-1]
+
+    ATTEMPTS = 1_000
+    for _ in range(ATTEMPTS):
+        sleep(0.1)
+        schedule_response = client.get(f"/schedules/{job_id}")
+        schedule_json = schedule_response.json()
+        schedule = json_to_meeting_schedule(schedule_json)
+
+        if schedule.score is not None and schedule.score.is_feasible:
+            # Additional validation like Java version
+            assert all(
+                assignment.starting_time_grain is not None
+                and assignment.room is not None
+                for assignment in schedule.meeting_assignments
+            )
+
+            stop_solving_response = client.delete(f"/schedules/{job_id}")
+            assert stop_solving_response.status_code == 200
+            return
+
+    client.delete(f"/schedules/{job_id}")
+    fail("solution is not feasible")
+
+
+def test_analyze():
+    demo_data_response = client.get("/demo-data")
+    assert demo_data_response.status_code == 200
+
+    job_id_response = client.post("/schedules", json=demo_data_response.json())
+    assert job_id_response.status_code == 200
+    job_id = job_id_response.text[1:-1]
+
+    ATTEMPTS = 1_000
+    for _ in range(ATTEMPTS):
+        sleep(0.1)
+        schedule_response = client.get(f"/schedules/{job_id}")
+        schedule_json = schedule_response.json()
+        schedule = json_to_meeting_schedule(schedule_json)
+
+        if schedule.score is not None and schedule.score.is_feasible:
+            # Test the analyze endpoint
+            analysis_response = client.put("/schedules/analyze", json=schedule_json)
+            assert analysis_response.status_code == 200
+            analysis = analysis_response.text
+            assert analysis is not None
+
+            # Test with fetchPolicy parameter
+            analysis_response_2 = client.put(
+                "/schedules/analyze?fetchPolicy=FETCH_SHALLOW", json=schedule_json
+            )
+            assert analysis_response_2.status_code == 200
+            analysis_2 = analysis_response_2.text
+            assert analysis_2 is not None
+
+            client.delete(f"/schedules/{job_id}")
+            return
+
+    client.delete(f"/schedules/{job_id}")
+    fail("solution is not feasible for analyze test")
+
+
+def test_analyze_constraint_scores():
+    """Test that the analyze endpoint returns proper constraint scores instead of all zeros."""
+    demo_data_response = client.get("/demo-data")
+    assert demo_data_response.status_code == 200
+
+    job_id_response = client.post("/schedules", json=demo_data_response.json())
+    assert job_id_response.status_code == 200
+    job_id = job_id_response.text[1:-1]
+
+    ATTEMPTS = 1_000
+    for _ in range(ATTEMPTS):
+        sleep(0.1)
+        schedule_response = client.get(f"/schedules/{job_id}")
+        schedule_json = schedule_response.json()
+        schedule = json_to_meeting_schedule(schedule_json)
+
+        if schedule.score is not None and schedule.score.is_feasible:
+            # Test the analyze endpoint and verify constraint scores
+            analysis_response = client.put("/schedules/analyze", json=schedule_json)
+            assert analysis_response.status_code == 200
+
+            # Parse the analysis response
+            analysis_data = json.loads(analysis_response.text)
+            constraints = analysis_data.get("constraints", [])
+
+            # Verify we have constraints
+            assert len(constraints) > 0, "Should have at least one constraint"
+
+            # Check that at least some constraints have non-zero scores
+            # (since we have a feasible solution, some soft constraints should be violated)
+            non_zero_scores = 0
+            for constraint in constraints:
+                score_str = constraint.get("score", "")
+                if score_str and score_str != "0hard/0medium/0soft":
+                    non_zero_scores += 1
+                    print(
+                        f"Found non-zero constraint score: {constraint.get('name')} = {score_str}"
+                    )
+
+            # We should have at least some non-zero scores for soft constraints
+            assert non_zero_scores > 0, (
+                f"Expected some non-zero constraint scores, but all were zero. Total constraints: {len(constraints)}"
+            )
+
+            print(
+                f"✅ Analysis test passed: Found {non_zero_scores} constraints with non-zero scores out of {len(constraints)} total constraints"
+            )
+
+            client.delete(f"/schedules/{job_id}")
+            return
+
+    client.delete(f"/schedules/{job_id}")
+    fail("solution is not feasible for analyze constraint scores test")