Alex Grädel

@router.post('/proposals/{pid}/decision')
def decide(pid:str,data:Decision,x_ai_token:str=Header(),x_ai_session:str=Header(),user:dict=Depends(get_current_user)):
    """Accept or reject a pending proposal. Accepting executes the underlying change only if the target record hasn't changed since the proposal was staged; otherwise the proposal is marked Stale."""
    authorize(x_ai_token,'review')
    with connect() as db:
        db.execute('BEGIN IMMEDIATE')
        row=db.execute('SELECT * FROM proposals WHERE id=? AND session=?',(pid,x_ai_session)).fetchone()
        if not row:raise HTTPException(404,'Proposal not found')
        if row['status']!='Pending':return {'status':row['status'],'result':json.loads(row['result']) if row['result'] else None}
        authorize_role(user,row['action'])
        if data.decision=='reject':
            db.execute("UPDATE proposals SET status='Rejected' WHERE id=?",(pid,))
            return {'status':'Rejected'}
        payload=json.loads(row['payload'])
        if baseline(db,row['action'],row['target'],payload)!=row['baseline']:
            db.execute("UPDATE proposals SET status='Stale' WHERE id=?",(pid,))
            return {'status':'Stale','message':'Record changed since proposal. Ask for a new proposal.'}
        from .modules.students.application import create_student,edit_student,mark_attendance
        from .modules.notices.application import create_notice,edit_notice
        from .modules.support.application import create_task,resolve_task,add_note
        from .modules.finance.application import add_teacher,edit_teacher,record_expense,update_payroll_status,allocate_budget
        from .modules.rooms.application import commit_move
        from .modules.absences.application import record_absence
        from .modules.timetable.application import create_event
        handlers={
            'create_student':create_student,'edit_student':edit_student,'mark_attendance':mark_attendance,'record_absence':record_absence,'create_school_event':create_event,
            'create_notice':create_notice,'edit_notice':edit_notice,'create_task':create_task,
            'resolve_task':resolve_task,'add_note':add_note,
            'create_teacher':add_teacher,'edit_teacher':edit_teacher,'record_expense':record_expense,
            'update_payroll_status':update_payroll_status,'allocate_budget':allocate_budget,
            'move_session':commit_move
        }
        validated=validate(row['action'],payload)
        token=active_connection.set(db)
        try:
            args=[validated] if row['target'] is None else [row['target'],validated]
            result=jsonable_encoder(handlers[row['action']](*args))
        finally:active_connection.reset(token)
        db.execute("UPDATE proposals SET status='Accepted',result=? WHERE id=?",(json.dumps(result),pid))
        return {'status':'Accepted','result':result}

for (const [action, config] of Object.entries(writes)) {
	server.registerTool(
		"propose_" + action,
		{
			description:
				config.description +
				". Creates a PENDING proposal only. A human must accept in the UI. Never claim the change was executed.",
			inputSchema: {
				...(config.target
					? {
							target: z
								.number()
								.int()
								.positive()
								.describe("Existing record ID"),
						}
					: {}),
				...config.fields,
			},
		},
		async (args) => {
			const { target, ...payload } = args;
			return request("/api/internal/ai/proposals", {
				action,
				target: target ?? null,
				payload,
			});
		},
	);
}
await server.connect(new StdioServerTransport());

def move_session(
    session: Session,
    move: MoveInput,
    others: list[Session],
    rooms: dict[int, RoomFacts],
    module_codes: dict[int, str],
    teacher_names: dict[int, str] | None = None,
) -> dict:
    """
    Dry run of moving `session`: the session as it would be, the conflicts it
    would take part in, and the conflicts the move clears. `others` are the
    other sessions that could clash (same day, any campus). Saves nothing.
    """
    after = moved(session, move)
    if after.room_id not in rooms:
        raise ValueError('Room not found')
    before = {c['id'] for c in find_conflicts([session, *others], rooms, module_codes, teacher_names)
              if session.id in c['session_ids']}
    now = [c for c in find_conflicts([after, *others], rooms, module_codes, teacher_names)
           if session.id in c['session_ids']]
    return {
        'session': after.model_dump(),
        'ok': not now,
        'conflicts': now,
        'resolved': sorted(before - {c['id'] for c in now}),
    }
 
 
