142 lines
4.3 KiB
Python
142 lines
4.3 KiB
Python
from sqlmodel import Session, select
|
|
from src import messages, models
|
|
from src.productors import exceptions
|
|
|
|
|
|
def get_all(
|
|
session: Session,
|
|
user: models.User,
|
|
names: list[str],
|
|
types: list[str]
|
|
) -> list[models.ProductorPublic]:
|
|
statement = select(models.Productor)\
|
|
.where(models.Productor.type.in_([r.name for r in user.roles]))\
|
|
.distinct()
|
|
if len(names) > 0:
|
|
statement = statement.where(models.Productor.name.in_(names))
|
|
if len(types) > 0:
|
|
statement = statement.where(models.Productor.type.in_(types))
|
|
return session.exec(statement.order_by(models.Productor.name)).all()
|
|
|
|
|
|
def get_one(session: Session, productor_id: int) -> models.ProductorPublic:
|
|
return session.get(models.Productor, productor_id)
|
|
|
|
|
|
def create_one(
|
|
session: Session,
|
|
productor: models.ProductorCreate) -> models.ProductorPublic:
|
|
if not productor:
|
|
raise exceptions.ProductorCreateError(
|
|
messages.Messages.invalid_input(
|
|
'productor', 'input cannot be None'))
|
|
productor_create = productor.model_dump(
|
|
exclude_unset=True, exclude='payment_methods')
|
|
new_productor = models.Productor(**productor_create)
|
|
|
|
new_productor.payment_methods = [
|
|
models.PaymentMethod(
|
|
name=pm.name,
|
|
details=pm.details
|
|
) for pm in productor.payment_methods
|
|
]
|
|
|
|
session.add(new_productor)
|
|
session.commit()
|
|
session.refresh(new_productor)
|
|
return new_productor
|
|
|
|
|
|
def update_one(
|
|
session: Session,
|
|
_id: int,
|
|
productor: models.ProductorUpdate
|
|
) -> models.ProductorPublic:
|
|
statement = select(models.Productor).where(models.Productor.id == _id)
|
|
result = session.exec(statement)
|
|
new_productor = result.first()
|
|
if not new_productor:
|
|
raise exceptions.ProductorNotFoundError(
|
|
messages.Messages.not_found('productor'))
|
|
|
|
productor_updates = productor.model_dump(exclude_unset=True)
|
|
if 'payment_methods' in productor_updates:
|
|
new_productor.payment_methods.clear()
|
|
for pm in productor_updates['payment_methods']:
|
|
print(pm)
|
|
new_productor.payment_methods.append(
|
|
models.PaymentMethod(
|
|
name=pm['name'],
|
|
details=pm['details'],
|
|
productor_id=id,
|
|
max=pm['max'],
|
|
min=pm['min']
|
|
)
|
|
)
|
|
del productor_updates['payment_methods']
|
|
|
|
for key, value in productor_updates.items():
|
|
setattr(new_productor, key, value)
|
|
session.add(new_productor)
|
|
session.commit()
|
|
session.refresh(new_productor)
|
|
return new_productor
|
|
|
|
|
|
def delete_one(session: Session, _id: int) -> models.ProductorPublic:
|
|
statement = select(models.Productor).where(models.Productor.id == _id)
|
|
result = session.exec(statement)
|
|
productor = result.first()
|
|
if not productor:
|
|
raise exceptions.ProductorNotFoundError(
|
|
messages.Messages.not_found('productor'))
|
|
result = models.ProductorPublic.model_validate(productor)
|
|
session.delete(productor)
|
|
session.commit()
|
|
return result
|
|
|
|
|
|
def get_delete_dependencies(
|
|
session: Session,
|
|
_id: int
|
|
) -> list[models.DeleteDependency]:
|
|
statement = select(models.Productor).where(models.Productor.id == _id)
|
|
result = session.exec(statement)
|
|
productor = result.first()
|
|
if not productor:
|
|
raise exceptions.ProductorNotFoundError(
|
|
messages.Messages.not_found('productor'))
|
|
products_statement = (
|
|
select(models.Product)
|
|
.where(models.Product.productor_id == _id)
|
|
.distinct()
|
|
)
|
|
products = session.exec(products_statement).all()
|
|
result = [
|
|
models.DeleteDependency(
|
|
name=pro.name,
|
|
id=pro.id,
|
|
type='product'
|
|
) for pro in products
|
|
]
|
|
return result
|
|
|
|
|
|
def is_allowed(
|
|
session: Session,
|
|
user: models.User,
|
|
_id: int = None,
|
|
productor: models.ProductorCreate = None
|
|
) -> bool:
|
|
if not _id and not productor:
|
|
return False
|
|
if not _id:
|
|
return productor.type in [r.name for r in user.roles]
|
|
statement = (
|
|
select(models.Productor)
|
|
.where(models.Productor.id == _id)
|
|
.where(models.Productor.type.in_([r.name for r in user.roles]))
|
|
.distinct()
|
|
)
|
|
return len(session.exec(statement).all()) > 0
|