269 lines
8.8 KiB
Python
269 lines
8.8 KiB
Python
from datetime import UTC, datetime, timedelta
|
|
|
|
from sqlalchemy import func, select
|
|
from sqlalchemy.orm import Session, selectinload
|
|
|
|
from app.models.customer import Customer, CustomerAddress, CustomerContact
|
|
from app.schemas.customer import (
|
|
CustomerAddressCreate,
|
|
CustomerAddressUpdate,
|
|
CustomerContactCreate,
|
|
CustomerContactUpdate,
|
|
CustomerCreate,
|
|
CustomerUpdate,
|
|
)
|
|
|
|
|
|
def _email(value: object) -> str:
|
|
return "" if value is None else str(value)
|
|
|
|
|
|
def _url(value: object) -> str:
|
|
return "" if value is None else str(value)
|
|
|
|
|
|
class CustomerRepository:
|
|
@staticmethod
|
|
def get_all(db: Session) -> list[Customer]:
|
|
return list(
|
|
db.scalars(
|
|
select(Customer)
|
|
.options(
|
|
selectinload(Customer.addresses),
|
|
selectinload(Customer.contacts),
|
|
)
|
|
.order_by(Customer.created_at.desc())
|
|
)
|
|
)
|
|
|
|
@staticmethod
|
|
def get_by_id(db: Session, customer_id: int) -> Customer | None:
|
|
return db.scalar(
|
|
select(Customer)
|
|
.where(Customer.id == customer_id)
|
|
.options(
|
|
selectinload(Customer.addresses),
|
|
selectinload(Customer.contacts),
|
|
)
|
|
)
|
|
|
|
@staticmethod
|
|
def get_by_number(db: Session, customer_number: str) -> Customer | None:
|
|
return db.scalar(select(Customer).where(Customer.customer_number == customer_number))
|
|
|
|
@staticmethod
|
|
def find_number_conflict(
|
|
db: Session,
|
|
*,
|
|
customer_number: str,
|
|
exclude_customer_id: int | None = None,
|
|
) -> Customer | None:
|
|
query = select(Customer).where(Customer.customer_number == customer_number)
|
|
if exclude_customer_id is not None:
|
|
query = query.where(Customer.id != exclude_customer_id)
|
|
return db.scalar(query)
|
|
|
|
@staticmethod
|
|
def count_all(db: Session) -> int:
|
|
return db.scalar(select(func.count(Customer.id))) or 0
|
|
|
|
@staticmethod
|
|
def count_active(db: Session) -> int:
|
|
return db.scalar(select(func.count(Customer.id)).where(Customer.status == "active")) or 0
|
|
|
|
@staticmethod
|
|
def count_recent(db: Session, days: int = 30) -> int:
|
|
since = datetime.now(UTC) - timedelta(days=days)
|
|
return db.scalar(
|
|
select(func.count(Customer.id))
|
|
.where(Customer.created_at >= since)
|
|
) or 0
|
|
|
|
@staticmethod
|
|
def get_latest(db: Session, limit: int = 5) -> list[Customer]:
|
|
return list(
|
|
db.scalars(
|
|
select(Customer)
|
|
.options(selectinload(Customer.addresses), selectinload(Customer.contacts))
|
|
.order_by(Customer.created_at.desc())
|
|
.limit(limit)
|
|
)
|
|
)
|
|
|
|
@staticmethod
|
|
def create(db: Session, customer: CustomerCreate) -> Customer:
|
|
db_customer = Customer(
|
|
customer_number=customer.customer_number,
|
|
company_name=customer.company_name,
|
|
legal_name=customer.legal_name,
|
|
customer_type=customer.customer_type,
|
|
status=customer.status,
|
|
industry=customer.industry,
|
|
website=_url(customer.website),
|
|
email=_email(customer.email),
|
|
phone=customer.phone,
|
|
tax_number=customer.tax_number,
|
|
vat_id=customer.vat_id,
|
|
notes=customer.notes,
|
|
)
|
|
db_customer.addresses = [
|
|
CustomerRepository._address_from_payload(address)
|
|
for address in customer.addresses
|
|
]
|
|
db_customer.contacts = [
|
|
CustomerRepository._contact_from_payload(contact)
|
|
for contact in customer.contacts
|
|
]
|
|
CustomerRepository._normalize_primary(db_customer.addresses)
|
|
CustomerRepository._normalize_primary(db_customer.contacts)
|
|
|
|
db.add(db_customer)
|
|
db.commit()
|
|
db.refresh(db_customer)
|
|
|
|
return CustomerRepository.get_by_id(db, db_customer.id) or db_customer
|
|
|
|
@staticmethod
|
|
def update(db: Session, db_customer: Customer, customer: CustomerUpdate) -> Customer:
|
|
db_customer.customer_number = customer.customer_number
|
|
db_customer.company_name = customer.company_name
|
|
db_customer.legal_name = customer.legal_name
|
|
db_customer.customer_type = customer.customer_type
|
|
db_customer.status = customer.status
|
|
db_customer.industry = customer.industry
|
|
db_customer.website = _url(customer.website)
|
|
db_customer.email = _email(customer.email)
|
|
db_customer.phone = customer.phone
|
|
db_customer.tax_number = customer.tax_number
|
|
db_customer.vat_id = customer.vat_id
|
|
db_customer.notes = customer.notes
|
|
|
|
db_customer.addresses = [
|
|
CustomerRepository._address_from_payload(address)
|
|
for address in customer.addresses
|
|
]
|
|
CustomerRepository._normalize_primary(db_customer.addresses)
|
|
|
|
db.commit()
|
|
db.refresh(db_customer)
|
|
|
|
return CustomerRepository.get_by_id(db, db_customer.id) or db_customer
|
|
|
|
@staticmethod
|
|
def delete(db: Session, db_customer: Customer) -> None:
|
|
db.delete(db_customer)
|
|
db.commit()
|
|
|
|
@staticmethod
|
|
def get_contacts(db: Session, customer_id: int) -> list[CustomerContact]:
|
|
return list(
|
|
db.scalars(
|
|
select(CustomerContact)
|
|
.where(CustomerContact.customer_id == customer_id)
|
|
.order_by(CustomerContact.is_primary.desc(), CustomerContact.last_name)
|
|
)
|
|
)
|
|
|
|
@staticmethod
|
|
def get_contact_by_id(
|
|
db: Session,
|
|
customer_id: int,
|
|
contact_id: int,
|
|
) -> CustomerContact | None:
|
|
return db.scalar(
|
|
select(CustomerContact)
|
|
.where(CustomerContact.customer_id == customer_id)
|
|
.where(CustomerContact.id == contact_id)
|
|
)
|
|
|
|
@staticmethod
|
|
def create_contact(
|
|
db: Session,
|
|
customer_id: int,
|
|
contact: CustomerContactCreate,
|
|
) -> CustomerContact:
|
|
db_contact = CustomerRepository._contact_from_payload(contact)
|
|
db_contact.customer_id = customer_id
|
|
db.add(db_contact)
|
|
db.flush()
|
|
|
|
if db_contact.is_primary:
|
|
CustomerRepository._clear_other_primary_contacts(db, customer_id, db_contact.id)
|
|
|
|
db.commit()
|
|
db.refresh(db_contact)
|
|
return db_contact
|
|
|
|
@staticmethod
|
|
def update_contact(
|
|
db: Session,
|
|
db_contact: CustomerContact,
|
|
contact: CustomerContactUpdate,
|
|
) -> CustomerContact:
|
|
db_contact.first_name = contact.first_name
|
|
db_contact.last_name = contact.last_name
|
|
db_contact.position = contact.position
|
|
db_contact.email = _email(contact.email)
|
|
db_contact.phone = contact.phone
|
|
db_contact.mobile = contact.mobile
|
|
db_contact.is_primary = contact.is_primary
|
|
db_contact.notes = contact.notes
|
|
|
|
if db_contact.is_primary:
|
|
CustomerRepository._clear_other_primary_contacts(db, db_contact.customer_id, db_contact.id)
|
|
|
|
db.commit()
|
|
db.refresh(db_contact)
|
|
return db_contact
|
|
|
|
@staticmethod
|
|
def delete_contact(db: Session, db_contact: CustomerContact) -> None:
|
|
db.delete(db_contact)
|
|
db.commit()
|
|
|
|
@staticmethod
|
|
def _address_from_payload(address: CustomerAddressCreate | CustomerAddressUpdate) -> CustomerAddress:
|
|
return CustomerAddress(
|
|
type=address.type,
|
|
street=address.street,
|
|
postal_code=address.postal_code,
|
|
city=address.city,
|
|
state=address.state,
|
|
country=address.country,
|
|
is_primary=address.is_primary,
|
|
)
|
|
|
|
@staticmethod
|
|
def _contact_from_payload(contact: CustomerContactCreate | CustomerContactUpdate) -> CustomerContact:
|
|
return CustomerContact(
|
|
first_name=contact.first_name,
|
|
last_name=contact.last_name,
|
|
position=contact.position,
|
|
email=_email(contact.email),
|
|
phone=contact.phone,
|
|
mobile=contact.mobile,
|
|
is_primary=contact.is_primary,
|
|
notes=contact.notes,
|
|
)
|
|
|
|
@staticmethod
|
|
def _normalize_primary(items: list[CustomerAddress] | list[CustomerContact]) -> None:
|
|
primary_seen = False
|
|
for item in items:
|
|
if item.is_primary and not primary_seen:
|
|
primary_seen = True
|
|
elif item.is_primary:
|
|
item.is_primary = False
|
|
|
|
if items and not primary_seen:
|
|
items[0].is_primary = True
|
|
|
|
@staticmethod
|
|
def _clear_other_primary_contacts(db: Session, customer_id: int, contact_id: int) -> None:
|
|
contacts = db.scalars(
|
|
select(CustomerContact)
|
|
.where(CustomerContact.customer_id == customer_id)
|
|
.where(CustomerContact.id != contact_id)
|
|
)
|
|
for contact in contacts:
|
|
contact.is_primary = False
|