def free_rooms(
    session: Session,
    others: list[Session],
    rooms: dict[int, RoomFacts],
    module_codes: dict[int, str],
) -> list[dict]:
    """
    Rooms on the same campus where `session` could move at the same time
    without any conflict: those on the same floor first (the class stays
    close by), then the smallest suitable, so a fix doesn't take a hall a
    smaller class would fit. Used to suggest conflict fixes.
    """
    here = rooms.get(session.room_id)
    if not here:
        return []
 
    def elsewhere(room: RoomFacts) -> bool:
        return (room.building_id, room.floor) != (here.building_id, here.floor)
 
    options = []
    for room in sorted(rooms.values(), key=lambda r: (elsewhere(r), r.capacity, r.code)):
        if room.id == session.room_id or room.campus_id != here.campus_id:
            continue
        result = move_session(session, MoveInput(room_id=room.id), others, rooms, module_codes)
        if result['ok']:
            options.append({'room_id': room.id, 'code': room.code, 'capacity': room.capacity, 'kind': room.kind})
    return options

	undo(): void {
		const from = this.history.present();
		if (this.saving() || !this.history.undo()) return;
		this.sync(from, this.history.present(), this.i18n.t("Undone."));
	}
 
	redo(): void {
		const from = this.history.present();
		if (this.saving() || !this.history.redo()) return;
		this.sync(from, this.history.present(), this.i18n.t("Redone."));
	}
 
	/** Sends the creates, updates and deletes that turn `from` into `to`. */
	private sync(from: PlanSnapshot, to: PlanSnapshot, done: string): void {
		const host = this.host;
		const building = host?.building();
		if (!host || !building) return;
		const changes = diffPlans(from, to);
		const steps: Observable<unknown>[] = [
			...changes.remove.map((key) =>
				defer(() => this.api.deleteRoom(this.idOf(key))),
			),
			...changes.update.map(([key, draft]) =>
				defer(() => this.api.editRoom(this.idOf(key), draft)),
			),
			...changes.create.map(([key, draft]) =>
				defer(() => this.api.createRoom(building.id, draft)).pipe(
					tap((room) => this.remember(key, room)),
				),
			),
		];
		if (!steps.length) return;
		this.saving.set(true);
		this.newRoom.set(null);
		this.selectedId.set(null);
		concat(...steps, of(null))
			.pipe(last())
			.subscribe({
				next: () => {
					this.saving.set(false);
					host.notify(done);
					host.reload();
				},
				error: (e) => {
					this.saving.set(false);
					host.notify(
						detail(
							e,
							this.i18n.t(
								"That step could not be replayed. The plan shows what is saved.",
							),
						),
					);
					// Start the history again from whatever the server has now.
					host.reload(() => this.restart());
				},
			});
	}

# Swiss statutory employee contributions, 2025/26. The employer pays at least as much again on top.
AHV_IV_EO_RATE = 5.3            # old-age, disability and loss-of-earnings insurance, employee share
ALV_RATE = 1.1                  # unemployment insurance, employee share
ALV_CEILING_YEAR = 148_200      # ALV is only due on salary up to this much a year
DEFAULT_NBU_RATE = 1.0          # non-occupational accident insurance; each insurer sets its own rate
# Occupational pension (BVG): the legal minimum on the coordinated salary.
BVG_ENTRY_THRESHOLD = 22_680
BVG_COORDINATION_DEDUCTION = 26_460
BVG_UPPER_LIMIT = 90_720
BVG_MIN_COORDINATED = 3_780
# Age credits in percent of the coordinated salary, by age in the calendar year; the employee pays half.
BVG_CREDITS = ((25, 34, 7.0), (35, 44, 10.0), (45, 54, 15.0), (55, 65, 18.0))
 
 
def round_to_five(amount: float) -> float:
    """To the nearest 5 Rappen, as Swiss payslips are paid."""
    return round(round(amount * 20) / 20, 2)
 
 
def bvg_credit(age: int | None) -> float:
    if age is None:
        return 0.0
    return next((rate for low, high, rate in BVG_CREDITS if low <= age <= high), 0.0)
 
 
def coordinated_salary(annual: float) -> float:
    """The part of the annual salary the BVG minimum insures."""
    if annual < BVG_ENTRY_THRESHOLD:
        return 0.0
    return max(BVG_MIN_COORDINATED, min(annual, BVG_UPPER_LIMIT) - BVG_COORDINATION_DEDUCTION)
 
 
