Upload 30 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,86 @@
 ---
-title: Maintenance Scheduling Python
-emoji: 🐨
-colorFrom: green
-colorTo: pink
+title: Maintenance Scheduling (Python)
+emoji: 🔧
+colorFrom: gray
+colorTo: green
 sdk: docker
+app_port: 8080
 pinned: false
 license: apache-2.0
-short_description: Generate the optimal schedule for your maintenance staff
+short_description: SolverForge Maintenance Scheduling problem
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Maintenance Scheduling (Python)
+
+Assign maintenance jobs to crews and schedule them over time, avoiding conflicts and meeting deadlines.
+
+- [Prerequisites](#prerequisites)
+- [Run the application](#run-the-application)
+- [Test the application](#test-the-application)
+
+## Prerequisites
+
+1. Install [Python 3.10, 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/maintenance-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.
+
+## Problem Description
+
+The maintenance scheduling problem assigns maintenance jobs to crews over a planning period while respecting constraints:
+
+### Hard Constraints
+- **Crew conflict**: A crew can only work on one job at a time
+- **Min start date**: Jobs cannot start before their ready date
+- **Max end date**: Jobs must complete before their deadline
+
+### Soft Constraints
+- **Before ideal end date**: Slight penalty for finishing too early (maintenance cycles restart sooner)
+- **After ideal end date**: Heavy penalty for finishing late (risk of missing deadline)
+- **Tag conflict**: Avoid scheduling jobs with the same tag (e.g., same area) at overlapping times
+
+## Test the application
+
+1. Run tests:
+   ```sh
+   $ pytest
+   ```
+
+## More information
+
+Visit [solverforge.org](https://www.solverforge.org).

logging.conf

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

pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "maintenance_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',
+]
+
+
+[project.scripts]
+run-app = "maintenance_scheduling:main"

src/maintenance_scheduling/__init__.py

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

src/maintenance_scheduling/constraints.py

@@ -0,0 +1,225 @@
+from solverforge_legacy.solver.score import (
+    constraint_provider,
+    HardSoftScore,
+    Joiners,
+    ConstraintFactory,
+    Constraint,
+)
+
+from .domain import Job
+
+# Constraint names
+CREW_CONFLICT = "Crew conflict"
+MIN_START_DATE = "Min start date"
+MAX_END_DATE = "Max end date"
+BEFORE_IDEAL_END_DATE = "Before ideal end date"
+AFTER_IDEAL_END_DATE = "After ideal end date"
+TAG_CONFLICT = "Tag conflict"
+
+
+@constraint_provider
+def define_constraints(constraint_factory: ConstraintFactory):
+    """
+    Defines all constraints for the maintenance scheduling problem.
+
+    Args:
+        constraint_factory: The constraint factory.
+
+    Returns:
+        List of all defined constraints.
+    """
+    return [
+        # Hard constraints
+        crew_conflict(constraint_factory),
+        min_start_date(constraint_factory),
+        max_end_date(constraint_factory),
+        # Soft constraints
+        before_ideal_end_date(constraint_factory),
+        after_ideal_end_date(constraint_factory),
+        tag_conflict(constraint_factory),
+    ]
+
+
+# ************************************************************************
+# Hard constraints
+# ************************************************************************
+
+
+def crew_conflict(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    A crew can do at most one maintenance job at the same time.
+
+    Penalizes overlapping jobs assigned to the same crew, proportional to the
+    number of overlapping days.
+    """
+    return (
+        constraint_factory.for_each_unique_pair(
+            Job,
+            Joiners.equal(lambda job: job.crew),
+            Joiners.overlapping(
+                lambda job: job.start_date,
+                lambda job: job.get_end_date(),
+            ),
+        )
+        .filter(lambda job1, job2: job1.crew is not None)
+        .penalize(
+            HardSoftScore.ONE_HARD,
+            lambda job1, job2: _calculate_overlap_days(job1, job2),
+        )
+        .as_constraint(CREW_CONFLICT)
+    )
+
+
+def min_start_date(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Don't start a maintenance job before it's ready to start.
+
+    Penalizes jobs that start before their minimum start date, proportional
+    to the number of days early.
+    """
+    return (
+        constraint_factory.for_each(Job)
+        .filter(
+            lambda job: job.start_date is not None
+            and job.min_start_date is not None
+            and job.start_date < job.min_start_date
+        )
+        .penalize(
+            HardSoftScore.ONE_HARD,
+            lambda job: (job.min_start_date - job.start_date).days,
+        )
+        .as_constraint(MIN_START_DATE)
+    )
+
+
+def max_end_date(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Don't end a maintenance job after it's due.
+
+    Penalizes jobs that end after their maximum end date, proportional
+    to the number of days late.
+    """
+    return (
+        constraint_factory.for_each(Job)
+        .filter(
+            lambda job: job.get_end_date() is not None
+            and job.max_end_date is not None
+            and job.get_end_date() > job.max_end_date
+        )
+        .penalize(
+            HardSoftScore.ONE_HARD,
+            lambda job: (job.get_end_date() - job.max_end_date).days,
+        )
+        .as_constraint(MAX_END_DATE)
+    )
+
+
+# ************************************************************************
+# Soft constraints
+# ************************************************************************
+
+
+def before_ideal_end_date(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Early maintenance is expensive because maintenance cycles restart sooner.
+
+    Penalizes jobs that finish before their ideal end date.
+    Weight: 1 point per day early (lowest priority soft constraint).
+    """
+    return (
+        constraint_factory.for_each(Job)
+        .filter(
+            lambda job: job.get_end_date() is not None
+            and job.ideal_end_date is not None
+            and job.get_end_date() < job.ideal_end_date
+        )
+        .penalize(
+            HardSoftScore.ONE_SOFT,
+            lambda job: (job.ideal_end_date - job.get_end_date()).days,
+        )
+        .as_constraint(BEFORE_IDEAL_END_DATE)
+    )
+
+
+def after_ideal_end_date(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Late maintenance is risky because delays can push it over the due date.
+
+    Penalizes jobs that finish after their ideal end date.
+    Weight: 1,000,000 points per day late (high priority soft constraint).
+    """
+    return (
+        constraint_factory.for_each(Job)
+        .filter(
+            lambda job: job.get_end_date() is not None
+            and job.ideal_end_date is not None
+            and job.get_end_date() > job.ideal_end_date
+        )
+        .penalize(
+            HardSoftScore.of_soft(1_000_000),
+            lambda job: (job.get_end_date() - job.ideal_end_date).days,
+        )
+        .as_constraint(AFTER_IDEAL_END_DATE)
+    )
+
+
+def tag_conflict(constraint_factory: ConstraintFactory) -> Constraint:
+    """
+    Avoid overlapping maintenance jobs with the same tag.
+
+    For example, road maintenance in the same area should not overlap.
+    Penalizes overlapping jobs that share tags, proportional to the number
+    of shared tags and the overlap duration.
+    Weight: 1,000 points per tag per day of overlap.
+    """
+    return (
+        constraint_factory.for_each_unique_pair(
+            Job,
+            Joiners.overlapping(
+                lambda job: job.start_date,
+                lambda job: job.get_end_date(),
+            ),
+        )
+        .filter(lambda job1, job2: len(job1.get_common_tags(job2)) > 0)
+        .penalize(
+            HardSoftScore.of_soft(1_000),
+            lambda job1, job2: len(job1.get_common_tags(job2))
+            * _calculate_overlap_days(job1, job2),
+        )
+        .as_constraint(TAG_CONFLICT)
+    )
+
+
+# ************************************************************************
+# Helper functions
+# ************************************************************************
+
+
+def _calculate_overlap_days(job1: Job, job2: Job) -> int:
+    """
+    Calculate the number of overlapping calendar days between two jobs.
+
+    Args:
+        job1: First job
+        job2: Second job
+
+    Returns:
+        Number of overlapping days (calendar days, not working days)
+    """
+    if job1.start_date is None or job2.start_date is None:
+        return 0
+
+    end1 = job1.get_end_date()
+    end2 = job2.get_end_date()
+
+    if end1 is None or end2 is None:
+        return 0
+
+    # Calculate overlap range
+    overlap_start = max(job1.start_date, job2.start_date)
+    overlap_end = min(end1, end2)
+
+    if overlap_start >= overlap_end:
+        return 0
+
+    return (overlap_end - overlap_start).days

src/maintenance_scheduling/converters.py

@@ -0,0 +1,156 @@
+"""
+Converters for bidirectional transformation between domain objects and API models.
+"""
+
+from datetime import date
+from typing import Dict, List, Optional
+
+from solverforge_legacy.solver import SolverStatus
+from solverforge_legacy.solver.score import HardSoftScore
+
+from . import domain
+
+
+# ************************************************************************
+# Helper functions
+# ************************************************************************
+
+
+def date_to_iso(d: Optional[date]) -> Optional[str]:
+    """Convert a date to ISO format string."""
+    return d.isoformat() if d else None
+
+
+def iso_to_date(s: Optional[str]) -> Optional[date]:
+    """Convert an ISO format string to a date."""
+    return date.fromisoformat(s) if s else None
+
+
+# ************************************************************************
+# Domain -> Model conversions
+# ************************************************************************
+
+
+def work_calendar_to_model(wc: domain.WorkCalendar) -> domain.WorkCalendarModel:
+    """Convert a WorkCalendar domain object to its API model."""
+    return domain.WorkCalendarModel(
+        id=wc.id,
+        from_date=date_to_iso(wc.from_date),
+        to_date=date_to_iso(wc.to_date),
+    )
+
+
+def crew_to_model(crew: domain.Crew) -> domain.CrewModel:
+    """Convert a Crew domain object to its API model."""
+    return domain.CrewModel(id=crew.id, name=crew.name)
+
+
+def job_to_model(job: domain.Job) -> domain.JobModel:
+    """Convert a Job domain object to its API model."""
+    return domain.JobModel(
+        id=job.id,
+        name=job.name,
+        duration_in_days=job.duration_in_days,
+        min_start_date=date_to_iso(job.min_start_date),
+        max_end_date=date_to_iso(job.max_end_date),
+        ideal_end_date=date_to_iso(job.ideal_end_date),
+        tags=list(job.tags),
+        crew=crew_to_model(job.crew) if job.crew else None,
+        start_date=date_to_iso(job.start_date),
+        end_date=date_to_iso(job.get_end_date()),
+    )
+
+
+def schedule_to_model(schedule: domain.MaintenanceSchedule) -> domain.MaintenanceScheduleModel:
+    """Convert a MaintenanceSchedule domain object to its API model."""
+    return domain.MaintenanceScheduleModel(
+        work_calendar=work_calendar_to_model(schedule.work_calendar),
+        crews=[crew_to_model(c) for c in schedule.crews],
+        jobs=[job_to_model(j) for j in schedule.jobs],
+        start_date_range=[date_to_iso(d) for d in schedule.start_date_range],
+        score=str(schedule.score) if schedule.score else None,
+        solver_status=schedule.solver_status.name if schedule.solver_status else None,
+    )
+
+
+# ************************************************************************
+# Model -> Domain conversions
+# ************************************************************************
+
+
+def model_to_work_calendar(model: domain.WorkCalendarModel) -> domain.WorkCalendar:
+    """Convert a WorkCalendarModel to its domain object."""
+    return domain.WorkCalendar(
+        id=model.id,
+        from_date=iso_to_date(model.from_date),
+        to_date=iso_to_date(model.to_date),
+    )
+
+
+def model_to_crew(model: domain.CrewModel) -> domain.Crew:
+    """Convert a CrewModel to its domain object."""
+    return domain.Crew(id=model.id, name=model.name)
+
+
+def model_to_schedule(model: domain.MaintenanceScheduleModel) -> domain.MaintenanceSchedule:
+    """
+    Convert a MaintenanceScheduleModel to its domain object.
+
+    Handles reference resolution for crew assignments.
+    """
+    # Create work calendar
+    work_calendar = model_to_work_calendar(model.work_calendar)
+
+    # Create crews and lookup
+    crews: List[domain.Crew] = [model_to_crew(c) for c in model.crews]
+    crew_lookup: Dict[str, domain.Crew] = {c.id: c for c in crews}
+
+    # Create jobs with crew references resolved
+    jobs: List[domain.Job] = []
+    for job_model in model.jobs:
+        # Resolve crew reference
+        crew = None
+        if job_model.crew:
+            if isinstance(job_model.crew, str):
+                crew = crew_lookup.get(job_model.crew)
+            elif isinstance(job_model.crew, domain.CrewModel):
+                crew = crew_lookup.get(job_model.crew.id)
+
+        job = domain.Job(
+            id=job_model.id,
+            name=job_model.name,
+            duration_in_days=job_model.duration_in_days,
+            min_start_date=iso_to_date(job_model.min_start_date),
+            max_end_date=iso_to_date(job_model.max_end_date),
+            ideal_end_date=iso_to_date(job_model.ideal_end_date),
+            tags=set(job_model.tags) if job_model.tags else set(),
+            crew=crew,
+            start_date=iso_to_date(job_model.start_date) if job_model.start_date else None,
+        )
+        jobs.append(job)
+
+    # Parse start_date_range
+    start_date_range = (
+        [iso_to_date(d) for d in model.start_date_range]
+        if model.start_date_range
+        else []
+    )
+
+    # Parse score
+    score = None
+    if model.score:
+        score = HardSoftScore.parse(model.score)
+
+    # Parse solver status
+    solver_status = SolverStatus.NOT_SOLVING
+    if model.solver_status:
+        solver_status = SolverStatus[model.solver_status]
+
+    return domain.MaintenanceSchedule(
+        work_calendar=work_calendar,
+        crews=crews,
+        jobs=jobs,
+        start_date_range=start_date_range,
+        score=score,
+        solver_status=solver_status,
+    )

src/maintenance_scheduling/demo_data.py

@@ -0,0 +1,124 @@
+from datetime import date, timedelta
+from enum import Enum
+from random import Random
+from typing import List
+
+from .domain import (
+    Crew,
+    Job,
+    MaintenanceSchedule,
+    WorkCalendar,
+    calculate_end_date,
+    create_start_date_range,
+)
+
+
+class DemoData(Enum):
+    SMALL = "SMALL"
+    LARGE = "LARGE"
+
+
+# Job area names for generating job names
+JOB_AREA_NAMES = [
+    "Downtown", "Uptown", "Park", "Airport", "Bay", "Hill", "Forest", "Station",
+    "Hospital", "Harbor", "Market", "Fort", "Beach", "Garden", "River", "Springs",
+    "Tower", "Mountain"
+]
+
+# Job target names for generating job names
+JOB_TARGET_NAMES = [
+    "Street", "Bridge", "Tunnel", "Highway", "Boulevard", "Avenue", "Square", "Plaza"
+]
+
+
+def _get_next_monday(from_date: date) -> date:
+    """Get the next Monday on or after the given date."""
+    days_until_monday = (7 - from_date.weekday()) % 7
+    if days_until_monday == 0 and from_date.weekday() != 0:
+        days_until_monday = 7
+    return from_date + timedelta(days=days_until_monday)
+
+
+def generate_demo_data(demo_data: DemoData) -> MaintenanceSchedule:
+    """
+    Generate demo data for the maintenance scheduling problem.
+
+    Args:
+        demo_data: The demo data type (SMALL or LARGE)
+
+    Returns:
+        A MaintenanceSchedule with crews, work calendar, and jobs
+    """
+    # Create crews
+    crews: List[Crew] = [
+        Crew(id="1", name="Alpha crew"),
+        Crew(id="2", name="Beta crew"),
+        Crew(id="3", name="Gamma crew"),
+    ]
+    if demo_data == DemoData.LARGE:
+        crews.append(Crew(id="4", name="Delta crew"))
+        crews.append(Crew(id="5", name="Epsilon crew"))
+
+    # Create work calendar
+    from_date = _get_next_monday(date.today())
+    week_list_size = 16 if demo_data == DemoData.LARGE else 8
+    to_date = from_date + timedelta(weeks=week_list_size)
+    work_calendar = WorkCalendar(id="1", from_date=from_date, to_date=to_date)
+
+    workday_total = week_list_size * 5
+
+    # Create jobs
+    jobs: List[Job] = []
+    job_list_size = week_list_size * len(crews) * 3 // 5
+    job_area_target_limit = min(len(JOB_TARGET_NAMES), len(crews) * 2)
+    random = Random(17)  # Same seed as Java
+
+    for i in range(job_list_size):
+        job_area = JOB_AREA_NAMES[i // job_area_target_limit]
+        job_target = JOB_TARGET_NAMES[i % job_area_target_limit]
+
+        # 1 day to 2 workweeks (1 workweek on average)
+        duration_in_days = 1 + random.randint(0, 9)
+
+        # Calculate date constraints with at least 5 days of flexibility
+        min_max_between_workdays = (
+            duration_in_days + 5
+            + random.randint(0, workday_total - (duration_in_days + 5) - 1)
+        )
+        min_workday_offset = random.randint(0, workday_total - min_max_between_workdays)
+        min_ideal_end_between_workdays = min_max_between_workdays - 1 - random.randint(0, 3)
+
+        # Calculate dates using the weekend-skipping calculation
+        min_start_date = calculate_end_date(from_date, min_workday_offset)
+        max_end_date = calculate_end_date(min_start_date, min_max_between_workdays)
+        ideal_end_date = calculate_end_date(min_start_date, min_ideal_end_between_workdays)
+
+        # 10% chance of having "Subway" tag
+        if random.random() < 0.1:
+            tags = {job_area, "Subway"}
+        else:
+            tags = {job_area}
+
+        jobs.append(Job(
+            id=str(i),
+            name=f"{job_area} {job_target}",
+            duration_in_days=duration_in_days,
+            min_start_date=min_start_date,
+            max_end_date=max_end_date,
+            ideal_end_date=ideal_end_date,
+            tags=tags,
+        ))
+
+    # Create and return the schedule
+    schedule = MaintenanceSchedule(
+        work_calendar=work_calendar,
+        crews=crews,
+        jobs=jobs,
+    )
+
+    # The start_date_range will be auto-populated by __post_init__
+    # But let's ensure it's populated
+    if not schedule.start_date_range:
+        schedule.start_date_range = create_start_date_range(from_date, to_date)
+
+    return schedule

src/maintenance_scheduling/domain.py

@@ -0,0 +1,253 @@
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from typing import List, Optional, Annotated, Union, Set
+
+from solverforge_legacy.solver import SolverStatus
+from solverforge_legacy.solver.score import HardSoftScore
+from solverforge_legacy.solver.domain import (
+    planning_entity,
+    planning_solution,
+    PlanningId,
+    PlanningVariable,
+    PlanningEntityCollectionProperty,
+    ProblemFactCollectionProperty,
+    ProblemFactProperty,
+    ValueRangeProvider,
+    PlanningScore,
+)
+from .json_serialization import JsonDomainBase
+from pydantic import Field
+
+
+# ************************************************************************
+# Utility functions for working day calculations
+# ************************************************************************
+
+
+def calculate_end_date(start_date: Optional[date], duration_in_days: int) -> Optional[date]:
+    """
+    Calculate the end date by adding working days to the start date, skipping weekends.
+
+    The end date is exclusive (like Java's implementation).
+
+    Args:
+        start_date: The start date (inclusive)
+        duration_in_days: Number of working days the job takes
+
+    Returns:
+        The end date (exclusive), or None if start_date is None
+    """
+    if start_date is None:
+        return None
+
+    # Skip weekends. Does not work for holidays.
+    # Keep in sync with create_start_date_range().
+    # Formula: For every 5 working days plus the weekday offset, add 2 weekend days
+    # Python weekday(): Monday=0, Tuesday=1, ..., Sunday=6
+    weekend_padding = 2 * ((duration_in_days + start_date.weekday()) // 5)
+    return start_date + timedelta(days=duration_in_days + weekend_padding)
+
+
+def count_working_days_between(start: date, end: date) -> int:
+    """
+    Count the number of working days (Mon-Fri) between two dates.
+
+    Args:
+        start: Start date (inclusive)
+        end: End date (exclusive)
+
+    Returns:
+        Number of working days between the dates
+    """
+    if start >= end:
+        return 0
+
+    count = 0
+    current = start
+    while current < end:
+        if current.weekday() < 5:  # Monday=0 to Friday=4
+            count += 1
+        current += timedelta(days=1)
+    return count
+
+
+def create_start_date_range(from_date: date, to_date: date) -> List[date]:
+    """
+    Generate a list of working days (Mon-Fri) within the date range.
+
+    Args:
+        from_date: Start of range (inclusive)
+        to_date: End of range (exclusive)
+
+    Returns:
+        List of working days in the range
+    """
+    dates = []
+    current = from_date
+    while current < to_date:
+        if current.weekday() < 5:  # Monday=0 to Friday=4
+            dates.append(current)
+        current += timedelta(days=1)
+    return dates
+
+
+# ************************************************************************
+# Domain classes
+# ************************************************************************
+
+
+@dataclass
+class WorkCalendar:
+    """Defines the planning window for the schedule."""
+    id: Annotated[str, PlanningId]
+    from_date: date  # Inclusive
+    to_date: date    # Exclusive
+
+
+@dataclass
+class Crew:
+    """A maintenance crew that can be assigned to jobs."""
+    id: Annotated[str, PlanningId]
+    name: str
+
+    def __hash__(self):
+        return hash(self.id)
+
+    def __eq__(self, other):
+        if isinstance(other, Crew):
+            return self.id == other.id
+        return False
+
+    def __str__(self):
+        return f"{self.name}({self.id})"
+
+
+@planning_entity
+@dataclass
+class Job:
+    """
+    A maintenance job that needs to be scheduled.
+
+    Planning variables:
+    - crew: The crew assigned to this job
+    - start_date: When the job starts (inclusive)
+
+    The end_date is computed from start_date and duration_in_days.
+    """
+    id: Annotated[str, PlanningId]
+    name: str
+    duration_in_days: int
+    min_start_date: date    # Inclusive - earliest the job can start
+    max_end_date: date      # Exclusive - latest the job can end
+    ideal_end_date: date    # Exclusive - preferred end date
+    tags: Set[str] = field(default_factory=set)
+
+    # Planning variables
+    crew: Annotated[Optional[Crew], PlanningVariable] = None
+    start_date: Annotated[Optional[date], PlanningVariable] = None
+
+    def get_end_date(self) -> Optional[date]:
+        """Calculate the end date based on start_date and duration."""
+        return calculate_end_date(self.start_date, self.duration_in_days)
+
+    @property
+    def end_date(self) -> Optional[date]:
+        """End date property for convenient access."""
+        return self.get_end_date()
+
+    def calculate_overlap(self, other: "Job") -> int:
+        """
+        Calculate the number of overlapping working days with another job.
+
+        Args:
+            other: The other job to compare with
+
+        Returns:
+            Number of overlapping working days
+        """
+        if self.start_date is None or other.start_date is None:
+            return 0
+
+        self_end = self.get_end_date()
+        other_end = other.get_end_date()
+
+        if self_end is None or other_end is None:
+            return 0
+
+        # Calculate overlap range
+        overlap_start = max(self.start_date, other.start_date)
+        overlap_end = min(self_end, other_end)
+
+        if overlap_start >= overlap_end:
+            return 0
+
+        return count_working_days_between(overlap_start, overlap_end)
+
+    def get_common_tags(self, other: "Job") -> Set[str]:
+        """Get the tags that both jobs share."""
+        return self.tags & other.tags
+
+    def __str__(self):
+        return f"{self.name}({self.id})"
+
+
+@planning_solution
+@dataclass
+class MaintenanceSchedule:
+    """
+    The planning solution containing the schedule to be optimized.
+    """
+    work_calendar: Annotated[WorkCalendar, ProblemFactProperty]
+    crews: Annotated[List[Crew], ProblemFactCollectionProperty, ValueRangeProvider]
+    jobs: Annotated[List[Job], PlanningEntityCollectionProperty]
+    start_date_range: Annotated[
+        List[date], ProblemFactCollectionProperty, ValueRangeProvider
+    ] = field(default_factory=list)
+    score: Annotated[Optional[HardSoftScore], PlanningScore] = None
+    solver_status: SolverStatus = SolverStatus.NOT_SOLVING
+
+    def __post_init__(self):
+        """Initialize start_date_range if not provided."""
+        if not self.start_date_range and self.work_calendar:
+            self.start_date_range = create_start_date_range(
+                self.work_calendar.from_date,
+                self.work_calendar.to_date
+            )
+
+
+# ************************************************************************
+# Pydantic REST models for API
+# ************************************************************************
+
+
+class WorkCalendarModel(JsonDomainBase):
+    id: str
+    from_date: str = Field(..., alias="fromDate")  # ISO date string
+    to_date: str = Field(..., alias="toDate")
+
+
+class CrewModel(JsonDomainBase):
+    id: str
+    name: str
+
+
+class JobModel(JsonDomainBase):
+    id: str
+    name: str
+    duration_in_days: int = Field(..., alias="durationInDays")
+    min_start_date: str = Field(..., alias="minStartDate")
+    max_end_date: str = Field(..., alias="maxEndDate")
+    ideal_end_date: str = Field(..., alias="idealEndDate")
+    tags: List[str] = Field(default_factory=list)
+    crew: Optional[Union[str, CrewModel]] = None
+    start_date: Optional[str] = Field(None, alias="startDate")
+    end_date: Optional[str] = Field(None, alias="endDate")
+
+
+class MaintenanceScheduleModel(JsonDomainBase):
+    work_calendar: WorkCalendarModel = Field(..., alias="workCalendar")
+    crews: List[CrewModel]
+    jobs: List[JobModel]
+    start_date_range: List[str] = Field(default_factory=list, alias="startDateRange")
+    score: Optional[str] = None
+    solver_status: Optional[str] = Field(None, alias="solverStatus")

src/maintenance_scheduling/json_serialization.py

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

src/maintenance_scheduling/rest_api.py

@@ -0,0 +1,149 @@
+"""
+FastAPI REST endpoints for the maintenance scheduling application.
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+from uuid import uuid4
+from typing import Dict, List
+from dataclasses import asdict
+import logging
+
+from .domain import MaintenanceSchedule, MaintenanceScheduleModel
+from .converters import schedule_to_model, model_to_schedule
+from .score_analysis import ConstraintAnalysisDTO, MatchAnalysisDTO
+from .demo_data import generate_demo_data, DemoData
+from .solver import solver_manager, solution_manager
+
+
+logger = logging.getLogger(__name__)
+
+app = FastAPI(docs_url='/q/swagger-ui')
+
+data_sets: Dict[str, MaintenanceSchedule] = {}
+
+
+# ************************************************************************
+# Demo Data Endpoints
+# ************************************************************************
+
+
+@app.get("/demo-data")
+async def get_demo_data_list() -> List[str]:
+    """Get available demo data sets."""
+    return [demo.name for demo in DemoData]
+
+
+@app.get("/demo-data/{demo_name}", response_model=MaintenanceScheduleModel)
+async def get_demo_data_by_name(demo_name: str) -> MaintenanceScheduleModel:
+    """Get a specific demo data set."""
+    try:
+        demo = DemoData[demo_name]
+        schedule = generate_demo_data(demo)
+        return schedule_to_model(schedule)
+    except KeyError:
+        raise HTTPException(status_code=404, detail=f"Demo data '{demo_name}' not found")
+
+
+# ************************************************************************
+# Schedule Endpoints
+# ************************************************************************
+
+
+@app.get("/schedules")
+async def list_schedules() -> List[str]:
+    """List the job IDs of all submitted schedules."""
+    return list(data_sets.keys())
+
+
+@app.post("/schedules")
+async def solve_schedule(model: MaintenanceScheduleModel) -> str:
+    """
+    Submit a schedule for solving.
+
+    Returns the job ID that can be used to track progress and retrieve results.
+    """
+    job_id = str(uuid4())
+    schedule = model_to_schedule(model)
+    data_sets[job_id] = schedule
+    solver_manager.solve_and_listen(
+        job_id,
+        schedule,
+        lambda solution: data_sets.update({job_id: solution})
+    )
+    return job_id
+
+
+@app.get("/schedules/{job_id}", response_model=MaintenanceScheduleModel)
+async def get_schedule(job_id: str) -> MaintenanceScheduleModel:
+    """Get the current solution for a job."""
+    schedule = data_sets.get(job_id)
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+    schedule.solver_status = solver_manager.get_solver_status(job_id)
+    return schedule_to_model(schedule)
+
+
+@app.get("/schedules/{job_id}/status")
+async def get_schedule_status(job_id: str) -> dict:
+    """Get the status and score for a job (lightweight, without full solution)."""
+    schedule = data_sets.get(job_id)
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+    solver_status = solver_manager.get_solver_status(job_id)
+    return {
+        "score": str(schedule.score) if schedule.score else None,
+        "solverStatus": solver_status.name if solver_status else None,
+    }
+
+
+@app.delete("/schedules/{job_id}", response_model=MaintenanceScheduleModel)
+async def stop_solving(job_id: str) -> MaintenanceScheduleModel:
+    """Terminate solving and return the best solution so far."""
+    solver_manager.terminate_early(job_id)
+    schedule = data_sets.get(job_id)
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+    schedule.solver_status = solver_manager.get_solver_status(job_id)
+    return schedule_to_model(schedule)
+
+
+# ************************************************************************
+# Score Analysis Endpoint
+# ************************************************************************
+
+
+@app.put("/schedules/analyze")
+async def analyze_schedule(model: MaintenanceScheduleModel) -> dict:
+    """
+    Analyze the constraints in a schedule.
+
+    Returns detailed information about which constraints are satisfied or violated.
+    """
+    schedule = model_to_schedule(model)
+    analysis = solution_manager.analyze(schedule)
+    constraints = []
+    for constraint in getattr(analysis, 'constraint_analyses', []) or []:
+        matches = [
+            MatchAnalysisDTO(
+                name=str(getattr(getattr(match, 'constraint_ref', None), 'constraint_name', "")),
+                score=str(getattr(match, 'score', "0hard/0soft")),
+                justification=str(getattr(match, 'justification', ""))
+            )
+            for match in getattr(constraint, 'matches', []) or []
+        ]
+        constraints.append(ConstraintAnalysisDTO(
+            name=str(getattr(constraint, 'constraint_name', "")),
+            weight=str(getattr(constraint, 'weight', "0hard/0soft")),
+            score=str(getattr(constraint, 'score', "0hard/0soft")),
+            matches=matches
+        ))
+    return {"constraints": [asdict(constraint) for constraint in constraints]}
+
+
+# ************************************************************************
+# Static Files
+# ************************************************************************
+
+
+app.mount("/", StaticFiles(directory="static", html=True), name="static")

src/maintenance_scheduling/score_analysis.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import Annotated
+
+from solverforge_legacy.solver.score import HardSoftScore
+from .json_serialization import ScoreSerializer
+
+
+@dataclass
+class MatchAnalysisDTO:
+    name: str
+    score: Annotated[HardSoftScore, ScoreSerializer]
+    justification: object
+
+
+@dataclass
+class ConstraintAnalysisDTO:
+    name: str
+    weight: Annotated[HardSoftScore, ScoreSerializer]
+    matches: list[MatchAnalysisDTO]
+    score: Annotated[HardSoftScore, ScoreSerializer]

src/maintenance_scheduling/solver.py

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

static/app.js

@@ -0,0 +1,607 @@
+// Maintenance Scheduling Color Palette
+const COLOR_IDEAL = '#8AE234';           // Green - in ideal window
+const COLOR_IDEAL_BG = '#8AE23433';      // Green with transparency
+const COLOR_ACCEPTABLE = '#FCAF3E';      // Orange - after ideal, before due
+const COLOR_ACCEPTABLE_BG = '#FCAF3E33'; // Orange with transparency
+const COLOR_OVERDUE = '#EF2929';         // Red - past due date
+const COLOR_OVERDUE_BG = '#EF292999';    // Red with transparency
+const BRAND_GREEN = '#10b981';           // SolverForge brand green
+const HIGHLIGHT_COLOR = 'rgba(99, 102, 241, 0.15)'; // Indigo highlight
+
+var autoRefreshIntervalId = null;
+let highlightedCrewId = null;
+
+let demoDataId = null;
+let scheduleId = null;
+let loadedSchedule = null;
+
+const byCrewPanel = document.getElementById("byCrewPanel");
+const byCrewTimelineOptions = {
+    timeAxis: {scale: "day"},
+    orientation: {axis: "top"},
+    stack: false,
+    xss: {disabled: true}, // Items are XSS safe through JQuery
+    zoomMin: 3 * 1000 * 60 * 60 * 24 // Three day in milliseconds
+};
+var byCrewGroupData = new vis.DataSet();
+var byCrewItemData = new vis.DataSet();
+var byCrewTimeline = new vis.Timeline(byCrewPanel, byCrewItemData, byCrewGroupData, byCrewTimelineOptions);
+
+const byJobPanel = document.getElementById("byJobPanel");
+const byJobTimelineOptions = {
+    timeAxis: {scale: "day"},
+    orientation: {axis: "top"},
+    xss: {disabled: true}, // Items are XSS safe through JQuery
+    zoomMin: 3 * 1000 * 60 * 60 * 24 // Three day in milliseconds
+};
+var byJobGroupData = new vis.DataSet();
+var byJobItemData = new vis.DataSet();
+var byJobTimeline = new vis.Timeline(byJobPanel, byJobItemData, byJobGroupData, byJobTimelineOptions);
+
+
+$(document).ready(function () {
+    replaceQuickstartSolverForgeAutoHeaderFooter();
+
+    $("#solveButton").click(function () {
+        solve();
+    });
+    $("#stopSolvingButton").click(function () {
+        stopSolving();
+    });
+    $("#analyzeButton").click(function () {
+        analyze();
+    });
+    // HACK to allow vis-timeline to work within Bootstrap tabs
+    $("#byCrewTab").on('shown.bs.tab', function (event) {
+        byCrewTimeline.redraw();
+    })
+    $("#byJobTab").on('shown.bs.tab', function (event) {
+        byJobTimeline.redraw();
+    })
+
+    // Timeline item click handlers
+    byCrewTimeline.on('select', function(properties) {
+        if (properties.items.length > 0) {
+            const itemId = properties.items[0];
+            // Ignore background items (they have underscore in ID like "job1_readyToIdealEnd")
+            if (!String(itemId).includes('_')) {
+                showJobDetails(itemId);
+            }
+            byCrewTimeline.setSelection([]); // Clear selection
+        }
+    });
+    byJobTimeline.on('select', function(properties) {
+        if (properties.items.length > 0) {
+            const itemId = properties.items[0];
+            if (!String(itemId).includes('_')) {
+                showJobDetails(itemId);
+            }
+            byJobTimeline.setSelection([]);
+        }
+    });
+
+    setupAjax();
+    fetchDemoData();
+});
+
+function setupAjax() {
+    $.ajaxSetup({
+        headers: {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json,text/plain', // plain text is required by solve() returning UUID of the solver job
+        }
+    });
+
+    // Extend jQuery to support $.put() and $.delete()
+    jQuery.each(["put", "delete"], function (i, method) {
+        jQuery[method] = function (url, data, callback, type) {
+            if (jQuery.isFunction(data)) {
+                type = type || callback;
+                callback = data;
+                data = undefined;
+            }
+            return jQuery.ajax({
+                url: url,
+                type: method,
+                dataType: type,
+                data: data,
+                success: callback
+            });
+        };
+    });
+}
+
+function fetchDemoData() {
+    $.get("/demo-data", function (data) {
+        data.forEach(item => {
+            $("#testDataButton").append($('<a id="' + item + 'TestData" class="dropdown-item" href="#">' + item + '</a>'));
+
+            $("#" + item + "TestData").click(function () {
+                switchDataDropDownItemActive(item);
+                scheduleId = null;
+                demoDataId = item;
+
+                refreshSchedule();
+            });
+        });
+
+        // load first data set
+        demoDataId = data[0];
+        switchDataDropDownItemActive(demoDataId);
+        refreshSchedule();
+    }).fail(function (xhr, ajaxOptions, thrownError) {
+        // disable this page as there is no data
+        let $demo = $("#demo");
+        $demo.empty();
+        $demo.html("<h1><p align=\"center\">No test data available</p></h1>")
+    });
+}
+
+function switchDataDropDownItemActive(newItem) {
+    activeCssClass = "active";
+    $("#testDataButton > a." + activeCssClass).removeClass(activeCssClass);
+    $("#" + newItem + "TestData").addClass(activeCssClass);
+}
+
+function refreshSchedule() {
+    let path = "/schedules/" + scheduleId;
+    if (scheduleId === null) {
+        if (demoDataId === null) {
+            alert("Please select a test data set.");
+            return;
+        }
+
+        path = "/demo-data/" + demoDataId;
+    }
+
+    $.getJSON(path, function (schedule) {
+        loadedSchedule = schedule;
+        renderSchedule(schedule);
+    })
+        .fail(function (xhr, ajaxOptions, thrownError) {
+            showError("Getting the schedule has failed.", xhr);
+            refreshSolvingButtons(false);
+        });
+}
+
+function renderSchedule(schedule) {
+    refreshSolvingButtons(schedule.solverStatus != null && schedule.solverStatus !== "NOT_SOLVING");
+    $("#score").text("Score: " + (schedule.score == null ? "?" : schedule.score));
+
+    const unassignedJobs = $("#unassignedJobs");
+    unassignedJobs.children().remove();
+    var unassignedJobsCount = 0;
+    byCrewGroupData.clear();
+    byJobGroupData.clear();
+    byCrewItemData.clear();
+    byJobItemData.clear();
+
+    $.each(schedule.crews, (index, crew) => {
+        byCrewGroupData.add({id: crew.id, content: crew.name});
+    });
+
+    $.each(schedule.jobs, (index, job) => {
+        const jobGroupElement = $(`<div/>`)
+            .append($(`<h5 class="card-title mb-1"/>`).text(job.name))
+            .append($(`<p class="card-text ms-2 mb-0"/>`).text(`${job.durationInDays} workdays`));
+        byJobGroupData.add({
+            id: job.id,
+            content: jobGroupElement.html()
+        });
+        byJobItemData.add({
+            id: job.id + "_readyToIdealEnd", group: job.id,
+            start: job.minStartDate, end: job.idealEndDate,
+            type: "background",
+            style: `background-color: ${COLOR_IDEAL_BG}`
+        });
+        byJobItemData.add({
+            id: job.id + "_idealEndToDue", group: job.id,
+            start: job.idealEndDate, end: job.maxEndDate,
+            type: "background",
+            style: `background-color: ${COLOR_ACCEPTABLE_BG}`
+        });
+
+        if (job.crew == null || job.startDate == null) {
+            unassignedJobsCount++;
+            const unassignedJobElement = $(`<div class="card-body p-2"/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text(job.name))
+                .append($(`<p class="card-text ms-2 mb-0"/>`).text(`${job.durationInDays} workdays`))
+                .append($(`<p class="card-text ms-2 mb-0"/>`).text(`Start: ${job.minStartDate}`))
+                .append($(`<p class="card-text ms-2 mb-0"/>`).text(`End: ${job.maxEndDate}`));
+            const byJobJobElement = $(`<div/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text(`Unassigned`));
+            $.each(job.tags, (index, tag) => {
+                const color = pickColor(tag);
+                unassignedJobElement.append($(`<span class="badge me-1" style="background-color: ${color}"/>`).text(tag));
+                byJobJobElement.append($(`<span class="badge me-1" style="background-color: ${color}"/>`).text(tag));
+            });
+            const card = $(`<div class="card" style="cursor: pointer;"/>`).append(unassignedJobElement);
+            card.click(() => showJobDetails(job.id));
+            unassignedJobs.append($(`<div class="col"/>`).append(card));
+            byJobItemData.add({
+                id: job.id,
+                group: job.id,
+                content: byJobJobElement.html(),
+                start: job.minStartDate,
+                end: JSJoda.LocalDate.parse(job.minStartDate).plusDays(job.durationInDays).toString(),
+                style: `background-color: ${COLOR_OVERDUE_BG}`
+            });
+        } else {
+            const beforeReady = JSJoda.LocalDate.parse(job.startDate).isBefore(JSJoda.LocalDate.parse(job.minStartDate));
+            const afterDue = JSJoda.LocalDate.parse(job.endDate).isAfter(JSJoda.LocalDate.parse(job.maxEndDate));
+            const byCrewJobElement = $(`<div/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text(job.name))
+                .append($(`<p class="card-text ms-2 mb-0"/>`).text(`${job.durationInDays} workdays`));
+            const byJobJobElement = $(`<div/>`)
+                .append($(`<h5 class="card-title mb-1"/>`).text(job.crew.name));
+            if (beforeReady) {
+                byCrewJobElement.append($(`<p class="badge badge-danger mb-0"/>`).text(`Before ready (too early)`));
+                byJobJobElement.append($(`<p class="badge badge-danger mb-0"/>`).text(`Before ready (too early)`));
+            }
+            if (afterDue) {
+                byCrewJobElement.append($(`<p class="badge badge-danger mb-0"/>`).text(`After due (too late)`));
+                byJobJobElement.append($(`<p class="badge badge-danger mb-0"/>`).text(`After due (too late)`));
+            }
+            $.each(job.tags, (index, tag) => {
+                const color = pickColor(tag);
+                byCrewJobElement.append($(`<span class="badge me-1" style="background-color: ${color}"/>`).text(tag));
+                byJobJobElement.append($(`<span class="badge me-1" style="background-color: ${color}"/>`).text(tag));
+            });
+            byCrewItemData.add({
+                id: job.id, group: job.crew.id,
+                content: byCrewJobElement.html(),
+                start: job.startDate, end: job.endDate
+            });
+            byJobItemData.add({
+                id: job.id, group: job.id,
+                content: byJobJobElement.html(),
+                start: job.startDate, end: job.endDate,
+                crewId: job.crew.id
+            });
+        }
+    });
+    if (unassignedJobsCount === 0) {
+        unassignedJobs.append($(`<p/>`).text(`There are no unassigned jobs.`));
+    }
+    byCrewTimeline.setWindow(schedule.workCalendar.fromDate, schedule.workCalendar.toDate);
+    byJobTimeline.setWindow(schedule.workCalendar.fromDate, schedule.workCalendar.toDate);
+
+    // Render crew table and clear any previous highlighting
+    renderCrewTable(schedule);
+    highlightedCrewId = null;
+}
+
+function solve() {
+    $.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() {
+    analyzeScore(loadedSchedule, "/schedules/analyze");
+}
+
+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 = document.getElementById(id).innerText;
+    navigator.clipboard.writeText(text);
+}
+
+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 d-flex align-items-center gap-3">
+              <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>`),
+    );
+  }
+}
+
+// ****************************************************************************
+// Job Details Modal
+// ****************************************************************************
+
+function showJobDetails(jobId) {
+    const job = loadedSchedule.jobs.find(j => j.id === jobId);
+    if (!job) return;
+
+    $("#jobDetailsName").text(job.name);
+    $("#jobDetailsCrew").html(job.crew ?
+        `<i class="fas fa-hard-hat me-1"></i>${job.crew.name}` :
+        '<span class="text-danger">Unassigned</span>');
+    $("#jobDetailsDuration").text(`${job.durationInDays} workdays`);
+    $("#jobDetailsMinStart").text(job.minStartDate);
+    $("#jobDetailsMaxEnd").text(job.maxEndDate);
+    $("#jobDetailsIdealEnd").text(job.idealEndDate);
+
+    if (job.startDate && job.endDate) {
+        $("#jobDetailsScheduled").text(`${job.startDate} to ${job.endDate}`);
+    } else {
+        $("#jobDetailsScheduled").html('<span class="text-muted">Not scheduled</span>');
+    }
+
+    // Tags
+    const tagsContainer = $("#jobDetailsTags");
+    tagsContainer.empty();
+    if (job.tags && job.tags.length > 0) {
+        job.tags.forEach(tag => {
+            const color = pickColor(tag);
+            tagsContainer.append($(`<span class="badge me-1" style="background-color: ${color}"/>`).text(tag));
+        });
+    } else {
+        tagsContainer.html('<span class="text-muted">None</span>');
+    }
+
+    // Status alerts
+    const statusDiv = $("#jobDetailsStatus");
+    statusDiv.hide().removeClass("alert-danger alert-warning alert-success");
+
+    if (!job.crew || !job.startDate) {
+        statusDiv.addClass("alert-danger").text("This job is not assigned to any crew.").show();
+    } else {
+        const beforeReady = JSJoda.LocalDate.parse(job.startDate).isBefore(JSJoda.LocalDate.parse(job.minStartDate));
+        const afterDue = JSJoda.LocalDate.parse(job.endDate).isAfter(JSJoda.LocalDate.parse(job.maxEndDate));
+        const afterIdeal = JSJoda.LocalDate.parse(job.endDate).isAfter(JSJoda.LocalDate.parse(job.idealEndDate));
+
+        if (beforeReady) {
+            statusDiv.addClass("alert-warning").text("Scheduled before ready date (too early).").show();
+        } else if (afterDue) {
+            statusDiv.addClass("alert-danger").text("Scheduled after due date (too late).").show();
+        } else if (afterIdeal) {
+            statusDiv.addClass("alert-warning").text("Ends after ideal date.").show();
+        } else {
+            statusDiv.addClass("alert-success").text("Scheduled within ideal window.").show();
+        }
+    }
+
+    new bootstrap.Modal("#jobDetailsModal").show();
+}
+
+// ****************************************************************************
+// Crew Details Modal
+// ****************************************************************************
+
+function showCrewDetails(crewId) {
+    const crew = loadedSchedule.crews.find(c => c.id === crewId);
+    if (!crew) return;
+
+    const crewJobs = loadedSchedule.jobs.filter(j => j.crew && j.crew.id === crewId);
+    const totalWorkdays = crewJobs.reduce((sum, j) => sum + j.durationInDays, 0);
+
+    $("#crewDetailsName").text(crew.name);
+    $("#crewDetailsJobCount").text(crewJobs.length);
+    $("#crewDetailsWorkdays").text(totalWorkdays);
+
+    // Job list
+    const jobList = $("#crewDetailsJobList");
+    jobList.empty();
+
+    if (crewJobs.length === 0) {
+        jobList.append('<div class="list-group-item text-muted">No jobs assigned</div>');
+    } else {
+        crewJobs.forEach(job => {
+            const afterDue = job.endDate && JSJoda.LocalDate.parse(job.endDate).isAfter(JSJoda.LocalDate.parse(job.maxEndDate));
+            const statusIcon = afterDue ?
+                '<i class="fas fa-exclamation-triangle text-danger me-2"></i>' :
+                '<i class="fas fa-check-circle text-success me-2"></i>';
+
+            const item = $(`
+                <a href="#" class="list-group-item list-group-item-action d-flex justify-content-between align-items-center">
+                    <div>
+                        ${statusIcon}
+                        <strong>${job.name}</strong>
+                        <small class="text-muted ms-2">${job.durationInDays} days</small>
+                    </div>
+                    <small class="text-muted">${job.startDate || 'Not scheduled'}</small>
+                </a>
+            `);
+            item.click((e) => {
+                e.preventDefault();
+                bootstrap.Modal.getInstance(document.getElementById('crewDetailsModal')).hide();
+                setTimeout(() => showJobDetails(job.id), 300);
+            });
+            jobList.append(item);
+        });
+    }
+
+    new bootstrap.Modal("#crewDetailsModal").show();
+}
+
+// ****************************************************************************
+// Crew Highlighting
+// ****************************************************************************
+
+function renderCrewTable(schedule) {
+    const crewTableBody = $("#crewTableBody");
+    crewTableBody.empty();
+
+    schedule.crews.forEach(crew => {
+        const crewJobs = schedule.jobs.filter(j => j.crew && j.crew.id === crew.id);
+        const totalWorkdays = crewJobs.reduce((sum, j) => sum + j.durationInDays, 0);
+        const color = pickColor("crew" + crew.id);
+
+        const row = $(`
+            <tr class="crew-row" data-crew-id="${crew.id}">
+                <td>
+                    <div class="crew-color-indicator" style="background-color: ${color};">
+                        <i class="fas fa-hard-hat"></i>
+                    </div>
+                </td>
+                <td><strong>${crew.name}</strong></td>
+                <td>${crewJobs.length}</td>
+                <td>${totalWorkdays}</td>
+                <td>
+                    <button class="btn btn-sm btn-outline-secondary crew-info-btn" title="View details">
+                        <i class="fas fa-info-circle"></i>
+                    </button>
+                </td>
+            </tr>
+        `);
+
+        // Click row to highlight
+        row.click((e) => {
+            if (!$(e.target).closest('.crew-info-btn').length) {
+                toggleCrewHighlight(crew.id);
+            }
+        });
+
+        // Click info button to show details
+        row.find('.crew-info-btn').click((e) => {
+            e.stopPropagation();
+            showCrewDetails(crew.id);
+        });
+
+        crewTableBody.append(row);
+    });
+}
+
+function toggleCrewHighlight(crewId) {
+    if (highlightedCrewId === crewId) {
+        clearCrewHighlight();
+    } else {
+        highlightCrew(crewId);
+    }
+}
+
+function clearCrewHighlight() {
+    highlightedCrewId = null;
+    $(".crew-row").removeClass("table-active");
+
+    // Reset timeline item opacity in both views
+    byCrewItemData.forEach(item => {
+        if (item.originalStyle !== undefined) {
+            byCrewItemData.update({ id: item.id, style: item.originalStyle });
+        }
+    });
+    byJobItemData.forEach(item => {
+        if (item.originalStyle !== undefined) {
+            byJobItemData.update({ id: item.id, style: item.originalStyle });
+        }
+    });
+}
+
+function highlightCrew(crewId) {
+    highlightedCrewId = crewId;
+
+    // Highlight table row
+    $(".crew-row").removeClass("table-active");
+    $(`[data-crew-id="${crewId}"]`).addClass("table-active");
+
+    // Dim non-highlighted timeline items in "By crew" view
+    byCrewItemData.forEach(item => {
+        if (item.originalStyle === undefined) {
+            item.originalStyle = item.style || "";
+        }
+        if (item.group !== crewId) {
+            byCrewItemData.update({
+                id: item.id,
+                style: item.originalStyle + "; opacity: 0.25;"
+            });
+        } else {
+            byCrewItemData.update({
+                id: item.id,
+                style: item.originalStyle
+            });
+        }
+    });
+
+    // Dim non-highlighted timeline items in "By job" view
+    byJobItemData.forEach(item => {
+        if (item.originalStyle === undefined) {
+            item.originalStyle = item.style || "";
+        }
+        // Check if this job belongs to the highlighted crew
+        if (item.crewId !== crewId && item.type !== "background") {
+            byJobItemData.update({
+                id: item.id,
+                style: item.originalStyle + "; opacity: 0.25;"
+            });
+        } else if (item.type !== "background") {
+            byJobItemData.update({
+                id: item.id,
+                style: item.originalStyle
+            });
+        }
+    });
+}

static/index.html

@@ -0,0 +1,356 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+    <title>Maintenance Scheduling - SolverForge for Python</title>
+
+    <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="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="/webjars/solverforge/css/solverforge-webui.css"/>
+    <link rel="icon" href="/webjars/solverforge/img/solverforge-favicon.svg" type="image/svg+xml">
+    <style>
+        /* Weekend highlighting */
+        .vis-time-axis .vis-grid.vis-saturday,
+        .vis-time-axis .vis-grid.vis-sunday {
+            background: #D3D7CFFF;
+        }
+
+        /* Solving spinner animation */
+        #solvingSpinner {
+            display: none;
+            width: 1.25rem;
+            height: 1.25rem;
+            border: 2px solid #10b981;
+            border-top-color: transparent;
+            border-radius: 50%;
+            animation: spin 0.75s linear infinite;
+            vertical-align: middle;
+        }
+        #solvingSpinner.active {
+            display: inline-block;
+        }
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        /* Button hover effects */
+        .btn {
+            transition: all 0.2s ease;
+        }
+        #solveButton:hover {
+            transform: translateY(-1px);
+            box-shadow: 0 2px 8px rgba(16, 185, 129, 0.3);
+        }
+        #stopSolvingButton:hover {
+            transform: translateY(-1px);
+            box-shadow: 0 2px 8px rgba(220, 53, 69, 0.3);
+        }
+
+        /* Unassigned job cards */
+        #unassignedJobs .card {
+            transition: transform 0.2s ease, box-shadow 0.2s ease;
+            border-left: 4px solid #ef4444;
+        }
+        #unassignedJobs .card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(239, 68, 68, 0.2);
+        }
+
+        /* Crew table styling */
+        #crewTable tbody tr.crew-row {
+            cursor: pointer;
+            transition: background-color 0.2s ease;
+        }
+        #crewTable tbody tr.crew-row:hover {
+            background-color: rgba(99, 102, 241, 0.1);
+        }
+        #crewTable tbody tr.crew-row.table-active {
+            background-color: rgba(99, 102, 241, 0.15) !important;
+        }
+        .crew-color-indicator {
+            width: 1.5rem;
+            height: 1.5rem;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        .crew-color-indicator i {
+            color: white;
+            font-size: 0.65rem;
+        }
+
+        /* Timeline styling */
+        .vis-item .vis-item-content {
+            font-size: 0.85rem;
+            padding: 2px 4px;
+        }
+        .vis-labelset .vis-label {
+            padding: 4px 8px;
+        }
+        .vis-item:not(.vis-background) {
+            cursor: pointer;
+        }
+        .vis-item:not(.vis-background):hover {
+            filter: brightness(1.05);
+        }
+
+        /* Score analysis table hover */
+        #scoreAnalysisModalContent .table tbody tr {
+            transition: background-color 0.15s ease;
+        }
+        #scoreAnalysisModalContent .table tbody tr:hover {
+            background-color: rgba(99, 102, 241, 0.08);
+        }
+
+        /* Score display styling */
+        .score {
+            color: #1f2937;
+        }
+    </style>
+</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>Road maintenance schedule solver</h1>
+    <p>Generate the optimal schedule for your maintenance staff.</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="solvingSpinner" class="ms-2"></span>
+        <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="byCrewTab" data-bs-toggle="tab" data-bs-target="#byCrewPanel" type="button" role="tab" aria-controls="byCrewPanel" aria-selected="true">By crew</button>
+                </li>
+                <li class="nav-item" role="presentation">
+                    <button class="nav-link" id="byJobTab" data-bs-toggle="tab" data-bs-target="#byJobPanel" type="button" role="tab" aria-controls="byJobPanel" aria-selected="false">By job</button>
+                </li>
+            </ul>
+        </div>
+    </div>
+    <div class="row mb-4">
+        <div class="col-md-3">
+            <h5>Crews <small class="text-muted"><i class="fas fa-hand-pointer"></i> Click to highlight</small></h5>
+            <table class="table table-sm" id="crewTable">
+                <thead>
+                    <tr>
+                        <th style="width: 2rem;"></th>
+                        <th>Crew</th>
+                        <th>Jobs</th>
+                        <th>Days</th>
+                        <th style="width: 2.5rem;"></th>
+                    </tr>
+                </thead>
+                <tbody id="crewTableBody"></tbody>
+            </table>
+        </div>
+        <div class="col-md-9">
+            <div class="tab-content">
+                <div class="tab-pane fade show active" id="byCrewPanel" role="tabpanel" aria-labelledby="byCrewTab">
+                </div>
+                <div class="tab-pane fade" id="byJobPanel" role="tabpanel" aria-labelledby="byJobTab">
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <h2>Unassigned jobs</h2>
+    <div id="unassignedJobs" class="row row-cols-3 g-3 mb-4"></div>
+</div>
+
+    <div id="rest" class="tab-pane fade  container-fluid">
+        <h1>REST API Guide</h1>
+
+        <h2>Maintenance Scheduling solver integration via cURL</h2>
+
+        <h3>1. Download demo data</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl1')">Copy</button>
+            <code id="curl1">curl -X GET -H 'Accept:application/json' http://localhost:8080/demo-data/SMALL -o sample.json</code>
+    </pre>
+
+        <h3>2. Post the sample data for solving</h3>
+        <p>The POST operation returns a <code>jobId</code> that should be used in subsequent commands.</p>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl2')">Copy</button>
+            <code id="curl2">curl -X POST -H 'Content-Type:application/json' http://localhost:8080/schedules -d@sample.json</code>
+    </pre>
+
+        <h3>3. Get the current status and score</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl3')">Copy</button>
+            <code id="curl3">curl -X GET -H 'Accept:application/json' http://localhost:8080/schedules/{jobId}/status</code>
+    </pre>
+
+        <h3>4. Get the complete solution</h3>
+        <pre>
+            <button class="btn btn-outline-dark btn-sm float-end"
+                    onclick="copyTextToClipboard('curl4')">Copy</button>
+            <code id="curl4">curl -X GET -H 'Accept:application/json' http://localhost:8080/schedules/{jobId}</code>
+    </pre>
+
+        <h3>5. 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>
+<div class="modal fadebd-example-modal-lg" id="scoreAnalysisModal" tabindex="-1"
+     aria-labelledby="scoreAnalysisModalLabel" aria-hidden="true">
+    <div class="modal-dialog modal-lg modal-dialog-scrollable">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h1 class="modal-title fs-5" id="scoreAnalysisModalLabel">Score analysis <span
+                        id="scoreAnalysisScoreLabel"></span></h1>
+
+                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+            </div>
+            <div class="modal-body" id="scoreAnalysisModalContent">
+                <!-- Filled in by app.js -->
+            </div>
+            <div class="modal-footer">
+                <button type="button" class="btn btn-primary" data-bs-dismiss="modal">Close</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- Job Details Modal -->
+<div class="modal fade" id="jobDetailsModal" tabindex="-1" aria-labelledby="jobDetailsModalLabel" aria-hidden="true">
+    <div class="modal-dialog">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title" id="jobDetailsModalLabel">
+                    <i class="fas fa-wrench me-2"></i><span id="jobDetailsName"></span>
+                </h5>
+                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+            </div>
+            <div class="modal-body">
+                <div class="row mb-3">
+                    <div class="col-6">
+                        <small class="text-muted">Assigned Crew</small>
+                        <div id="jobDetailsCrew" class="fw-bold"></div>
+                    </div>
+                    <div class="col-6">
+                        <small class="text-muted">Duration</small>
+                        <div id="jobDetailsDuration" class="fw-bold"></div>
+                    </div>
+                </div>
+                <div class="row mb-3">
+                    <div class="col-6">
+                        <small class="text-muted">Ready Date</small>
+                        <div id="jobDetailsMinStart"></div>
+                    </div>
+                    <div class="col-6">
+                        <small class="text-muted">Due Date</small>
+                        <div id="jobDetailsMaxEnd"></div>
+                    </div>
+                </div>
+                <div class="row mb-3">
+                    <div class="col-6">
+                        <small class="text-muted">Ideal End Date</small>
+                        <div id="jobDetailsIdealEnd"></div>
+                    </div>
+                    <div class="col-6">
+                        <small class="text-muted">Scheduled</small>
+                        <div id="jobDetailsScheduled"></div>
+                    </div>
+                </div>
+                <div class="mb-3">
+                    <small class="text-muted">Tags</small>
+                    <div id="jobDetailsTags"></div>
+                </div>
+                <div id="jobDetailsStatus" class="alert mb-0" style="display: none;"></div>
+            </div>
+            <div class="modal-footer">
+                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- Crew Details Modal -->
+<div class="modal fade" id="crewDetailsModal" tabindex="-1" aria-labelledby="crewDetailsModalLabel" aria-hidden="true">
+    <div class="modal-dialog">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title" id="crewDetailsModalLabel">
+                    <i class="fas fa-hard-hat me-2"></i><span id="crewDetailsName"></span>
+                </h5>
+                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+            </div>
+            <div class="modal-body">
+                <div class="row mb-3">
+                    <div class="col-6">
+                        <small class="text-muted">Assigned Jobs</small>
+                        <div id="crewDetailsJobCount" class="fw-bold fs-4"></div>
+                    </div>
+                    <div class="col-6">
+                        <small class="text-muted">Total Workdays</small>
+                        <div id="crewDetailsWorkdays" class="fw-bold fs-4"></div>
+                    </div>
+                </div>
+                <h6>Assigned Jobs</h6>
+                <div id="crewDetailsJobList" class="list-group list-group-flush"></div>
+            </div>
+            <div class="modal-footer">
+                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.3/js/bootstrap.bundle.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/@js-joda/core@5.6.3/dist/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="/score-analysis.js"></script>
+<script src="/app.js"></script>
+</body>
+</html>

