def delete_wireless_device(ctx, s, mac_address):
""" Delete a wireless device from the database """
q = s.query(Portable).filter(Portable.mac == mac_address)
dev = q.one()
with track_modifications(ctx, s, dev):
s.delete(dev)
def delete_wired_device(ctx, s, mac_address):
""" Delete a wired device from the databse """
q = s.query(Ordinateur).filter(Ordinateur.mac == mac_address)
dev = q.one()
with track_modifications(ctx, s, dev):
s.delete(dev)
def create_account(self,
ctx,
name=None,
actif=None,
type=None,
creation_date=None):
"""
Create an account.
:raise AccountTypeNotFound ?
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_account_repository_create_account_called",
extra=log_extra(ctx, name=name, type=type))
now = datetime.now()
account = SQLAccount(
name=name,
actif=actif,
type=type,
creation_date=now,
)
with track_modifications(ctx, s, account):
s.add(account)
return account
def create_product(self,
ctx,
name=None,
selling_price=None,
buying_price=None):
"""
Create a product .
:raise ProductTypeNotFound ?
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_product_repository_create_product_called",
extra=log_extra(ctx, name=name))
product = SQLProduct(
name=name,
buying_price=buying_price,
selling_price=selling_price,
)
with track_modifications(ctx, s, product):
s.add(product)
return product
def create_wireless_device(ctx, mac_address, username, s):
""" Create a wireless device in the database """
dev = Portable(
mac=mac_address,
adherent=s.query(Adherent).filter(Adherent.login == username).one(),
)
with track_modifications(ctx, s, dev):
s.add(dev)
return dev
def create_transaction(self,
ctx,
src=None,
dst=None,
name=None,
value=None,
paymentMethod=None,
attachments=None):
LOG.debug("sql_device_repository_create_transaction_called",
extra=log_extra(ctx, name=name))
"""
Create a transaction.
:raise AccountNotFound
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_transaction_repository_create_transaction_called",
extra=log_extra(ctx, name=name))
now = datetime.now()
account_src = None
if src is not None:
account_src = s.query(Account).filter(
Account.id == src).one_or_none()
if not account_src:
raise AccountNotFoundError(src)
account_dst = None
if dst is not None:
account_dst = s.query(Account).filter(
Account.id == dst).one_or_none()
if not account_dst:
raise AccountNotFoundError(dst)
method = None
if paymentMethod is not None:
method = s.query(PaymentMethod).filter(
PaymentMethod.id == paymentMethod).one_or_none()
if not method:
raise PaymentMethodNotFoundError(paymentMethod)
transaction = SQLTransaction(src_account=account_src,
dst_account=account_dst,
value=value,
name=name,
timestamp=now,
attachments="",
payment_method=method)
with track_modifications(ctx, s, transaction):
s.add(transaction)
pass
def create_wired_device(ctx, mac_address, ip_v4_address, ip_v6_address,
username, s):
""" Create a wired device in the database """
dev = Ordinateur(
mac=mac_address,
ip=ip_v4_address,
ipv6=ip_v6_address,
adherent=s.query(Adherent).filter(Adherent.login == username).one(),
)
with track_modifications(ctx, s, dev):
s.add(dev)
return dev
def create_member(self,
ctx,
last_name=None,
first_name=None,
email=None,
username=None,
comment=None,
room_number=None,
departure_date=None,
association_mode=None) -> None:
"""
Create a member.
:raise RoomNotFound
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_member_repository_create_member_called",
extra=log_extra(ctx, username=username))
now = datetime.now()
room = None
if room_number is not None:
room = s.query(Chambre).filter(
Chambre.numero == room_number).one_or_none()
if not room:
raise RoomNotFoundError(room_number)
member = s.query(Adherent).filter(
Adherent.login == username).one_or_none()
if member is not None:
raise MemberAlreadyExist()
member = Adherent(
nom=last_name,
prenom=first_name,
mail=email,
login=username,
chambre=room,
created_at=now,
updated_at=now,
commentaires=comment,
date_de_depart=_parse_date_or_none(departure_date),
mode_association=_parse_date_or_none(association_mode),
)
with track_modifications(ctx, s, member):
s.add(member)
def update_wireless_device(ctx,
s,
device_to_update,
mac_address=None,
username=None):
""" Update a wireless device in the database """
q = s.query(Portable).filter(Portable.mac == device_to_update)
dev = q.one()
with track_modifications(ctx, s, dev):
dev.mac = mac_address or dev.mac
if username:
dev.adherent = s.query(Adherent).filter(
Adherent.login == username).one()
return dev
def update_member(self,
ctx,
member_to_update,
last_name=None,
first_name=None,
email=None,
username=None,
comment=None,
room_number=None,
departure_date: str = None,
association_mode: str = None,
password=None) -> None:
"""
Update a member.
:raise MemberNotFound
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_member_repository_update_member_called",
extra=log_extra(ctx, username=member_to_update))
member = _get_member_by_login(s, member_to_update)
if member is None:
raise MemberNotFoundError(member_to_update)
with track_modifications(ctx, s, member):
member.nom = last_name or member.nom
member.prenom = first_name or member.prenom
member.mail = email or member.mail
member.commentaires = comment or member.commentaires
member.login = username or member.login
if departure_date is not None:
member.date_de_depart = _parse_date_or_none(departure_date)
if association_mode is not None:
member.mode_association = _parse_date_or_none(association_mode)
if room_number is not None:
member.chambre = s.query(Chambre).filter(
Chambre.numero == room_number).one()
member.updated_at = datetime.now()
member.password = password or member.password # Will not be tracked.
def delete_member(self, ctx, username=None) -> None:
"""
Delete a member.
:raise MemberNotFound
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_member_repository_delete_member_called",
extra=log_extra(ctx, username=username))
# Find the soon-to-be deleted user
member = _get_member_by_login(s, username)
if not member:
raise MemberNotFoundError(username)
with track_modifications(ctx, s, member):
# Actually delete it
s.delete(member)
def delete_product(self, ctx, name=None):
"""
Delete a product.
:raise ProductNotFound (one day)
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_product_repository_delete_product_called",
extra=log_extra(ctx, name=name))
# Find the soon-to-be deleted user
product = _get_product_by_name(s, name)
if not product:
raise ProductNotFoundError(name)
with track_modifications(ctx, s, product):
# Actually delete it
s.delete(product)
def update_wired_device(ctx,
s,
device_to_update,
mac_address=None,
username=None,
ip_v4_address=None,
ip_v6_address=None):
""" Update a wired device in the database """
q = s.query(Ordinateur).filter(Ordinateur.mac == device_to_update)
dev = q.one()
with track_modifications(ctx, s, dev):
dev.ip = ip_v4_address or dev.ip
dev.ipv6 = ip_v6_address or dev.ipv6
dev.mac = mac_address or dev.mac
if username:
dev.adherent = s.query(Adherent).filter(
Adherent.login == username).one()
return dev
def update_product(self,
ctx,
name=None,
selling_price=None,
buying_price=None,
product_id=None) -> None:
"""
Update a product.
Will raise (one day) ProductNotFound
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_product_repository_update_product_called",
extra=log_extra(ctx, product_id=product_id))
product = _get_product_by_id(s, product_id)
if product is None:
raise ProductNotFoundError(product_id)
with track_modifications(ctx, s, product):
product.name = name or product.name
product.buying_price = buying_price or product.buying_price
product.selling_price = selling_price or product.selling_price
def update_account(self,
ctx,
name=None,
type=None,
actif=None,
creation_date=None,
account_id=None) -> None:
"""
Update an account.
Will raise (one day) AccountNotFound
"""
s = ctx.get(CTX_SQL_SESSION)
LOG.debug("sql_account_repository_update_account_called",
extra=log_extra(ctx, account_id=account_id, actif=actif))
account = _get_account_by_id(s, account_id)
if account is None:
raise AccountNotFoundError(account_id)
with track_modifications(ctx, s, account):
account.name = name or account.name
account.type = type or account.type
account.actif = actif
account.creation_date = creation_date or account.creation_date