def deduction_lines(gross: float, birth_year: int | None, year: int, nbu_rate: float = DEFAULT_NBU_RATE) -> list[dict]:
    """
    The employee's statutory deductions from one month's gross pay: AHV/IV/EO,
    ALV up to its ceiling, NBU, and half the BVG age credit on the coordinated
    salary (none without a date of birth, or under 25). Each line is rounded
    to 5 Rappen. Withholding tax (Quellensteuer) is not included.
    """
    age = year - birth_year if birth_year else None
    alv_base = min(gross, ALV_CEILING_YEAR / 12)
    bvg_rate = bvg_credit(age) / 2
    bvg_base = coordinated_salary(gross * 12) / 12
    lines = [
        {'label': 'AHV/IV/EO', 'rate': AHV_IV_EO_RATE, 'base': gross, 'amount': round_to_five(gross * AHV_IV_EO_RATE / 100)},
        {'label': 'ALV', 'rate': ALV_RATE, 'base': round(alv_base, 2), 'amount': round_to_five(alv_base * ALV_RATE / 100)},
    ]
    if nbu_rate:
        lines.append({'label': 'NBU', 'rate': nbu_rate, 'base': gross, 'amount': round_to_five(gross * nbu_rate / 100)})
    if bvg_rate and bvg_base:
        lines.append({'label': 'BVG', 'rate': bvg_rate, 'base': round(bvg_base, 2), 'amount': round_to_five(bvg_base * bvg_rate / 100)})
    return lines

const VERSION = "gradus-v2";
const SHELL = ["/", "/manifest.webmanifest", "/icon.svg"];
// Angular's build names scripts and styles after their content, e.g. main-AB12CD34.js.
const HASHED = /-[\w-]{8,}\.(js|css)$/;
const STATIC = /\.(js|css|woff2?|svg|png|webmanifest)$/;
 
self.addEventListener("install", (event) => {
	event.waitUntil(
		caches
			.open(VERSION)
			.then((cache) => cache.addAll(SHELL))
			.then(() => self.skipWaiting()),
	);
});
 
self.addEventListener("activate", (event) => {
	event.waitUntil(
		caches.keys().then(async (keys) => {
			const stale = keys.filter((k) => k !== VERSION);
			await Promise.all(stale.map((k) => caches.delete(k)));
			await self.clients.claim();
			// An older version may have served files from a previous deploy and left
			// the page blank; reload open tabs so they start over with fresh files.
			if (stale.length === 0) return;
			const windows = await self.clients.matchAll({ type: "window" });
			await Promise.all(
				windows.map((client) => client.navigate(client.url).catch(() => {})),
			);
		}),
	);
});
 
// Only keep real files. Hosting answers unknown paths with the app's HTML page,
// which must never be stored under a script or stylesheet URL.
function cacheable(response, html) {
	if (!response.ok || response.type !== "basic") return false;
	const type = response.headers.get("content-type") || "";
	return html === type.includes("text/html");
}

/** Readable text colour on top of the accent, by WCAG relative luminance. */
export function accentInkFor(accent: string): string {
	const rgb = accent
		.slice(1)
		.match(/.{2}/g)!
		.map((v) => parseInt(v, 16) / 255)
		.map((v) => (v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4));
	const luminance = rgb[0] * 0.2126 + rgb[1] * 0.7152 + rgb[2] * 0.0722;
	return luminance > 0.4 ? "#1c152b" : "#ffffff";
}
 
/** Writes the theme's data attributes and CSS custom properties onto `<html>`. */
export function applyThemeToDocument(
	theme: WorkspaceTheme,
	accentInk: string = accentInkFor(theme.accent),
): void {
	const root = document.documentElement;
	root.dataset["theme"] = theme.mode;
	root.dataset["workspaceBackground"] = theme.background;
	root.dataset["density"] = theme.density;
	root.dataset["motion"] = theme.motion;
	const values: Record<string, string> = {
		"--accent-ink": accentInk,
		"--accent": theme.accent,
		"--bg": theme.canvas,
		"--surface-solid": theme.surface,
		"--sidebar-solid": theme.sidebar,
		"--text": theme.text,
		"--muted": theme.muted,
		"--line": theme.border,
		"--card-radius": theme.radius + "px",
		"--button-radius": theme.buttonRadius + "px",
		"--glass-blur": theme.blur + "px",
		"--surface-opacity": theme.opacity + "%",
		"--dashboard-gap": theme.gap + "px",
		"--workspace-width": theme.maxWidth + "px",
	};
	for (const [key, value] of Object.entries(values))
		root.style.setProperty(key, value);
}