static/score-analysis.js

@@ -0,0 +1,98 @@
+function analyzeScore(solution, endpointPath) {
+    const modalElement = document.getElementById("scoreAnalysisModal");
+    const modal = bootstrap.Modal.getOrCreateInstance(modalElement);
+    modal.show();
+    const scoreAnalysisModalContent = $("#scoreAnalysisModalContent");
+    scoreAnalysisModalContent.children().remove();
+    scoreAnalysisModalContent.text("");
+
+    if (solution.score == null) {
+        scoreAnalysisModalContent.text("Score not ready for analysis, try to run the solver first or wait until it advances.");
+    } else {
+        visualizeScoreAnalysis(scoreAnalysisModalContent, solution, endpointPath)
+    }
+}
+
+function visualizeScoreAnalysis(scoreAnalysisModalContent, solution, endpointPath) {
+    $('#scoreAnalysisScoreLabel').text(`(${solution.score})`);
+    $.put(endpointPath, JSON.stringify(solution), function (scoreAnalysis) {
+        let constraints = scoreAnalysis.constraints;
+        constraints.sort(compareConstraintsBySeverity);
+        constraints.map(addDerivedScoreAttributes);
+        scoreAnalysis.constraints = constraints;
+
+        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, function (index, constraintAnalysis) {
+            visualizeConstraintAnalysis(analysisTBody, index, constraintAnalysis)
+        });
+        analysisTable.append(analysisTBody);
+        scoreAnalysisModalContent.append(analysisTable);
+    }).fail(function (xhr, ajaxOptions, thrownError) {
+            showError("Score analysis failed.", xhr);
+        },
+        "text");
+}
+
+function compareConstraintsBySeverity(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);
+        }
+    }
+}
+
+function addDerivedScoreAttributes(constraint) {
+    let components = getScoreComponents(constraint.weight);
+    constraint.type = components.hard != 0 ? 'hard' : (components.medium != 0 ? 'medium' : 'soft');
+    constraint.weight = components[constraint.type];
+    let scores = getScoreComponents(constraint.score);
+    constraint.implicitScore = scores.hard != 0 ? scores.hard : (scores.medium != 0 ? scores.medium : scores.soft);
+}
+
+function getScoreComponents(score) {
+    let components = {hard: 0, medium: 0, soft: 0};
+
+    $.each([...score.matchAll(/(-?[0-9]+)(hard|medium|soft)/g)], function (i, parts) {
+        components[parts[2]] = parseInt(parts[1], 10);
+    });
+
+    return components;
+}
+
+function visualizeConstraintAnalysis(analysisTBody, constraintIndex, constraintAnalysis, recommendation = false, recommendationIndex = null) {
+    let icon = constraintAnalysis.type == "hard" && constraintAnalysis.implicitScore < 0 ? '<span class="fas fa-exclamation-triangle" style="color: red"></span>' : '';
+    if (!icon) icon = constraintAnalysis.weight < 0 && 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(recommendation ? constraintAnalysis.score : constraintAnalysis.implicitScore));
+
+    analysisTBody.append(row);
+    row.append($(`<td/>`));
+}

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.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>
+        </nav>
+      </div>`));
+  }
+  const solverforgeFooter = $("footer#solverforge-auto-footer");
+  if (solverforgeFooter != null) {
+    solverforgeFooter.append(
+      $(`<footer class="bg-light text-muted">
+           <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/test_constraints.py

