jacobh2
6d92b87bf3
A repeating period was a single row that the planner expanded into one window per year at read time, so no year had anywhere to differ from the others. Editing one year rewrote them all, and removing a year in the middle had to split the wish in two. Neither survives contact with the thing this app is for: Easter moves, and the cheapest week is not the same week every year. Each year is now its own row, linked by a series id. Editing one year touches one row; editing the series re-projects the rest from it. Removing a year is one delete. The weekday snap is worked out once, when the rows are made, and stored, so a row now says what it means rather than being re-derived on every read. Recurrence stops being a stored field and becomes what it always was in practice — an instruction at create and update time; whether a period repeats is whether it belongs to a series. Migration 004 rebuilds the table and expands the existing rows, keeping each original row as its first year so the days already planned against it still point somewhere. A Feb 29 anchor recurring into a common year used to raise out of the allocator; it clamps now. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ei7gCZzdd751uZtPzb1Pep
756 lines
30 KiB
Python
756 lines
30 KiB
Python
"""Tips engine.
|
||
|
||
Architecture:
|
||
- `Tip` is a plain dataclass returned to the router.
|
||
- `RULE_REGISTRY` is a list of async functions; each takes a `TipsContext`
|
||
and returns a `Tip | None`. None means the rule doesn't apply right now.
|
||
- `TipsService.get_tips()` runs all rules and returns the non-None results.
|
||
|
||
All 12 rules from ARCHITECTURE.md §6.1 are registered; the stubs return None
|
||
until implemented. This lets the junior wire rules one at a time by editing the
|
||
corresponding function without touching the plumbing.
|
||
|
||
To add a new rule:
|
||
1. Write an async function `_rule_<id>(ctx: TipsContext) -> Tip | None`.
|
||
2. Append it to RULE_REGISTRY.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
from collections import defaultdict
|
||
from dataclasses import dataclass
|
||
from datetime import date, timedelta
|
||
from typing import Callable, Coroutine, TypeAlias
|
||
from uuid import UUID, uuid4
|
||
|
||
from dateutil.relativedelta import relativedelta as _relativedelta
|
||
|
||
from app.config import settings
|
||
from app.entities.child import Child
|
||
from app.entities.leave_wish import LeaveWish
|
||
from app.entities.parental_leave import ParentalLeaveFetch
|
||
from app.entities.personal_data import PersonalData
|
||
from app.entities.planned_leave import PlannedLeaveDay
|
||
from app.entities.tip_dismissal import TipDismissal
|
||
from app.entities.vacation_days import VacationDays
|
||
from app.repositories.child_repository import ChildRepository
|
||
from app.repositories.leave_wish_repository import LeaveWishRepository
|
||
from app.repositories.parental_leave_repository import ParentalLeaveRepository
|
||
from app.repositories.personal_data_repository import PersonalDataRepository
|
||
from app.repositories.planned_leave_repository import PlannedLeaveRepository
|
||
from app.repositories.tip_dismissal_repository import TipDismissalRepository
|
||
from app.repositories.vacation_days_repository import VacationDaysRepository
|
||
from app.utils.errors import NotFoundError
|
||
from app.utils.tip_predicates import (
|
||
age4_pooling_loss,
|
||
days_left_at_age_4_projection,
|
||
has_vacation_near_expiry,
|
||
hash_tip_data,
|
||
is_child_over_age,
|
||
preschool_buffer_needed,
|
||
red_day_clusters_in_range,
|
||
resolve_age4_savable_cap,
|
||
sgi_at_risk,
|
||
weekly_intensity,
|
||
)
|
||
|
||
|
||
@dataclass
|
||
class Tip:
|
||
id: str
|
||
severity: str # 'info' | 'warning' | 'action'
|
||
message_key: str # i18n key for frontend
|
||
data: dict # context for frontend rendering (e.g. {days: 5, period: "Jul–Aug"})
|
||
# Where this tip is anchored on a calendar: a single day (e.g. "use this
|
||
# vacation day"), a span (e.g. a break period), or neither. Lifted out of
|
||
# `data` — where the value already lived — rather than invented; see the
|
||
# individual rules for which `data` key each maps to. Rules with no
|
||
# meaningful date (balance_between_parents, lagsta_niva_coverage,
|
||
# stretch_time_at_home, sgi_minimum_after_age_1,
|
||
# reserve_for_preschool_planning_days) leave both null.
|
||
anchor_date: date | None = None
|
||
anchor_range: tuple[date, date] | None = None
|
||
|
||
|
||
@dataclass
|
||
class TipsContext:
|
||
workspace_id: UUID
|
||
# Either empty (the workspace-level context — see `_WORKSPACE_SCOPED_RULES`
|
||
# in `TipsService`) or a single child (a per-child context, built once per
|
||
# child in `_build_context`). Never more than one: entitlement and
|
||
# planned days are tracked per child, so a rule scoped to "the" child
|
||
# would silently pick an arbitrary one in a multi-child workspace.
|
||
children: list[Child]
|
||
parents: list[PersonalData]
|
||
leave_by_parent: dict[UUID, ParentalLeaveFetch | None] # personal_data_uuid → latest
|
||
# Future planned days for `children[0]` only (empty for the workspace
|
||
# context) — see `_build_context`.
|
||
planned_days: list[PlannedLeaveDay]
|
||
vacation_by_parent: dict[UUID, list[VacationDays]]
|
||
leave_wishes: list[LeaveWish]
|
||
today: date # injected for deterministic testing
|
||
|
||
|
||
# Type alias for a rule function.
|
||
RuleFn: TypeAlias = Callable[[TipsContext], Coroutine[None, None, Tip | None]]
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Rule implementations (stub → return None until fully wired)
|
||
# ---------------------------------------------------------------------------
|
||
|
||
|
||
async def _rule_use_vacation_before_expiry(ctx: TipsContext) -> Tip | None:
|
||
for parent in ctx.parents:
|
||
for vd in ctx.vacation_by_parent.get(parent.uuid, []):
|
||
if has_vacation_near_expiry(vd.total_days, vd.saved_days_in):
|
||
# `vd.year` is the only date-shaped fact this rule has; anchor
|
||
# to that vacation year's last day — the natural forcing point
|
||
# for "use it before it's gone" — rather than leaving the rail
|
||
# with nothing to place this tip on.
|
||
year_end = date(vd.year, 12, 31)
|
||
return Tip(
|
||
id="use_vacation_before_expiry",
|
||
severity="warning",
|
||
message_key="tips.use_vacation_before_expiry",
|
||
data={
|
||
"parent_name": parent.name,
|
||
"saved_days": vd.saved_days_in,
|
||
"year": vd.year,
|
||
},
|
||
anchor_date=year_end,
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_balance_between_parents(ctx: TipsContext) -> Tip | None:
|
||
if len(ctx.parents) < 2:
|
||
return None
|
||
usages = [
|
||
(p, ctx.leave_by_parent[p.uuid].days_used)
|
||
for p in ctx.parents
|
||
if ctx.leave_by_parent.get(p.uuid) is not None
|
||
]
|
||
if len(usages) < 2:
|
||
return None
|
||
leading, leading_used = max(usages, key=lambda x: x[1])
|
||
lagging, lagging_used = min(usages, key=lambda x: x[1])
|
||
gap = leading_used - lagging_used
|
||
if gap > 30:
|
||
return Tip(
|
||
id="balance_between_parents",
|
||
severity="info",
|
||
message_key="tips.balance_between_parents",
|
||
data={
|
||
"leading_parent": leading.name,
|
||
"lagging_parent": lagging.name,
|
||
"gap_days": gap,
|
||
},
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_preserve_for_age_4(ctx: TipsContext) -> Tip | None:
|
||
if not ctx.children:
|
||
return None
|
||
child = ctx.children[0]
|
||
fourth_bday = child.birth_date + _relativedelta(years=4)
|
||
savable_cap = resolve_age4_savable_cap(len(ctx.parents))
|
||
for parent in ctx.parents:
|
||
leave = ctx.leave_by_parent.get(parent.uuid)
|
||
if leave is None:
|
||
continue
|
||
planned_fp_before_b4 = sum(
|
||
1
|
||
for d in ctx.planned_days
|
||
if d.parent_personal_data_uuid == parent.uuid
|
||
and d.day_type in ("sjukpenning", "lagsta")
|
||
and d.date < fourth_bday
|
||
)
|
||
_, expiring_at_b4 = days_left_at_age_4_projection(
|
||
leave.days_used, planned_fp_before_b4, leave.total_days, savable_cap
|
||
)
|
||
if expiring_at_b4 > 0:
|
||
return Tip(
|
||
id="preserve_for_age_4",
|
||
severity="warning",
|
||
message_key="tips.preserve_for_age_4",
|
||
data={
|
||
"parent_name": parent.name,
|
||
"expiring_days": expiring_at_b4,
|
||
"fourth_birthday": fourth_bday.isoformat(),
|
||
},
|
||
anchor_date=fourth_bday,
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_age4_pooling_loss(ctx: TipsContext) -> Tip | None:
|
||
"""Warn a family when one parent is over the per-parent age-4 cap while
|
||
|
||
another has unused headroom — days that could have been pooled but won't
|
||
be, because `resolve_age4_savable_cap` splits the ceiling per parent as
|
||
soon as the child has 2+ parents (see `age4_pooling_loss`). This fires
|
||
for any 2+-parent family — the per-parent cut (and the pooling loss it
|
||
can cause) is a legal fact about the child having two parents, purely a
|
||
function of parent count.
|
||
|
||
Advice order is the substance of this tip: taking more leave before the
|
||
birthday converts entitlement into actual time at home (strictly
|
||
better), so it is offered first. Transferring days at Försäkringskassan
|
||
only preserves the entitlement — it is offered second, and the transfer
|
||
figure is bounded by what `ParentalLeaveFetch.transferable_days_left`
|
||
(not the raw days-left total, which includes non-transferable reserved
|
||
days) says is actually movable. When the partner has no FK snapshot the
|
||
exact transfer figure can't be known, so the tip degrades to a hedged
|
||
"if you both have days left" phrasing instead of guessing a number.
|
||
"""
|
||
if len(ctx.parents) < 2 or not ctx.children:
|
||
return None
|
||
|
||
child = ctx.children[0]
|
||
if not is_child_over_age(child.birth_date, settings.rules.age4_pooling_tip_min_child_age_years):
|
||
return None # first couple of years: too early to usefully act on this
|
||
|
||
fourth_bday = child.birth_date + _relativedelta(years=4)
|
||
per_parent_cap = resolve_age4_savable_cap(len(ctx.parents))
|
||
per_child_cap = settings.rules.max_savable_days_at_age_4
|
||
|
||
projected_left_by_parent: dict[UUID, int] = {}
|
||
excess_by_parent: dict[UUID, int] = {}
|
||
for parent in ctx.parents:
|
||
leave = ctx.leave_by_parent.get(parent.uuid)
|
||
if leave is None:
|
||
continue
|
||
planned_fp_before_b4 = sum(
|
||
1
|
||
for d in ctx.planned_days
|
||
if d.parent_personal_data_uuid == parent.uuid
|
||
and d.day_type in ("sjukpenning", "lagsta")
|
||
and d.date < fourth_bday
|
||
)
|
||
projected_left, expiring = days_left_at_age_4_projection(
|
||
leave.days_used, planned_fp_before_b4, leave.total_days, per_parent_cap
|
||
)
|
||
projected_left_by_parent[parent.uuid] = projected_left
|
||
excess_by_parent[parent.uuid] = expiring
|
||
|
||
if not projected_left_by_parent:
|
||
return None
|
||
|
||
family_loss = age4_pooling_loss(
|
||
list(projected_left_by_parent.values()), per_parent_cap, per_child_cap
|
||
)
|
||
if family_loss <= 0:
|
||
return None
|
||
|
||
surplus_uuid = max(excess_by_parent, key=lambda u: excess_by_parent[u])
|
||
surplus_parent = next(p for p in ctx.parents if p.uuid == surplus_uuid)
|
||
surplus_leave = ctx.leave_by_parent[surplus_uuid]
|
||
excess_days = excess_by_parent[surplus_uuid]
|
||
|
||
other_parents = [p for p in ctx.parents if p.uuid != surplus_uuid]
|
||
partner_has_snapshot = False
|
||
lagging_parent: PersonalData | None = None
|
||
lagging_headroom = 0
|
||
for other in other_parents:
|
||
other_leave = ctx.leave_by_parent.get(other.uuid)
|
||
if other_leave is None:
|
||
continue
|
||
partner_has_snapshot = True
|
||
headroom = max(per_parent_cap - projected_left_by_parent[other.uuid], 0)
|
||
if headroom > lagging_headroom:
|
||
lagging_headroom = headroom
|
||
lagging_parent = other
|
||
|
||
if lagging_parent is not None and lagging_headroom > 0:
|
||
transfer_days = min(excess_days, lagging_headroom, surplus_leave.transferable_days_left)
|
||
transfer_days = max(transfer_days, 0)
|
||
return Tip(
|
||
id="age4_pooling_loss",
|
||
severity="warning",
|
||
message_key="tips.age4_pooling_loss_exact",
|
||
data={
|
||
"surplus_parent": surplus_parent.name,
|
||
"lagging_parent": lagging_parent.name,
|
||
"excess_days": excess_days,
|
||
"transfer_days": transfer_days,
|
||
"family_loss_days": family_loss,
|
||
"parent_cap": per_parent_cap,
|
||
"fourth_birthday": fourth_bday.isoformat(),
|
||
},
|
||
)
|
||
|
||
if not partner_has_snapshot and other_parents:
|
||
return Tip(
|
||
id="age4_pooling_loss",
|
||
severity="warning",
|
||
message_key="tips.age4_pooling_loss_hedged",
|
||
data={
|
||
"surplus_parent": surplus_parent.name,
|
||
"excess_days": excess_days,
|
||
"family_loss_days": family_loss,
|
||
"parent_cap": per_parent_cap,
|
||
"fourth_birthday": fourth_bday.isoformat(),
|
||
},
|
||
)
|
||
|
||
return None
|
||
|
||
|
||
async def _rule_use_dubbeldagar_strategically(ctx: TipsContext) -> Tip | None:
|
||
if len(ctx.parents) < 2 or not ctx.children:
|
||
return None
|
||
child = ctx.children[0]
|
||
window_end = child.birth_date + _relativedelta(months=settings.rules.dubbeldagar_months_limit)
|
||
|
||
# Map date → set of parent UUIDs with FP planned that day (within dubbeldagar window)
|
||
fp_by_date: dict[date, set[UUID]] = defaultdict(set)
|
||
for d in ctx.planned_days:
|
||
if d.day_type in ("sjukpenning", "lagsta") and d.date <= window_end:
|
||
fp_by_date[d.date].add(d.parent_personal_data_uuid)
|
||
|
||
for day_date, parent_uuids in fp_by_date.items():
|
||
if len(parent_uuids) < 2:
|
||
continue
|
||
already_marked = any(
|
||
d.is_dubbeldag
|
||
for d in ctx.planned_days
|
||
if d.date == day_date and d.parent_personal_data_uuid in parent_uuids
|
||
)
|
||
if not already_marked:
|
||
return Tip(
|
||
id="use_dubbeldagar_strategically",
|
||
severity="action",
|
||
message_key="tips.use_dubbeldagar_strategically",
|
||
data={"date": day_date.isoformat()},
|
||
anchor_date=day_date,
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_lagsta_niva_coverage(ctx: TipsContext) -> Tip | None:
|
||
for parent in ctx.parents:
|
||
leave = ctx.leave_by_parent.get(parent.uuid)
|
||
if leave is None:
|
||
continue
|
||
tier = leave.tier_data
|
||
if tier.sjukpenning_left < 30 and tier.lagsta_niva_left > 0:
|
||
return Tip(
|
||
id="lagsta_niva_coverage",
|
||
severity="info",
|
||
message_key="tips.lagsta_niva_coverage",
|
||
data={
|
||
"parent_name": parent.name,
|
||
"sjukpenning_left": tier.sjukpenning_left,
|
||
"lagsta_left": tier.lagsta_niva_left,
|
||
},
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_stretch_time_at_home(ctx: TipsContext) -> Tip | None:
|
||
if not ctx.children:
|
||
return None
|
||
child = ctx.children[0]
|
||
fourth_bday = child.birth_date + _relativedelta(years=4)
|
||
today = ctx.today
|
||
window_end = today + timedelta(weeks=4)
|
||
savable_cap = resolve_age4_savable_cap(len(ctx.parents))
|
||
|
||
for parent in ctx.parents:
|
||
parent_window_days = [
|
||
d
|
||
for d in ctx.planned_days
|
||
if d.parent_personal_data_uuid == parent.uuid and today <= d.date <= window_end
|
||
]
|
||
intensity = weekly_intensity(parent_window_days, 4.0)
|
||
if intensity < 7:
|
||
continue
|
||
leave = ctx.leave_by_parent.get(parent.uuid)
|
||
if leave is None:
|
||
continue
|
||
planned_fp_before_b4 = sum(
|
||
1
|
||
for d in ctx.planned_days
|
||
if d.parent_personal_data_uuid == parent.uuid
|
||
and d.day_type in ("sjukpenning", "lagsta")
|
||
and d.date < fourth_bday
|
||
)
|
||
projected_left, _ = days_left_at_age_4_projection(
|
||
leave.days_used, planned_fp_before_b4, leave.total_days, savable_cap
|
||
)
|
||
if projected_left < 60:
|
||
return Tip(
|
||
id="stretch_time_at_home",
|
||
severity="info",
|
||
message_key="tips.stretch_time_at_home",
|
||
data={
|
||
"parent_name": parent.name,
|
||
"weekly_intensity": round(intensity, 1),
|
||
"projected_left": projected_left,
|
||
},
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_sgi_minimum_after_age_1(ctx: TipsContext) -> Tip | None:
|
||
today = ctx.today
|
||
for child in ctx.children:
|
||
if not is_child_over_age(child.birth_date, 1):
|
||
continue
|
||
period_end = today + timedelta(weeks=4)
|
||
for parent in ctx.parents:
|
||
if sgi_at_risk(parent, ctx.planned_days, child.birth_date, today, period_end):
|
||
return Tip(
|
||
id="sgi_minimum_after_age_1",
|
||
severity="warning",
|
||
message_key="tips.sgi_minimum_after_age_1",
|
||
data={
|
||
"parent_name": parent.name,
|
||
"min_days_per_week": settings.rules.sgi_min_days_per_week_after_age_1,
|
||
},
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_wrap_weekend_with_vacation(ctx: TipsContext) -> Tip | None:
|
||
today = ctx.today
|
||
look_ahead = today + timedelta(weeks=8)
|
||
for parent in ctx.parents:
|
||
if parent.salary_type != "monthly":
|
||
continue
|
||
fp_dates = {
|
||
d.date
|
||
for d in ctx.planned_days
|
||
if d.parent_personal_data_uuid == parent.uuid
|
||
and d.day_type in ("sjukpenning", "lagsta")
|
||
and today <= d.date <= look_ahead
|
||
}
|
||
for fp_date in sorted(fp_dates):
|
||
if fp_date.weekday() == 4: # Friday
|
||
monday = fp_date + timedelta(days=3)
|
||
if monday in fp_dates:
|
||
return Tip(
|
||
id="wrap_weekend_with_vacation",
|
||
severity="info",
|
||
message_key="tips.wrap_weekend_with_vacation",
|
||
data={
|
||
"parent_name": parent.name,
|
||
"friday": fp_date.isoformat(),
|
||
"monday": monday.isoformat(),
|
||
},
|
||
anchor_range=(fp_date, monday),
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_wrap_red_days_with_vacation(ctx: TipsContext) -> Tip | None:
|
||
today = ctx.today
|
||
look_ahead = today + timedelta(weeks=12)
|
||
clusters = red_day_clusters_in_range(today, look_ahead)
|
||
if not clusters:
|
||
return None
|
||
for parent in ctx.parents:
|
||
if parent.salary_type != "monthly":
|
||
continue
|
||
fp_dates = {
|
||
d.date
|
||
for d in ctx.planned_days
|
||
if d.parent_personal_data_uuid == parent.uuid
|
||
and d.day_type in ("sjukpenning", "lagsta")
|
||
and today <= d.date <= look_ahead
|
||
}
|
||
for cluster_start, cluster_end in clusters:
|
||
day_before = cluster_start - timedelta(days=1)
|
||
day_after = cluster_end + timedelta(days=1)
|
||
if day_before in fp_dates or day_after in fp_dates:
|
||
return Tip(
|
||
id="wrap_red_days_with_vacation",
|
||
severity="info",
|
||
message_key="tips.wrap_red_days_with_vacation",
|
||
data={
|
||
"parent_name": parent.name,
|
||
"cluster_start": cluster_start.isoformat(),
|
||
"cluster_end": cluster_end.isoformat(),
|
||
},
|
||
anchor_range=(cluster_start, cluster_end),
|
||
)
|
||
return None
|
||
|
||
|
||
def _concrete_windows_near_today(wish: LeaveWish, today: date) -> list[tuple[date, date]]:
|
||
"""This wish's window, if it is anchored near `today` — else nothing.
|
||
|
||
One wish row is one year (see `app.entities.leave_wish`), so there is
|
||
nothing to concretize any more; the tips engine just ignores occurrences
|
||
far from today. The neighbourhood is last year / this year / next year —
|
||
"last year" is what catches a window that started last December and wraps
|
||
into January. Reasoning over the whole horizon is the allocator's job
|
||
(PLANNING_ENGINE_SPEC.md §3.2), not the tips engine's.
|
||
"""
|
||
if wish.first_year not in (today.year - 1, today.year, today.year + 1):
|
||
return []
|
||
return [wish.window()]
|
||
|
||
|
||
async def _rule_long_break_parent_swap(ctx: TipsContext) -> Tip | None:
|
||
if len(ctx.parents) < 2 or not ctx.leave_wishes:
|
||
return None
|
||
today = ctx.today
|
||
for wish in ctx.leave_wishes:
|
||
for start_date, end_date in _concrete_windows_near_today(wish, today):
|
||
if end_date < today:
|
||
continue
|
||
working_days = sum(
|
||
1
|
||
for i in range((end_date - start_date).days + 1)
|
||
if (start_date + timedelta(days=i)).weekday() < 5
|
||
)
|
||
if working_days == 0:
|
||
continue
|
||
for parent in ctx.parents:
|
||
covered = sum(
|
||
1
|
||
for d in ctx.planned_days
|
||
if d.parent_personal_data_uuid == parent.uuid
|
||
and start_date <= d.date <= end_date
|
||
)
|
||
if covered < working_days * 0.5:
|
||
other = next(p for p in ctx.parents if p.uuid != parent.uuid)
|
||
return Tip(
|
||
id="long_break_parent_swap",
|
||
severity="info",
|
||
message_key="tips.long_break_parent_swap",
|
||
data={
|
||
"break_name": wish.name,
|
||
"start_date": start_date.isoformat(),
|
||
"end_date": end_date.isoformat(),
|
||
"parent_name": parent.name,
|
||
"other_parent_name": other.name,
|
||
},
|
||
anchor_range=(start_date, end_date),
|
||
)
|
||
return None
|
||
|
||
|
||
async def _rule_reserve_for_preschool_planning_days(ctx: TipsContext) -> Tip | None:
|
||
if not ctx.children:
|
||
return None
|
||
child = ctx.children[0]
|
||
buffer_needed = preschool_buffer_needed(child, settings.rules.preschool_planning_days_per_year)
|
||
if buffer_needed == 0:
|
||
return None
|
||
for parent in ctx.parents:
|
||
leave = ctx.leave_by_parent.get(parent.uuid)
|
||
if leave is None:
|
||
continue
|
||
if leave.days_left < buffer_needed * 2:
|
||
return Tip(
|
||
id="reserve_for_preschool_planning_days",
|
||
severity="info",
|
||
message_key="tips.reserve_for_preschool_planning_days",
|
||
data={
|
||
"parent_name": parent.name,
|
||
"buffer_days": buffer_needed,
|
||
"days_left": leave.days_left,
|
||
},
|
||
)
|
||
return None
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# Registry — order matters (earlier rules shown first)
|
||
# ---------------------------------------------------------------------------
|
||
|
||
RULE_REGISTRY: list[RuleFn] = [
|
||
_rule_use_vacation_before_expiry,
|
||
_rule_balance_between_parents,
|
||
_rule_preserve_for_age_4,
|
||
_rule_age4_pooling_loss,
|
||
_rule_use_dubbeldagar_strategically,
|
||
_rule_lagsta_niva_coverage,
|
||
_rule_stretch_time_at_home,
|
||
_rule_sgi_minimum_after_age_1,
|
||
_rule_wrap_weekend_with_vacation,
|
||
_rule_wrap_red_days_with_vacation,
|
||
_rule_long_break_parent_swap,
|
||
_rule_reserve_for_preschool_planning_days,
|
||
]
|
||
|
||
# Parental-leave entitlement (`parental_leave_fetch`), and every planned day
|
||
# that draws on it, is tracked per CHILD (see `ParentalLeaveRepository.
|
||
# get_latest_by_parent` / `PlannedLeaveRepository.list_by_workspace_child`).
|
||
# `TipsService.get_tips` therefore runs most rules once per child, against a
|
||
# context scoped to that child's own leave/planned-day data (see
|
||
# `_build_context`). `use_vacation_before_expiry` is the one rule that reads
|
||
# neither — vacation days belong to the parent, not any child — so running it
|
||
# per child would just print the same warning N times for an N-child
|
||
# workspace; it runs once instead, against a childless workspace-level
|
||
# context.
|
||
_WORKSPACE_SCOPED_RULES: frozenset[RuleFn] = frozenset({_rule_use_vacation_before_expiry})
|
||
|
||
|
||
class TipsService:
|
||
def __init__(
|
||
self,
|
||
leave_repo: ParentalLeaveRepository,
|
||
planned_repo: PlannedLeaveRepository,
|
||
child_repo: ChildRepository,
|
||
pd_repo: PersonalDataRepository,
|
||
vacation_repo: VacationDaysRepository,
|
||
leave_wish_repo: LeaveWishRepository,
|
||
dismissal_repo: TipDismissalRepository,
|
||
) -> None:
|
||
self._leave = leave_repo
|
||
self._planned = planned_repo
|
||
self._children = child_repo
|
||
self._parents = pd_repo
|
||
self._vacation = vacation_repo
|
||
self._leave_wishes = leave_wish_repo
|
||
self._dismissals = dismissal_repo
|
||
|
||
async def get_tips(self, workspace_id: UUID) -> list[Tip]:
|
||
"""Load workspace context(s), run all rules, drop stale-dismissed tips.
|
||
|
||
One workspace-level context feeds `_WORKSPACE_SCOPED_RULES`; one
|
||
per-child context feeds every other rule (see `_build_context` and
|
||
`_WORKSPACE_SCOPED_RULES` for why). A child-scoped tip's `id` is
|
||
suffixed with its child's id so that e.g. `preserve_for_age_4` firing
|
||
for two different children never collides — neither in the returned
|
||
list nor in `TipDismissal` (dismissing child A's warning must not
|
||
dismiss child B's).
|
||
"""
|
||
workspace_ctx, child_contexts = await self._build_context(workspace_id)
|
||
tips: list[Tip] = []
|
||
|
||
workspace_rules = [rule for rule in RULE_REGISTRY if rule in _WORKSPACE_SCOPED_RULES]
|
||
child_rules = [rule for rule in RULE_REGISTRY if rule not in _WORKSPACE_SCOPED_RULES]
|
||
|
||
workspace_results = await asyncio.gather(*(rule(workspace_ctx) for rule in workspace_rules))
|
||
tips.extend(tip for tip in workspace_results if tip is not None)
|
||
|
||
for ctx in child_contexts:
|
||
child = ctx.children[0]
|
||
results = await asyncio.gather(*(rule(ctx) for rule in child_rules))
|
||
for tip in results:
|
||
if tip is None:
|
||
continue
|
||
tip.data = {**tip.data, "child_id": str(child.id), "child_name": child.name}
|
||
tip.id = f"{tip.id}:{child.id}"
|
||
tips.append(tip)
|
||
|
||
return await self._drop_stale_dismissed(workspace_id, tips)
|
||
|
||
async def dismiss(self, workspace_id: UUID, tip_id: str) -> None:
|
||
"""Record that `tip_id` is dismissed, fingerprinted to its current `data`.
|
||
|
||
Recomputes the live tip list (rather than trusting a client-supplied
|
||
`data` payload) so the stored fingerprint is always the engine's own
|
||
truth. Raises NotFoundError if `tip_id` doesn't match any
|
||
currently-firing tip — there is nothing meaningful to dismiss.
|
||
"""
|
||
tips = await self.get_tips(workspace_id)
|
||
tip = next((t for t in tips if t.id == tip_id), None)
|
||
if tip is None:
|
||
raise NotFoundError(f"Tip {tip_id!r} is not currently active for this workspace")
|
||
|
||
data_hash = hash_tip_data(tip.data)
|
||
existing = await self._dismissals.get_by_workspace_tip(workspace_id, tip_id)
|
||
if existing is not None:
|
||
existing.data_hash = data_hash
|
||
await self._dismissals.update(existing.id, existing)
|
||
return
|
||
|
||
await self._dismissals.create(
|
||
TipDismissal(
|
||
id=uuid4(),
|
||
workspace_id=workspace_id,
|
||
tip_id=tip_id,
|
||
data_hash=data_hash,
|
||
)
|
||
)
|
||
|
||
async def _drop_stale_dismissed(self, workspace_id: UUID, tips: list[Tip]) -> list[Tip]:
|
||
"""Filter out tips whose dismissal is still fresh.
|
||
|
||
A dismissal only silences the *exact* situation the user acknowledged
|
||
(same tip id, same `data`). If the rule now fires with different data
|
||
— a bigger `expiring_days` count, a moved `fourth_birthday`, ... — the
|
||
old dismissal describes a fact that's no longer true, so the tip
|
||
resurfaces instead of staying silenced forever. See module docstring
|
||
on `app.entities.tip_dismissal.TipDismissal` for why an unconditional
|
||
(non-expiring) dismissal would be dangerous for warnings like
|
||
`preserve_for_age_4`.
|
||
"""
|
||
dismissals = await self._dismissals.list_by_workspace(workspace_id)
|
||
if not dismissals:
|
||
return tips
|
||
dismissed_hash_by_id = {d.tip_id: d.data_hash for d in dismissals}
|
||
return [tip for tip in tips if dismissed_hash_by_id.get(tip.id) != hash_tip_data(tip.data)]
|
||
|
||
async def _build_context(self, workspace_id: UUID) -> tuple[TipsContext, list[TipsContext]]:
|
||
"""Build the workspace-level context plus one context per child.
|
||
|
||
Two bugs used to live here:
|
||
|
||
1. **Single-child only.** Only `children[0]` was ever fetched, so a
|
||
workspace with two children got advice about one and silence about
|
||
the other — despite `list_by_workspace` already returning every
|
||
child. Now every child gets its own context (see the loop below).
|
||
2. **Doubled planned days.** `list_by_workspace_child` already
|
||
returns every parent's days for a given child; the old code called
|
||
it again *inside* the per-parent loop and kept appending to the
|
||
same list, so an N-parent workspace saw each planned day N times.
|
||
Every count-sensitive rule (intensity, SGI, age-4 projections) was
|
||
silently working from doubled input. Fetched once per child now,
|
||
outside any per-parent loop.
|
||
"""
|
||
parents = await self._parents.list_by_workspace(workspace_id)
|
||
children = await self._children.list_by_workspace(workspace_id)
|
||
leave_wishes = await self._leave_wishes.get_by_workspace(workspace_id)
|
||
today = date.today()
|
||
|
||
# Vacation days belong to the parent, not any child — fetched once,
|
||
# shared by the workspace context and every per-child context.
|
||
vacation_by_parent: dict[UUID, list[VacationDays]] = {}
|
||
for pd in parents:
|
||
vacation_by_parent[pd.uuid] = await self._vacation.list(
|
||
personal_data_uuid=pd.uuid, workspace_id=workspace_id
|
||
)
|
||
|
||
workspace_ctx = TipsContext(
|
||
workspace_id=workspace_id,
|
||
children=[],
|
||
parents=parents,
|
||
leave_by_parent={},
|
||
planned_days=[],
|
||
vacation_by_parent=vacation_by_parent,
|
||
leave_wishes=leave_wishes,
|
||
today=today,
|
||
)
|
||
|
||
child_contexts: list[TipsContext] = []
|
||
for child in children:
|
||
leave_by_parent: dict[UUID, ParentalLeaveFetch | None] = {}
|
||
for pd in parents:
|
||
leave_by_parent[pd.uuid] = await self._leave.get_latest_by_parent(pd.uuid, child.id)
|
||
planned_days = await self._planned.list_by_workspace_child(
|
||
workspace_id, child.id, from_date=today
|
||
)
|
||
child_contexts.append(
|
||
TipsContext(
|
||
workspace_id=workspace_id,
|
||
children=[child],
|
||
parents=parents,
|
||
leave_by_parent=leave_by_parent,
|
||
planned_days=planned_days,
|
||
vacation_by_parent=vacation_by_parent,
|
||
leave_wishes=leave_wishes,
|
||
today=today,
|
||
)
|
||
)
|
||
|
||
return workspace_ctx, child_contexts
|