662 lines
31 KiB
Python
662 lines
31 KiB
Python
from datetime import UTC, datetime
|
|
from decimal import Decimal
|
|
from html import escape
|
|
|
|
from fastapi import HTTPException, status
|
|
from sqlalchemy.exc import IntegrityError
|
|
from sqlalchemy.orm import Session
|
|
from starlette.requests import Request
|
|
|
|
from app.models.repair import Repair
|
|
from app.models.repair_estimate import RepairEstimate, RepairEstimateItem
|
|
from app.models.user import User
|
|
from app.repositories.inventory_repository import InventoryRepository
|
|
from app.repositories.repair_estimate_repository import RepairEstimateRepository
|
|
from app.repositories.repair_repository import RepairRepository
|
|
from app.schemas.repair import RepairStatusUpdate
|
|
from app.schemas.repair_estimate import (
|
|
PublicEstimateDecisionRequest,
|
|
PublicEstimateItemResponse,
|
|
PublicEstimateResponse,
|
|
RepairEstimateCreate,
|
|
RepairEstimateItemPayload,
|
|
RepairEstimateUpdate,
|
|
calculate_item_total,
|
|
calculate_tax,
|
|
)
|
|
from app.services.audit_service import write_audit_log
|
|
from app.services.inventory_service import InventoryService
|
|
from app.services.repair_public_link_service import RepairPublicLinkService
|
|
from app.services.system_settings_service import SystemSettingsService
|
|
|
|
|
|
def _repair_label(repair: Repair) -> str:
|
|
return f"{repair.repair_number} · {repair.customer_name}"
|
|
|
|
|
|
def _estimate_label(estimate: RepairEstimate) -> str:
|
|
return f"{estimate.estimate_number} · {estimate.title}"
|
|
|
|
|
|
def _money(cents: int, currency: str = "EUR") -> str:
|
|
return f"{cents / 100:,.2f} {currency}".replace(",", "X").replace(".", ",").replace("X", ".")
|
|
|
|
|
|
def _audit_estimate_data(estimate: RepairEstimate) -> dict:
|
|
return {
|
|
"id": estimate.id,
|
|
"repair_id": estimate.repair_id,
|
|
"estimate_number": estimate.estimate_number,
|
|
"status": estimate.status,
|
|
"title": estimate.title,
|
|
"currency": estimate.currency,
|
|
"valid_until": estimate.valid_until,
|
|
"sent_at": estimate.sent_at,
|
|
"approved_at": estimate.approved_at,
|
|
"declined_at": estimate.declined_at,
|
|
"created_by_user_id": estimate.created_by_user_id,
|
|
"inventory_item_ids": [item.inventory_item_id for item in estimate.items if item.inventory_item_id is not None],
|
|
}
|
|
|
|
|
|
ESTIMATE_STATUS_LABELS = {
|
|
"draft": "Entwurf",
|
|
"sent": "Wartet auf Freigabe",
|
|
"approved": "Freigegeben",
|
|
"declined": "Abgelehnt",
|
|
"expired": "Abgelaufen",
|
|
"cancelled": "Storniert",
|
|
"revoked": "Kostenvoranschlag wird überarbeitet",
|
|
}
|
|
|
|
|
|
class RepairEstimateService:
|
|
@staticmethod
|
|
def create(db: Session, repair: Repair, payload: RepairEstimateCreate, *, actor: User, request: Request) -> RepairEstimate:
|
|
estimate_number = RepairEstimateRepository.get_next_number(db, datetime.now(UTC).year)
|
|
estimate = RepairEstimate(
|
|
repair_id=repair.id,
|
|
estimate_number=estimate_number,
|
|
status="draft",
|
|
created_by_user_id=actor.id,
|
|
)
|
|
price_overrides = RepairEstimateService._collect_price_overrides(db, payload.items)
|
|
RepairEstimateService._apply_payload(db, estimate, payload)
|
|
try:
|
|
db.add(estimate)
|
|
db.flush()
|
|
RepairEstimateRepository.add_event(db, estimate_id=estimate.id, event_type="created", actor_type="user", actor_user_id=actor.id, commit=False)
|
|
db.commit()
|
|
except IntegrityError:
|
|
db.rollback()
|
|
estimate.estimate_number = RepairEstimateRepository.get_next_number(db, datetime.now(UTC).year)
|
|
db.add(estimate)
|
|
db.flush()
|
|
RepairEstimateRepository.add_event(db, estimate_id=estimate.id, event_type="created", actor_type="user", actor_user_id=actor.id, commit=False)
|
|
db.commit()
|
|
db.refresh(estimate)
|
|
estimate = RepairEstimateRepository.get(db, repair_id=repair.id, estimate_id=estimate.id) or estimate
|
|
write_audit_log(
|
|
db,
|
|
action="repair_estimates.create",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=_estimate_label(estimate),
|
|
actor=actor,
|
|
request=request,
|
|
after_data=_audit_estimate_data(estimate),
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
RepairEstimateService._write_price_override_audits(db, estimate, price_overrides, actor=actor, request=request)
|
|
return estimate
|
|
|
|
@staticmethod
|
|
def update(db: Session, repair: Repair, estimate: RepairEstimate, payload: RepairEstimateUpdate, *, actor: User, request: Request) -> RepairEstimate:
|
|
if estimate.status not in {"draft", "sent"}:
|
|
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Dieser Kostenvoranschlag kann nicht mehr bearbeitet werden")
|
|
before_data = _audit_estimate_data(estimate)
|
|
price_overrides = RepairEstimateService._collect_price_overrides(db, payload.items)
|
|
was_sent = estimate.status == "sent"
|
|
if was_sent:
|
|
InventoryService.release_estimate_reservation(db, estimate, actor_user_id=actor.id)
|
|
RepairEstimateService._apply_payload(db, estimate, payload)
|
|
if was_sent:
|
|
InventoryService.reserve_for_estimate(db, estimate, actor_user_id=actor.id)
|
|
write_audit_log(
|
|
db,
|
|
action="inventory.estimate.reserve",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=_estimate_label(estimate),
|
|
actor=actor,
|
|
request=request,
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
RepairEstimateService._write_low_stock_audits(db, estimate, actor=actor, request=request)
|
|
RepairEstimateRepository.add_event(db, estimate_id=estimate.id, event_type="updated", actor_type="user", actor_user_id=actor.id, commit=False)
|
|
db.commit()
|
|
db.refresh(estimate)
|
|
updated = RepairEstimateRepository.get(db, repair_id=repair.id, estimate_id=estimate.id) or estimate
|
|
write_audit_log(
|
|
db,
|
|
action="repair_estimates.update",
|
|
entity_type="repair_estimates",
|
|
entity_id=updated.id,
|
|
entity_label=_estimate_label(updated),
|
|
actor=actor,
|
|
request=request,
|
|
before_data=before_data,
|
|
after_data=_audit_estimate_data(updated),
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
RepairEstimateService._write_price_override_audits(db, updated, price_overrides, actor=actor, request=request)
|
|
return updated
|
|
|
|
@staticmethod
|
|
def delete(db: Session, repair: Repair, estimate: RepairEstimate, *, actor: User, request: Request) -> None:
|
|
if estimate.status not in {"draft", "sent", "cancelled"}:
|
|
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Nur Entwürfe, gesendete oder stornierte Kostenvoranschläge können gelöscht werden")
|
|
before_data = _audit_estimate_data(estimate)
|
|
label = _estimate_label(estimate)
|
|
if estimate.status == "sent":
|
|
InventoryService.release_estimate_reservation(db, estimate, actor_user_id=actor.id)
|
|
write_audit_log(
|
|
db,
|
|
action="inventory.estimate.release",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=label,
|
|
actor=actor,
|
|
request=request,
|
|
metadata={"reason": "estimate_deleted", "repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
RepairEstimateRepository.delete(db, estimate)
|
|
write_audit_log(
|
|
db,
|
|
action="repair_estimates.delete",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=label,
|
|
actor=actor,
|
|
request=request,
|
|
before_data=before_data,
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
|
|
@staticmethod
|
|
def send(db: Session, repair: Repair, estimate: RepairEstimate, *, actor: User, request: Request) -> RepairEstimate:
|
|
if estimate.status not in {"draft", "sent"}:
|
|
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Dieser Kostenvoranschlag kann nicht gesendet werden")
|
|
|
|
if not repair.customer_email:
|
|
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Für diese Reparatur ist keine Kunden-E-Mail hinterlegt")
|
|
|
|
was_sent = estimate.status == "sent"
|
|
if not was_sent:
|
|
InventoryService.reserve_for_estimate(db, estimate, actor_user_id=actor.id)
|
|
|
|
link = RepairPublicLinkService.create_with_audit(
|
|
db,
|
|
repair,
|
|
actor=actor,
|
|
request=request,
|
|
audit_action="repairs.public_link.regenerate",
|
|
)
|
|
public_status_url = link.public_status_path
|
|
estimate = RepairEstimateRepository.mark_sent(db, estimate)
|
|
RepairEstimateRepository.add_event(db, estimate_id=estimate.id, event_type="sent", actor_type="user", actor_user_id=actor.id)
|
|
if not was_sent:
|
|
write_audit_log(
|
|
db,
|
|
action="inventory.estimate.reserve",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=_estimate_label(estimate),
|
|
actor=actor,
|
|
request=request,
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
RepairEstimateService._write_low_stock_audits(db, estimate, actor=actor, request=request)
|
|
smtp_config = SystemSettingsService.get_smtp_runtime_config(db)
|
|
mail_sent = False
|
|
if smtp_config.is_configured:
|
|
try:
|
|
SystemSettingsService.send_email(
|
|
smtp_config,
|
|
recipient=repair.customer_email,
|
|
subject=f"Kostenvoranschlag {estimate.estimate_number} zu Reparatur {repair.repair_number}",
|
|
text=RepairEstimateService._estimate_mail_text(repair, estimate, public_status_url),
|
|
html=RepairEstimateService._estimate_mail_html(repair, estimate, public_status_url),
|
|
)
|
|
mail_sent = True
|
|
except Exception:
|
|
mail_sent = False
|
|
|
|
RepairRepository.create_notification_event(
|
|
db,
|
|
repair_id=repair.id,
|
|
event_type="repair_estimate_mail",
|
|
channel="email",
|
|
recipient=repair.customer_email,
|
|
subject=f"Kostenvoranschlag {estimate.estimate_number} zu Reparatur {repair.repair_number}",
|
|
template="repair_estimate",
|
|
status="sent" if mail_sent else "failed",
|
|
success=mail_sent,
|
|
error_message=None if mail_sent else "Kostenvoranschlag-Mail konnte nicht versendet werden",
|
|
sent_at=datetime.now(UTC) if mail_sent else None,
|
|
)
|
|
RepairRepository.update_status(db, repair, RepairStatusUpdate(status="waiting_for_customer", note="Kostenvoranschlag gesendet"), actor_user_id=actor.id)
|
|
write_audit_log(
|
|
db,
|
|
action="repair_estimates.send",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=_estimate_label(estimate),
|
|
actor=actor,
|
|
request=request,
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number, "mail_sent": mail_sent},
|
|
)
|
|
return RepairEstimateRepository.get(db, repair_id=repair.id, estimate_id=estimate.id) or estimate
|
|
|
|
@staticmethod
|
|
def cancel(db: Session, repair: Repair, estimate: RepairEstimate, *, actor: User, request: Request) -> RepairEstimate:
|
|
if estimate.status in {"approved", "declined", "cancelled", "expired", "revoked"}:
|
|
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Dieser Kostenvoranschlag kann nicht storniert werden")
|
|
was_sent = estimate.status == "sent"
|
|
if was_sent:
|
|
InventoryService.release_estimate_reservation(db, estimate, actor_user_id=actor.id)
|
|
estimate.status = "cancelled"
|
|
RepairEstimateRepository.add_event(db, estimate_id=estimate.id, event_type="cancelled", actor_type="user", actor_user_id=actor.id, commit=False)
|
|
db.commit()
|
|
db.refresh(estimate)
|
|
write_audit_log(
|
|
db,
|
|
action="repair_estimates.cancel",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=_estimate_label(estimate),
|
|
actor=actor,
|
|
request=request,
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
if was_sent:
|
|
write_audit_log(
|
|
db,
|
|
action="inventory.estimate.release",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=_estimate_label(estimate),
|
|
actor=actor,
|
|
request=request,
|
|
metadata={"reason": "estimate_cancelled", "repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
return RepairEstimateRepository.get(db, repair_id=repair.id, estimate_id=estimate.id) or estimate
|
|
|
|
@staticmethod
|
|
def revoke(db: Session, repair: Repair, estimate: RepairEstimate, *, actor: User, request: Request) -> RepairEstimate:
|
|
if estimate.status != "approved":
|
|
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Nur freigegebene Kostenvoranschläge können zurückgenommen werden")
|
|
|
|
before_data = _audit_estimate_data(estimate)
|
|
InventoryService.release_estimate_reservation(db, estimate, actor_user_id=actor.id, reason="estimate_revoked")
|
|
estimate.status = "revoked"
|
|
RepairEstimateRepository.add_event(
|
|
db,
|
|
estimate_id=estimate.id,
|
|
event_type="revoked",
|
|
actor_type="user",
|
|
actor_user_id=actor.id,
|
|
note="Freigabe zurückgenommen",
|
|
commit=False,
|
|
)
|
|
db.commit()
|
|
db.refresh(estimate)
|
|
|
|
if repair.status in {"approved", "repair", "final_test", "ready_for_pickup"}:
|
|
RepairRepository.update_status(
|
|
db,
|
|
repair,
|
|
RepairStatusUpdate(
|
|
status="waiting_for_customer",
|
|
note="Kostenvoranschlag zurückgenommen. Kunde wartet auf korrigierten Kostenvoranschlag.",
|
|
),
|
|
actor_user_id=actor.id,
|
|
)
|
|
|
|
link = RepairPublicLinkService.create_with_audit(
|
|
db,
|
|
repair,
|
|
actor=actor,
|
|
request=request,
|
|
audit_action="repairs.public_link.regenerate",
|
|
)
|
|
subject = "Kostenvoranschlag wurde zurückgenommen"
|
|
smtp_config = SystemSettingsService.get_smtp_runtime_config(db)
|
|
mail_sent = False
|
|
if smtp_config.is_configured and repair.customer_email:
|
|
try:
|
|
SystemSettingsService.send_email(
|
|
smtp_config,
|
|
recipient=repair.customer_email,
|
|
subject=subject,
|
|
text=RepairEstimateService._revoked_mail_text(repair, estimate, link.public_status_path),
|
|
html=RepairEstimateService._revoked_mail_html(repair, estimate, link.public_status_path),
|
|
)
|
|
mail_sent = True
|
|
except Exception:
|
|
mail_sent = False
|
|
|
|
RepairRepository.create_notification_event(
|
|
db,
|
|
repair_id=repair.id,
|
|
event_type="repair_estimate_revoked_mail",
|
|
channel="email",
|
|
recipient=repair.customer_email,
|
|
subject=subject,
|
|
template="repair_estimate_revoked",
|
|
status="sent" if mail_sent else "failed",
|
|
success=mail_sent,
|
|
error_message=None if mail_sent else "Kostenvoranschlag-Rücknahme-Mail konnte nicht versendet werden",
|
|
sent_at=datetime.now(UTC) if mail_sent else None,
|
|
)
|
|
updated = RepairEstimateRepository.get(db, repair_id=repair.id, estimate_id=estimate.id) or estimate
|
|
write_audit_log(
|
|
db,
|
|
action="repair_estimates.revoke",
|
|
entity_type="repair_estimates",
|
|
entity_id=updated.id,
|
|
entity_label=_estimate_label(updated),
|
|
actor=actor,
|
|
request=request,
|
|
before_data=before_data,
|
|
after_data=_audit_estimate_data(updated),
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number, "mail_sent": mail_sent},
|
|
)
|
|
write_audit_log(
|
|
db,
|
|
action="inventory.estimate.release",
|
|
entity_type="repair_estimates",
|
|
entity_id=updated.id,
|
|
entity_label=_estimate_label(updated),
|
|
actor=actor,
|
|
request=request,
|
|
metadata={"reason": "estimate_revoked", "repair_id": repair.id, "repair_number": repair.repair_number},
|
|
)
|
|
return updated
|
|
|
|
@staticmethod
|
|
def public_response(estimate: RepairEstimate | None) -> PublicEstimateResponse | None:
|
|
if estimate is None:
|
|
return None
|
|
return PublicEstimateResponse(
|
|
estimate_number=estimate.estimate_number,
|
|
status=estimate.status,
|
|
status_label=ESTIMATE_STATUS_LABELS.get(estimate.status, estimate.status),
|
|
title=estimate.title,
|
|
customer_message=estimate.customer_message,
|
|
subtotal_cents=estimate.subtotal_cents,
|
|
tax_cents=estimate.tax_cents,
|
|
total_cents=estimate.total_cents,
|
|
currency=estimate.currency,
|
|
valid_until=estimate.valid_until,
|
|
items=[
|
|
PublicEstimateItemResponse(
|
|
item_type=item.item_type,
|
|
inventory_snapshot_name=item.inventory_snapshot_name,
|
|
inventory_snapshot_sku=item.inventory_snapshot_sku,
|
|
inventory_snapshot_manufacturer=item.inventory_snapshot_manufacturer,
|
|
inventory_snapshot_part_number=item.inventory_snapshot_part_number,
|
|
title=item.title,
|
|
description=item.description,
|
|
quantity=item.quantity,
|
|
unit=item.unit,
|
|
unit_price_cents=item.unit_price_cents,
|
|
total_cents=item.total_cents,
|
|
)
|
|
for item in estimate.items
|
|
],
|
|
)
|
|
|
|
@staticmethod
|
|
def customer_decision(
|
|
db: Session,
|
|
repair: Repair,
|
|
estimate: RepairEstimate,
|
|
decision: str,
|
|
payload: PublicEstimateDecisionRequest,
|
|
*,
|
|
request: Request | None,
|
|
) -> RepairEstimate:
|
|
if estimate.status != "sent":
|
|
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Dieser Kostenvoranschlag ist nicht zur Entscheidung offen")
|
|
now = datetime.now(UTC)
|
|
estimate.customer_response_message = payload.message
|
|
if decision == "approve":
|
|
estimate.status = "approved"
|
|
estimate.approved_at = now
|
|
event_type = "approved"
|
|
repair_status = "approved"
|
|
note = "Kunde hat den Kostenvoranschlag freigegeben"
|
|
audit_action = "repair_estimates.approve"
|
|
elif decision == "decline":
|
|
estimate.status = "declined"
|
|
estimate.declined_at = now
|
|
event_type = "declined"
|
|
repair_status = "waiting_for_customer"
|
|
note = "Kunde hat den Kostenvoranschlag abgelehnt"
|
|
audit_action = "repair_estimates.decline"
|
|
InventoryService.release_estimate_reservation(db, estimate, actor_user_id=None)
|
|
else:
|
|
event_type = "question"
|
|
repair_status = "waiting_for_customer"
|
|
note = "Kunde hat eine Rückfrage zum Kostenvoranschlag gestellt"
|
|
audit_action = "repair_estimates.question"
|
|
|
|
RepairEstimateRepository.add_event(db, estimate_id=estimate.id, event_type=event_type, actor_type="customer", note=payload.message, commit=False)
|
|
RepairRepository.update_status(db, repair, RepairStatusUpdate(status=repair_status, note=note), actor_user_id=None)
|
|
db.commit()
|
|
db.refresh(estimate)
|
|
write_audit_log(
|
|
db,
|
|
action=audit_action,
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=_estimate_label(estimate),
|
|
request=request,
|
|
metadata={"repair_id": repair.id, "repair_number": repair.repair_number, "actor": "customer"},
|
|
)
|
|
if decision == "decline":
|
|
write_audit_log(
|
|
db,
|
|
action="inventory.estimate.release",
|
|
entity_type="repair_estimates",
|
|
entity_id=estimate.id,
|
|
entity_label=_estimate_label(estimate),
|
|
request=request,
|
|
metadata={"reason": "estimate_declined", "repair_id": repair.id, "repair_number": repair.repair_number, "actor": "customer"},
|
|
)
|
|
return RepairEstimateRepository.get(db, repair_id=repair.id, estimate_id=estimate.id) or estimate
|
|
|
|
@staticmethod
|
|
def _apply_payload(db: Session, estimate: RepairEstimate, payload: RepairEstimateCreate | RepairEstimateUpdate) -> None:
|
|
estimate.title = payload.title
|
|
estimate.customer_message = payload.customer_message
|
|
estimate.internal_note = payload.internal_note
|
|
estimate.tax_rate_percent = payload.tax_rate_percent
|
|
estimate.currency = payload.currency
|
|
estimate.valid_until = payload.valid_until
|
|
items, subtotal = RepairEstimateService._build_items(db, payload.items)
|
|
tax_cents = calculate_tax(subtotal, payload.tax_rate_percent)
|
|
estimate.subtotal_cents = subtotal
|
|
estimate.tax_cents = tax_cents
|
|
estimate.total_cents = subtotal + tax_cents
|
|
estimate.items = items
|
|
|
|
@staticmethod
|
|
def _build_items(
|
|
db: Session,
|
|
payload_items: list[RepairEstimateItemPayload],
|
|
) -> tuple[list[RepairEstimateItem], int]:
|
|
items: list[RepairEstimateItem] = []
|
|
subtotal = 0
|
|
for index, payload in enumerate(payload_items, start=1):
|
|
item_type = payload.item_type
|
|
title = payload.title
|
|
description = payload.description
|
|
unit = payload.unit
|
|
unit_price_cents = payload.unit_price_cents
|
|
inventory_item_id = payload.inventory_item_id
|
|
inventory_snapshot_name = ""
|
|
inventory_snapshot_sku = ""
|
|
inventory_snapshot_manufacturer = None
|
|
inventory_snapshot_part_number = None
|
|
if inventory_item_id is not None:
|
|
inventory_item = InventoryRepository.get_item(db, inventory_item_id)
|
|
if inventory_item is None or not inventory_item.is_active:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Lagerartikel in Position {index} nicht gefunden")
|
|
item_type = "part"
|
|
title = inventory_item.name
|
|
unit = inventory_item.unit
|
|
inventory_snapshot_name = inventory_item.name
|
|
inventory_snapshot_sku = inventory_item.sku
|
|
inventory_snapshot_manufacturer = inventory_item.manufacturer
|
|
inventory_snapshot_part_number = inventory_item.manufacturer_part_number
|
|
if not payload.inventory_price_overridden:
|
|
unit_price_cents = inventory_item.selling_price_cents or 0
|
|
total = calculate_item_total(payload.quantity, unit_price_cents)
|
|
subtotal += total
|
|
items.append(
|
|
RepairEstimateItem(
|
|
inventory_item_id=inventory_item_id,
|
|
inventory_snapshot_name=inventory_snapshot_name,
|
|
inventory_snapshot_sku=inventory_snapshot_sku,
|
|
inventory_snapshot_manufacturer=inventory_snapshot_manufacturer,
|
|
inventory_snapshot_part_number=inventory_snapshot_part_number,
|
|
position=index,
|
|
item_type=item_type,
|
|
title=title,
|
|
description=description,
|
|
quantity=payload.quantity,
|
|
unit=unit,
|
|
unit_price_cents=unit_price_cents,
|
|
total_cents=total,
|
|
)
|
|
)
|
|
return items, subtotal
|
|
|
|
@staticmethod
|
|
def _collect_price_overrides(db: Session, payload_items: list[RepairEstimateItemPayload]) -> list[dict]:
|
|
overrides: list[dict] = []
|
|
for payload in payload_items:
|
|
if payload.inventory_item_id is None or not payload.inventory_price_overridden:
|
|
continue
|
|
inventory_item = InventoryRepository.get_item(db, payload.inventory_item_id)
|
|
if inventory_item is None:
|
|
continue
|
|
default_price = inventory_item.selling_price_cents or 0
|
|
if payload.unit_price_cents != default_price:
|
|
overrides.append({
|
|
"inventory_item_id": inventory_item.id,
|
|
"label": f"{inventory_item.sku} · {inventory_item.name}",
|
|
"default_price_cents": default_price,
|
|
"override_price_cents": payload.unit_price_cents,
|
|
})
|
|
return overrides
|
|
|
|
@staticmethod
|
|
def _write_price_override_audits(db: Session, estimate: RepairEstimate, overrides: list[dict], *, actor: User, request: Request) -> None:
|
|
for override in overrides:
|
|
write_audit_log(
|
|
db,
|
|
action="inventory.estimate.price_override",
|
|
entity_type="inventory_items",
|
|
entity_id=override["inventory_item_id"],
|
|
entity_label=override["label"],
|
|
actor=actor,
|
|
request=request,
|
|
metadata={
|
|
"estimate_id": estimate.id,
|
|
"estimate_number": estimate.estimate_number,
|
|
"default_price_cents": override["default_price_cents"],
|
|
"override_price_cents": override["override_price_cents"],
|
|
},
|
|
)
|
|
|
|
@staticmethod
|
|
def _write_low_stock_audits(db: Session, estimate: RepairEstimate, *, actor: User, request: Request) -> None:
|
|
seen_item_ids: set[int] = set()
|
|
for estimate_item in estimate.items:
|
|
if estimate_item.inventory_item_id is None or estimate_item.inventory_item_id in seen_item_ids:
|
|
continue
|
|
seen_item_ids.add(estimate_item.inventory_item_id)
|
|
inventory_item = InventoryRepository.get_item(db, estimate_item.inventory_item_id)
|
|
if inventory_item is None or inventory_item.quantity_available > inventory_item.reorder_level:
|
|
continue
|
|
write_audit_log(
|
|
db,
|
|
action="inventory.stock.low",
|
|
entity_type="inventory_items",
|
|
entity_id=inventory_item.id,
|
|
entity_label=f"{inventory_item.sku} · {inventory_item.name}",
|
|
actor=actor,
|
|
request=request,
|
|
metadata={
|
|
"estimate_id": estimate.id,
|
|
"estimate_number": estimate.estimate_number,
|
|
"quantity_available": inventory_item.quantity_available,
|
|
"reorder_level": inventory_item.reorder_level,
|
|
},
|
|
)
|
|
|
|
@staticmethod
|
|
def _estimate_mail_text(repair: Repair, estimate: RepairEstimate, public_status_url: str) -> str:
|
|
return (
|
|
f"Hallo {repair.customer_name},\n\n"
|
|
f"zu Ihrer Reparatur {repair.repair_number} liegt ein Kostenvoranschlag vor.\n\n"
|
|
f"Gerät: {repair.device_manufacturer} {repair.device_model}\n"
|
|
f"Kostenvoranschlag: {estimate.estimate_number}\n"
|
|
f"Gesamtbetrag: {_money(estimate.total_cents, estimate.currency)}\n\n"
|
|
f"Kostenvoranschlag ansehen und entscheiden:\n{public_status_url}\n\n"
|
|
"Funktechnik Schubert"
|
|
)
|
|
|
|
@staticmethod
|
|
def _estimate_mail_html(repair: Repair, estimate: RepairEstimate, public_status_url: str) -> str:
|
|
return f"""<!doctype html>
|
|
<html lang="de"><body style="font-family:Arial,Helvetica,sans-serif;background:#f4f7fb;color:#172033;padding:24px;">
|
|
<table role="presentation" style="max-width:640px;width:100%;margin:auto;background:#fff;border:1px solid #dce5ef;border-radius:8px;">
|
|
<tr><td style="background:#082a60;color:#fff;padding:24px 28px;font-size:22px;font-weight:800;">Funktechnik Schubert</td></tr>
|
|
<tr><td style="padding:28px;">
|
|
<p>Hallo {escape(repair.customer_name)},</p>
|
|
<p>zu Ihrer Reparatur <strong>{escape(repair.repair_number)}</strong> liegt ein Kostenvoranschlag vor.</p>
|
|
<p><strong>Gerät:</strong> {escape((repair.device_manufacturer + " " + repair.device_model).strip())}<br>
|
|
<strong>Kostenvoranschlag:</strong> {escape(estimate.estimate_number)}<br>
|
|
<strong>Gesamtbetrag:</strong> {escape(_money(estimate.total_cents, estimate.currency))}</p>
|
|
<p><a href="{escape(public_status_url)}" style="display:inline-block;background:#082a60;color:#fff;text-decoration:none;font-weight:700;border-radius:8px;padding:12px 16px;">Kostenvoranschlag ansehen</a></p>
|
|
</td></tr></table></body></html>"""
|
|
|
|
@staticmethod
|
|
def _revoked_mail_text(repair: Repair, estimate: RepairEstimate, public_status_url: str) -> str:
|
|
return (
|
|
f"Hallo {repair.customer_name},\n\n"
|
|
"Der zuvor freigegebene Kostenvoranschlag wurde aufgrund einer Korrektur zurückgenommen. "
|
|
"Sie erhalten in Kürze einen neuen Kostenvoranschlag.\n\n"
|
|
f"Reparatur: {repair.repair_number}\n"
|
|
f"Kostenvoranschlag: {estimate.estimate_number}\n\n"
|
|
f"Aktuellen Status ansehen:\n{public_status_url}\n\n"
|
|
"Funktechnik Schubert"
|
|
)
|
|
|
|
@staticmethod
|
|
def _revoked_mail_html(repair: Repair, estimate: RepairEstimate, public_status_url: str) -> str:
|
|
return f"""<!doctype html>
|
|
<html lang="de"><body style="font-family:Arial,Helvetica,sans-serif;background:#f4f7fb;color:#172033;padding:24px;">
|
|
<table role="presentation" style="max-width:640px;width:100%;margin:auto;background:#fff;border:1px solid #dce5ef;border-radius:8px;">
|
|
<tr><td style="background:#082a60;color:#fff;padding:24px 28px;font-size:22px;font-weight:800;">Funktechnik Schubert</td></tr>
|
|
<tr><td style="padding:28px;">
|
|
<p>Hallo {escape(repair.customer_name)},</p>
|
|
<p>Der zuvor freigegebene Kostenvoranschlag wurde aufgrund einer Korrektur zurückgenommen. Sie erhalten in Kürze einen neuen Kostenvoranschlag.</p>
|
|
<p><strong>Reparatur:</strong> {escape(repair.repair_number)}<br>
|
|
<strong>Kostenvoranschlag:</strong> {escape(estimate.estimate_number)}</p>
|
|
<p><a href="{escape(public_status_url)}" style="display:inline-block;background:#082a60;color:#fff;text-decoration:none;font-weight:700;border-radius:8px;padding:12px 16px;">Status ansehen</a></p>
|
|
</td></tr></table></body></html>"""
|