services.py

# services.py
from typing import Optional, List
from errors import BadRequestError, ConflictError, NotFoundError
from models import Person
from dal import PeopleRepository

class PeopleService:
    def __init__(self, repo: PeopleRepository):
        self.repo = repo

    @staticmethod
    def _validate_names(first_name: Optional[str], last_name: Optional[str], *, required: bool):
        if required:
            if first_name is None or last_name is None:
                raise BadRequestError("firstName or lastName is missing")

        if first_name is not None:
            first_name = first_name.strip()
            if not first_name:
                raise BadRequestError("firstName cannot be empty")
            if len(first_name) > 100:
                raise BadRequestError("firstName is too long (Max 100)")

        if last_name is not None:
            last_name = last_name.strip()
            if not last_name:
                raise BadRequestError("lastName cannot be empty")
            if len(last_name) > 100:
                raise BadRequestError("lastName is too long (Max 100)")

        if not required and first_name is None and last_name is None:
            raise BadRequestError("No fields to update")

        return first_name, last_name

    def save_person(self, first_name: str, last_name: str) -> Person:
        first_name, last_name = self._validate_names(first_name, last_name, required=True)
        new_id = self.repo.insert(first_name, last_name)
        person = self.repo.get_by_id(new_id)
        if not person:
            raise ConflictError("Insert succeeded but record not found")
        return person

    def delete_by_id(self, person_id: int) -> None:
        affected = self.repo.delete(person_id)
        if affected == 0:
            raise NotFoundError(f"Person with ID: {person_id} not Found")

    def update_person(self, person_id: int, first_name: Optional[str], last_name: Optional[str]) -> Person:
        first_name, last_name = self._validate_names(first_name, last_name, required=False)
        affected = self.repo.update(person_id, first_name, last_name)
        if affected == 0:
            if not self.repo.get_by_id(person_id):
                raise NotFoundError(f"Person with ID: {person_id} not found")
            raise ConflictError("Update had no effect")
        person = self.repo.get_by_id(person_id)
        if not person:
            raise ConflictError("Updated but could not re-fetch entity")
        return person

    def get_by_id(self, person_id: int) -> Person:
        person = self.repo.get_by_id(person_id)
        if not person:
            raise NotFoundError(f"Person with ID: {person_id} not found")
        return person

    def get_people(self) -> List[Person]:
        return self.repo.get_all()

    def search_people(self, name: str) -> List[Person]:
        name = (name or "").strip()
        if not name:
            raise BadRequestError("Missing search parameter: name")
        return self.repo.search_by_name(name)