@@ -0,0 +1,263 @@
+"""
+Unit tests for the maintenance scheduling constraints using ConstraintVerifier.
+"""
+
+from datetime import date, timedelta
+
+from solverforge_legacy.solver.test import ConstraintVerifier
+
+from maintenance_scheduling.domain import (
+    Crew,
+    Job,
+    MaintenanceSchedule,
+    WorkCalendar,
+    calculate_end_date,
+)
+from maintenance_scheduling.constraints import (
+    define_constraints,
+    crew_conflict,
+    min_start_date,
+    max_end_date,
+    before_ideal_end_date,
+    after_ideal_end_date,
+    tag_conflict,
+)
+
+
+# Test fixtures
+CREW_A = Crew(id="A", name="Crew A")
+CREW_B = Crew(id="B", name="Crew B")
+START_DATE = date(2024, 1, 8)  # A Monday
+WORK_CALENDAR = WorkCalendar(
+    id="cal",
+    from_date=START_DATE,
+    to_date=START_DATE + timedelta(days=60)
+)
+
+
+constraint_verifier = ConstraintVerifier.build(
+    define_constraints, MaintenanceSchedule, Job
+)
+
+
+def create_job(
+    job_id: str,
+    duration: int = 3,
+    crew: Crew = None,
+    start_offset: int = 0,
+    tags: set = None,
+    min_start_offset: int = 0,
+    max_end_offset: int = 30,
+    ideal_end_offset: int = 20,
+) -> Job:
+    """Helper function to create a Job with computed dates."""
+    start = calculate_end_date(START_DATE, start_offset) if crew else None
+    min_start = calculate_end_date(START_DATE, min_start_offset)
+    max_end = calculate_end_date(START_DATE, max_end_offset)
+    ideal_end = calculate_end_date(START_DATE, ideal_end_offset)
+
+    return Job(
+        id=job_id,
+        name=f"Job {job_id}",
+        duration_in_days=duration,
+        min_start_date=min_start,
+        max_end_date=max_end,
+        ideal_end_date=ideal_end,
+        tags=tags or set(),
+        crew=crew,
+        start_date=start,
+    )
+
+
+# ************************************************************************
+# Crew conflict tests
+# ************************************************************************
+
+
+def test_crew_conflict_no_overlap():
+    """Two jobs with same crew but no time overlap should not penalize."""
+    # Job 1: days 0-2 (3 days)
+    job1 = create_job("1", duration=3, crew=CREW_A, start_offset=0)
+    # Job 2: days 5-7 (3 days) - no overlap
+    job2 = create_job("2", duration=3, crew=CREW_A, start_offset=5)
+
+    constraint_verifier.verify_that(crew_conflict).given(job1, job2).penalizes_by(0)
+
+
+def test_crew_conflict_with_overlap():
+    """Two jobs with same crew and overlapping dates should penalize."""
+    # Job 1: days 0-4 (5 days)
+    job1 = create_job("1", duration=5, crew=CREW_A, start_offset=0)
+    # Job 2: days 3-7 (5 days) - overlaps on days 3-4
+    job2 = create_job("2", duration=5, crew=CREW_A, start_offset=3)
+
+    # Should penalize for the overlap
+    constraint_verifier.verify_that(crew_conflict).given(job1, job2).penalizes()
+
+
+def test_different_crews_no_conflict():
+    """Two overlapping jobs with different crews should not penalize."""
+    job1 = create_job("1", duration=5, crew=CREW_A, start_offset=0)
+    job2 = create_job("2", duration=5, crew=CREW_B, start_offset=2)
+
+    constraint_verifier.verify_that(crew_conflict).given(job1, job2).penalizes_by(0)
+
+
+# ************************************************************************
+# Min start date tests
+# ************************************************************************
+
+
+def test_min_start_date_valid():
+    """Job starting on or after min start date should not penalize."""
+    job = create_job(
+        "1",
+        duration=3,
+        crew=CREW_A,
+        start_offset=5,
+        min_start_offset=0,  # Can start from day 0
+    )
+
+    constraint_verifier.verify_that(min_start_date).given(job).penalizes_by(0)
+
+
+def test_min_start_date_violation():
+    """Job starting before min start date should penalize."""
+    job = create_job(
+        "1",
+        duration=3,
+        crew=CREW_A,
+        start_offset=0,
+        min_start_offset=5,  # Can't start until day 5
+    )
+
+    # Started 5 days early
+    constraint_verifier.verify_that(min_start_date).given(job).penalizes()
+
+
+# ************************************************************************
+# Max end date tests
+# ************************************************************************
+
+
+def test_max_end_date_valid():
+    """Job ending on or before max end date should not penalize."""
+    job = create_job(
+        "1",
+        duration=3,
+        crew=CREW_A,
+        start_offset=0,
+        max_end_offset=30,  # Due day 30
+    )
+
+    constraint_verifier.verify_that(max_end_date).given(job).penalizes_by(0)
+
+
+def test_max_end_date_violation():
+    """Job ending after max end date should penalize."""
+    job = create_job(
+        "1",
+        duration=10,
+        crew=CREW_A,
+        start_offset=0,
+        max_end_offset=5,  # Due day 5, but job takes 10 days
+    )
+
+    constraint_verifier.verify_that(max_end_date).given(job).penalizes()
+
+
+# ************************************************************************
+# Before ideal end date tests
+# ************************************************************************
+
+
+def test_before_ideal_end_date_valid():
+    """Job ending at or after ideal end date should not penalize."""
+    job = create_job(
+        "1",
+        duration=15,
+        crew=CREW_A,
+        start_offset=0,
+        ideal_end_offset=10,  # Ideal by day 10, job ends after
+    )
+
+    constraint_verifier.verify_that(before_ideal_end_date).given(job).penalizes_by(0)
+
+
+def test_before_ideal_end_date_violation():
+    """Job ending before ideal end date should penalize."""
+    job = create_job(
+        "1",
+        duration=3,
+        crew=CREW_A,
+        start_offset=0,
+        ideal_end_offset=20,  # Ideal by day 20, but job ends day 3
+    )
+
+    constraint_verifier.verify_that(before_ideal_end_date).given(job).penalizes()
+
+
+# ************************************************************************
+# After ideal end date tests
+# ************************************************************************
+
+
+def test_after_ideal_end_date_valid():
+    """Job ending at or before ideal end date should not penalize."""
+    job = create_job(
+        "1",
+        duration=3,
+        crew=CREW_A,
+        start_offset=0,
+        ideal_end_offset=20,  # Ideal by day 20
+    )
+
+    constraint_verifier.verify_that(after_ideal_end_date).given(job).penalizes_by(0)
+
+
+def test_after_ideal_end_date_violation():
+    """Job ending after ideal end date should penalize heavily."""
+    job = create_job(
+        "1",
+        duration=10,
+        crew=CREW_A,
+        start_offset=0,
+        ideal_end_offset=5,  # Ideal by day 5, but job takes 10 days
+    )
+
+    constraint_verifier.verify_that(after_ideal_end_date).given(job).penalizes()
+
+
+# ************************************************************************
+# Tag conflict tests
+# ************************************************************************
+
+
+def test_tag_conflict_no_common_tags():
+    """Overlapping jobs with no common tags should not penalize."""
+    job1 = create_job("1", duration=5, crew=CREW_A, start_offset=0, tags={"Downtown"})
+    job2 = create_job("2", duration=5, crew=CREW_B, start_offset=2, tags={"Airport"})
+
+    constraint_verifier.verify_that(tag_conflict).given(job1, job2).penalizes_by(0)
+
+
+def test_tag_conflict_with_common_tags():
+    """Overlapping jobs with common tags should penalize."""
+    job1 = create_job(
+        "1", duration=5, crew=CREW_A, start_offset=0,
+        tags={"Downtown", "Subway"}
+    )
+    job2 = create_job(
+        "2", duration=5, crew=CREW_B, start_offset=2,
+        tags={"Downtown"}  # Shares "Downtown" tag
+    )
+
+    constraint_verifier.verify_that(tag_conflict).given(job1, job2).penalizes()
+
+
+def test_tag_conflict_no_overlap():
+    """Non-overlapping jobs with common tags should not penalize."""
+    job1 = create_job("1", duration=3, crew=CREW_A, start_offset=0, tags={"Downtown"})
+    job2 = create_job("2", duration=3, crew=CREW_B, start_offset=10, tags={"Downtown"})
+
+    constraint_verifier.verify_that(tag_conflict).given(job1, job2).penalizes_by(0)