Skip to content
55 changes: 51 additions & 4 deletions backend/src/domus/application/fixed_batch_review.py
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
"""Prepare and atomically replace eligible future fixed obligations."""

from dataclasses import dataclass, replace
from dataclasses import asdict, dataclass, replace
from datetime import timedelta
from functools import partial

Expand All @@ -21,6 +21,7 @@
StorageFailure,
)
from domus.domain.identity import MemberStatus, validate_revision
from domus.domain.inventory import InventoryEffect
from domus.domain.recurrence_planning import FixedBatch, FixedCursor, cursor_binding
from domus.domain.recurrence_records import (
FixedExceptionKind,
Expand Down Expand Up @@ -104,6 +105,7 @@ class ReplacementSource:
definition: TaskDefinition
replaceable: tuple[AffectedWork, ...]
retained: tuple[AffectedWork, ...]
effects: tuple[InventoryEffect, ...]

def prepare(self, planner: FixedRecurrencePlanner, now: int) -> PreparedReplacement:
rule = self.upcoming
Expand Down Expand Up @@ -319,7 +321,10 @@ def replacement_source(
revision=rule.revision + 1,
pattern_revision=rule.pattern_revision + 1,
)
return ReplacementSource(rule, upcoming, progress, definition, tuple(replaced), tuple(retained))
effects = unit.inventory.effects(home, tuple(item.work.occurrence_id for item in replaced))
return ReplacementSource(
rule, upcoming, progress, definition, tuple(replaced), tuple(retained), effects
)


@dataclass(frozen=True, slots=True)
Expand All @@ -345,6 +350,20 @@ def document(self) -> JsonDocument:
"before": self.before.local.isoformat(),
"retained_work": [item.value() for item in rule.retained],
"cancelled_work": [item.value() for item in rule.replaceable],
**(
{
"inventory_effects": [
{
**asdict(effect),
"kind": effect.kind.value,
"remaining": str(effect.remaining),
}
for effect in rule.effects
]
}
if rule.effects
else {}
),
"prospective_slots": [
{
"planned": planned.value(),
Expand Down Expand Up @@ -389,7 +408,7 @@ def commit(
),
progress.revision,
)
replacements: JsonObject = {}
replacements: dict[str, str] = {}
additions: list[JsonValue] = []
originals = iter(self.pairing)
for batch in self.steps:
Expand Down Expand Up @@ -427,12 +446,40 @@ def commit(
transition.document(),
partial(transition_occurrence, household_id=home, request=transition),
)
moved, retained = self._transfer_effects(unit, replacements)
return {
"kind": "fixed_replacement",
"schedule_id": rule.schedule_id,
"schedule_revision": rule.revision,
"pattern_revision": rule.pattern_revision,
"replacements": replacements,
"replacements": dict[str, JsonValue](replacements),
"cancelled": [item.work.occurrence_id for item in self.source.replaceable],
"added": additions,
**(
{"inventory_transferred": moved, "inventory_retained": retained}
if moved or retained
else {}
),
}

def _transfer_effects(
self, unit: UnitOfWork, replacements: dict[str, str]
) -> tuple[list[JsonValue], list[JsonValue]]:
# New occurrences are materialized from this exact reviewed definition.
materials = {
(line.line_id, line.binding.reference_id) for line in self.source.definition.materials
}
moved: list[JsonValue] = []
retained: list[JsonValue] = []
for effect in self.source.effects:
assert effect.occurrence_id is not None
replacement = replacements.get(effect.occurrence_id)
if replacement is None or (effect.line_id, effect.reference_id) not in materials:
retained.append(effect.effect_id)
continue
unit.inventory.update_effect(
replace(effect, occurrence_id=replacement, revision=effect.revision + 1),
effect.revision,
)
moved.append({"id": effect.effect_id, "from": effect.occurrence_id, "to": replacement})
return moved, retained
247 changes: 247 additions & 0 deletions backend/src/domus/application/inventory.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,247 @@
"""Own physical movements and task-linked commitments in the caller's transaction."""

from collections.abc import Callable
from dataclasses import asdict, dataclass, replace
from typing import cast

from domus.application.authorization import HouseholdAccess, MembershipAuthorization
from domus.application.commands import AtomicCommands, Change
from domus.application.identity_ports import CurrentHuman
from domus.application.inventory_ports import InventoryRecords
from domus.application.ports import Clock, Identifiers, Transactions, UnitOfWork
from domus.application.task_material_ports import InventoryMaterialResult, MaterialPostingRequest
from domus.domain.errors import Conflict, InvalidInput, StorageFailure
from domus.domain.identity import Permission
from domus.domain.inventory import (
MAX_STOCK_UNITS,
EffectKind,
InventoryEffect,
StockMovement,
stock_units,
)
from domus.domain.storage import CommandKey, JsonDocument, Receipt
from domus.domain.task_material_values import (
MaterialBinding,
MaterialPendingReason,
MaterialQuantity,
)
from domus.domain.task_materials import MaterialPosting


@dataclass(frozen=True, slots=True)
class InventorySettlement:
records: InventoryRecords
clock: Clock
identifiers: Identifiers

def resolve(
self, household_id: str, actor_member_id: str, reference_id: str
) -> MaterialBinding | None:
# TaskMaterialAccess has already proved actor and household inside this unit.
return self.records.material(household_id, reference_id)

def settle(self, request: MaterialPostingRequest) -> InventoryMaterialResult:
intent = request.intent
home, reference = intent.household_id, intent.line.binding.reference_id
previous = self.records.movement(home, request.source_key)
if previous is not None:
return InventoryMaterialResult(posting=previous.posting)
if self.records.material(home, reference) != intent.line.binding:
return InventoryMaterialResult(pending_reason=MaterialPendingReason.BINDING_CHANGED)
quantity = cast(MaterialQuantity, intent.quantity)
used = stock_units(quantity)
corrects = None
if intent.posting is not None:
corrects = intent.posting.movement_id
original = self.records.movement_by_id(home, corrects)
if original is None or original.posting != intent.posting:
raise StorageFailure("invalid_inventory_posting_source")
used -= stock_units(intent.posting.quantity)
reservation = next(
(
item
for item in self.records.effects(home, (intent.occurrence_id,))
if item.kind is EffectKind.RESERVATION
and item.reference_id == reference
and item.line_id == intent.line.line_id
),
None,
)
balance = self.records.balance(home, reference)
available = balance - self.records.reserved(home, reference)
usable = available + (0 if reservation is None else reservation.remaining)
if used > usable or balance - used > MAX_STOCK_UNITS:
return InventoryMaterialResult(pending_reason=MaterialPendingReason.STOCK_SHORTAGE)
if reservation is not None and used > 0:
self.records.update_effect(
replace(
reservation,
remaining=max(0, reservation.remaining - used),
revision=reservation.revision + 1,
),
reservation.revision,
)
posted = MaterialPosting(
intent.intent_id,
home,
intent.occurrence_id,
intent.cycle_id,
intent.line.line_id,
reference,
intent.line.binding.revision,
intent.revision,
intent.effect_revision,
quantity,
self.identifiers.new(),
self.identifiers.new(),
self.clock.now(),
)
self.records.append(
StockMovement(
home,
reference,
posted.movement_id,
request.source_key,
request.actor_member_id,
-used,
posted.posted_at,
intent.reason,
posted,
corrects,
),
balance - used,
)
return InventoryMaterialResult(posting=posted)


@dataclass(frozen=True, slots=True)
class InventoryCommands:
"""Internal Inventory manager operations used by the task integration."""

transactions: Transactions
actor: CurrentHuman
clock: Clock
identifiers: Identifiers
household_id: str = "home"

def _execute(
self,
action: str,
key: str,
payload: JsonDocument,
apply: Callable[[UnitOfWork, str, CommandKey], JsonDocument],
) -> Receipt:
human = self.actor.current()
command = CommandKey(self.household_id, human.ha_user_id, action, key)
access = HouseholdAccess(human)
authority = MembershipAuthorization(access, action, Permission.INVENTORY_MANAGE)

def change(unit: UnitOfWork) -> Change:
member = access.require(unit, self.household_id, Permission.INVENTORY_MANAGE)
result = apply(unit, member.member_id, command)
return Change(result, payload, JsonDocument.from_value({"version": 1, "kind": action}))

return AtomicCommands(self.transactions, authority, self.clock, self.identifiers).execute(
command, payload, change
)

def receive(self, key: str, binding: MaterialBinding, quantity: MaterialQuantity) -> Receipt:
binding.require_quantity(quantity)
if binding.household_id != self.household_id or binding.revision != 1 or quantity.is_zero:
raise InvalidInput("invalid_inventory_receipt")
payload = JsonDocument.from_value({"binding": asdict(binding), "quantity": quantity.value})

def apply(unit: UnitOfWork, member: str, command: CommandKey) -> JsonDocument:
stock = unit.inventory
home, reference = binding.household_id, binding.reference_id
current = stock.material(home, reference)
if current is None:
stock.add_material(binding)
elif current != binding:
raise Conflict("inventory_binding_changed")
received = stock_units(quantity)
balance = stock.balance(home, reference) + received
if balance > MAX_STOCK_UNITS:
raise Conflict("inventory_stock_capacity")
movement = StockMovement(
home,
reference,
self.identifiers.new(),
JsonDocument.from_value(asdict(command)).fingerprint,
member,
received,
self.clock.now(),
"receipt",
)
stock.append(movement, balance)
return JsonDocument.from_value({"movement_id": movement.movement_id})

return self._execute("inventory.receive", key, payload, apply)

def commit_effect(
self,
key: str,
kind: EffectKind,
reference_id: str,
quantity: MaterialQuantity,
*,
occurrence_id: str | None = None,
) -> Receipt:
if (
not isinstance(kind, EffectKind)
or quantity.is_zero
or (occurrence_id is None and kind is EffectKind.RESERVATION)
):
raise InvalidInput("invalid_inventory_effect")
payload = JsonDocument.from_value(
{
"kind": kind.value,
"reference_id": reference_id,
"quantity": quantity.value,
"occurrence_id": occurrence_id,
}
)

def apply(unit: UnitOfWork, member: str, command: CommandKey) -> JsonDocument:
home, stock = self.household_id, unit.inventory
binding = stock.material(home, reference_id)
if binding is None:
raise InvalidInput("invalid_material_reference")
binding.require_quantity(quantity)
line_id = None
if occurrence_id is not None:
work = unit.tasks.occurrence(home, occurrence_id)
line = (
None
if work is None
else next(
(
item
for item in work.definition_snapshot.materials
if item.binding == binding
),
None,
)
)
if line is None:
raise InvalidInput("invalid_material_reference")
line_id = line.line_id
amount = stock_units(quantity)
if kind is EffectKind.RESERVATION and amount > stock.balance(
home, reference_id
) - stock.reserved(home, reference_id):
raise Conflict("inventory_insufficient_stock")
value = InventoryEffect(
home,
self.identifiers.new(),
kind,
reference_id,
occurrence_id,
occurrence_id,
line_id,
amount,
)
stock.add_effect(value)
return JsonDocument.from_value({"effect_id": value.effect_id})

return self._execute("inventory.commit-effect", key, payload, apply)
20 changes: 20 additions & 0 deletions backend/src/domus/application/inventory_ports.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,20 @@
"""Inventory records belong to the current unit of work."""

from typing import Protocol

from domus.domain.inventory import InventoryEffect, StockMovement
from domus.domain.task_material_values import MaterialBinding


class InventoryRecords(Protocol):
def material(self, home: str, reference: str) -> MaterialBinding | None: ...
def add_material(self, binding: MaterialBinding) -> None: ...
def balance(self, home: str, reference: str) -> int: ...
def reserved(self, home: str, reference: str) -> int: ...
def effect(self, home: str, effect_id: str) -> InventoryEffect | None: ...
def effects(self, home: str, occurrences: tuple[str, ...]) -> tuple[InventoryEffect, ...]: ...
def add_effect(self, value: InventoryEffect) -> None: ...
def update_effect(self, value: InventoryEffect, previous_revision: int) -> None: ...
def movement(self, home: str, source_key: str) -> StockMovement | None: ...
def movement_by_id(self, home: str, movement_id: str) -> StockMovement | None: ...
def append(self, value: StockMovement, balance: int) -> None: ...
4 changes: 4 additions & 0 deletions backend/src/domus/application/ports.py
Original file line number Diff line number Diff line change
Expand Up @@ -3,6 +3,7 @@
from contextlib import AbstractContextManager
from typing import Protocol

from domus.application.inventory_ports import InventoryRecords
from domus.application.member_profile_ports import MemberPreferencesRepository, MemberPresentations
from domus.application.points_ports import PointsRepository
from domus.application.recurrence_ports import RecurrenceRepository
Expand Down Expand Up @@ -97,6 +98,9 @@ def save(self, category: TaskCategory, expected_revision: int) -> None: ...


class UnitOfWork(Protocol):
@property
def inventory(self) -> InventoryRecords: ...

@property
def points(self) -> PointsRepository: ...

Expand Down
Loading
Loading