194 lines
7.6 KiB
Python
194 lines
7.6 KiB
Python
import uuid
|
|
|
|
from sqlalchemy import select, text
|
|
from sqlalchemy.exc import IntegrityError
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.audit.service import AuditService
|
|
from app.common.enums import AuditAction, EntityType, Role
|
|
from app.common.exceptions import ConflictError, NotFoundError
|
|
from app.common.utils import snapshot
|
|
from app.products.models import Product
|
|
from app.products.schemas import (
|
|
ProductCreate,
|
|
ProductUpdate,
|
|
StockInventoryCreate,
|
|
StockInventoryRead,
|
|
StockInventoryUpdate,
|
|
)
|
|
from app.users.models import User
|
|
|
|
_AUDIT_FIELDS = ["name", "pack", "unit", "is_active"]
|
|
|
|
|
|
class ProductService:
|
|
def __init__(self, db: AsyncSession) -> None:
|
|
self.db, self.audit = db, AuditService(db)
|
|
|
|
async def list_for(self, actor: User) -> list[Product]:
|
|
stmt = select(Product).where(Product.company_id == actor.company_id).order_by(Product.name)
|
|
if actor.role == Role.MR:
|
|
stmt = stmt.where(Product.is_active.is_(True))
|
|
return list((await self.db.execute(stmt)).scalars().all())
|
|
|
|
async def list_stock_inventory(self) -> list[StockInventoryRead]:
|
|
result = await self.db.execute(
|
|
text(
|
|
"""
|
|
SELECT id, serial_no, product_name, pack, quantity, unit
|
|
FROM stock_inventory
|
|
ORDER BY serial_no
|
|
"""
|
|
)
|
|
)
|
|
return [StockInventoryRead.model_validate(row) for row in result.mappings()]
|
|
|
|
async def _stock_row(self, item_id: int) -> StockInventoryRead:
|
|
result = await self.db.execute(
|
|
text(
|
|
"SELECT id, serial_no, product_name, pack, quantity, unit "
|
|
"FROM stock_inventory WHERE id = :id"
|
|
),
|
|
{"id": item_id},
|
|
)
|
|
row = result.mappings().one_or_none()
|
|
if row is None:
|
|
raise NotFoundError("Stock item not found")
|
|
return StockInventoryRead.model_validate(row)
|
|
|
|
async def _assert_stock_name_free(self, name: str, except_id: int | None = None) -> None:
|
|
"""A product appears once in the stock list — this also absorbs a double-submitted form."""
|
|
taken = (
|
|
await self.db.execute(
|
|
text(
|
|
"SELECT 1 FROM stock_inventory WHERE lower(btrim(product_name)) = lower(btrim(:name)) "
|
|
"AND (CAST(:skip AS INTEGER) IS NULL OR id <> :skip) LIMIT 1"
|
|
),
|
|
{"name": name, "skip": except_id},
|
|
)
|
|
).first()
|
|
if taken:
|
|
raise ConflictError("This product is already in the stock list", {"product_name": name})
|
|
|
|
async def create_stock_item(
|
|
self, data: StockInventoryCreate, actor: User, ip: str | None = None
|
|
) -> StockInventoryRead:
|
|
await self._assert_stock_name_free(data.product_name)
|
|
result = await self.db.execute(
|
|
text(
|
|
"""
|
|
INSERT INTO stock_inventory (serial_no, product_name, pack, quantity, unit)
|
|
VALUES (
|
|
(SELECT COALESCE(MAX(serial_no), 0) + 1 FROM stock_inventory),
|
|
:product_name, :pack, :quantity, :unit
|
|
)
|
|
RETURNING id
|
|
"""
|
|
),
|
|
data.model_dump(),
|
|
)
|
|
item = await self._stock_row(result.scalar_one())
|
|
await self._audit_stock(actor, item, None, item.model_dump(), AuditAction.CREATE, ip)
|
|
await self.db.commit()
|
|
return item
|
|
|
|
async def update_stock_item(
|
|
self, item_id: int, data: StockInventoryUpdate, actor: User, ip: str | None = None
|
|
) -> StockInventoryRead:
|
|
before = await self._stock_row(item_id)
|
|
changes = data.model_dump(exclude_unset=True)
|
|
if changes.get("product_name") is None:
|
|
changes.pop("product_name", None)
|
|
if "product_name" in changes:
|
|
await self._assert_stock_name_free(changes["product_name"], except_id=item_id)
|
|
if changes:
|
|
assignments = ", ".join(f"{column} = :{column}" for column in changes)
|
|
await self.db.execute(
|
|
text(f"UPDATE stock_inventory SET {assignments} WHERE id = :id"),
|
|
{**changes, "id": item_id},
|
|
)
|
|
after = await self._stock_row(item_id)
|
|
await self._audit_stock(
|
|
actor, after, before.model_dump(), after.model_dump(), AuditAction.UPDATE, ip
|
|
)
|
|
await self.db.commit()
|
|
return after
|
|
|
|
async def delete_stock_item(self, item_id: int, actor: User, ip: str | None = None) -> None:
|
|
before = await self._stock_row(item_id)
|
|
await self.db.execute(text("DELETE FROM stock_inventory WHERE id = :id"), {"id": item_id})
|
|
# keep the printed "No." column gap-free, like the company forms do
|
|
await self.db.execute(
|
|
text(
|
|
"""
|
|
WITH numbered AS (
|
|
SELECT id, ROW_NUMBER() OVER (ORDER BY serial_no, id) AS n FROM stock_inventory
|
|
)
|
|
UPDATE stock_inventory s SET serial_no = numbered.n
|
|
FROM numbered WHERE s.id = numbered.id AND s.serial_no <> numbered.n
|
|
"""
|
|
)
|
|
)
|
|
await self._audit_stock(actor, before, before.model_dump(), None, AuditAction.DELETE, ip)
|
|
await self.db.commit()
|
|
|
|
async def _audit_stock(self, actor, item, before, after, action, ip) -> None:
|
|
# entity_id is a UUID column; stock rows use integer ids, so derive a stable UUID.
|
|
await self.audit.log(
|
|
actor_user_id=actor.id,
|
|
entity_type=EntityType.PRODUCT,
|
|
entity_id=uuid.uuid5(uuid.NAMESPACE_OID, f"stock_inventory:{item.id}"),
|
|
action=action,
|
|
before=before,
|
|
after=after,
|
|
ip_address=ip,
|
|
)
|
|
|
|
async def create(self, data: ProductCreate, actor: User, ip: str | None = None) -> Product:
|
|
product = Product(company_id=actor.company_id, **data.model_dump())
|
|
self.db.add(product)
|
|
try:
|
|
await self.db.flush()
|
|
except IntegrityError as exc:
|
|
await self.db.rollback()
|
|
raise ConflictError(
|
|
"A product with this name already exists", {"cause": "uq_product_company_name"}
|
|
) from exc
|
|
await self.audit.log(
|
|
actor_user_id=actor.id,
|
|
entity_type=EntityType.PRODUCT,
|
|
entity_id=product.id,
|
|
action=AuditAction.CREATE,
|
|
after=snapshot(product, _AUDIT_FIELDS),
|
|
ip_address=ip,
|
|
)
|
|
await self.db.commit()
|
|
return product
|
|
|
|
async def update(
|
|
self, product_id: uuid.UUID, data: ProductUpdate, actor: User, ip: str | None = None
|
|
) -> Product:
|
|
product = await self.db.get(Product, product_id)
|
|
if product is None or product.company_id != actor.company_id:
|
|
raise NotFoundError("Product not found")
|
|
before = snapshot(product, _AUDIT_FIELDS)
|
|
for field, value in data.model_dump(exclude_unset=True).items():
|
|
setattr(product, field, value)
|
|
await self.audit.log(
|
|
actor_user_id=actor.id,
|
|
entity_type=EntityType.PRODUCT,
|
|
entity_id=product.id,
|
|
action=AuditAction.UPDATE,
|
|
before=before,
|
|
after=snapshot(product, _AUDIT_FIELDS),
|
|
ip_address=ip,
|
|
)
|
|
try:
|
|
await self.db.commit()
|
|
except IntegrityError as exc:
|
|
await self.db.rollback()
|
|
raise ConflictError(
|
|
"A product with this name already exists", {"cause": "uq_product_company_name"}
|
|
) from exc
|
|
return product
|