def get_by_id(self, ctx, object_id: int) -> AbstractRoom:
session: Session = ctx.get(CTX_SQL_SESSION)
obj = session.query(Chambre).filter(
Chambre.id == object_id).one_or_none()
if obj is None:
raise RoomNotFoundError(object_id)
return _map_room_sql_to_abstract_entity(obj)
def create(self, ctx, body: DeviceBody) -> Device:
if body.mac is None or not is_mac_address(body.mac):
raise InvalidMACAddress(body.mac)
if body.member is None:
raise MemberNotFoundError(None)
member = self.member_repository.get_by_id(ctx, body.member)
if not member:
raise MemberNotFoundError(body.member)
room = self.room_repository.get_from_member(ctx, body.member)
if not room:
raise RoomNotFoundError(f"for member {member.username}")
if not body.connection_type:
raise ValueError()
body.mac = str(body.mac).upper().replace(':', '-')
d = self.device_repository.get_by_mac(ctx, body.mac)
_, count = self.device_repository.search_by(ctx, limit=DEFAULT_LIMIT, offset=0, device_filter=DeviceFilter(member=body.member))
if d:
raise DeviceAlreadyExists()
elif count >= 20:
raise DevicesLimitReached()
device = self.device_repository.create(ctx, body)
vlan = self.vlan_repository.get_vlan(ctx, vlan_number=room.vlan)
if vlan is None:
raise VLANNotFoundError(room.vlan)
if body.connection_type == DeviceType.wired.name:
self._allocate_or_unallocate_ip(ctx, device, vlan.ipv4_network if vlan.ipv4_network else "", vlan.ipv6_network if vlan.ipv6_network else "")
else:
self._allocate_or_unallocate_ip(ctx, device, member.subnet if member.subnet else "", vlan.ipv6_network if vlan.ipv6_network else "")
return device
def create(self, ctx, abstract_port: Port) -> Port:
session: Session = ctx.get(CTX_SQL_SESSION)
now = datetime.now()
room = None
if abstract_port.room is not None:
room = session.query(SQLChambre).filter(
SQLChambre.id == abstract_port.room).one_or_none()
if not room:
raise RoomNotFoundError(abstract_port.room)
switch = None
if abstract_port.switch_obj is not None:
switch = session.query(SQLSwitch).filter(
SQLSwitch.id == abstract_port.switch_obj).one_or_none()
if not switch:
raise SwitchNotFoundError(abstract_port.switch_obj)
port = SQLPort(numero=abstract_port.port_number,
oid=abstract_port.oid,
switch_id=switch.id if switch else None,
chambre_id=room.id if room else None,
created_at=now,
updated_at=now)
session.add(port)
session.flush()
return _map_port_sql_to_entity(port)
def _merge_sql_with_entity(ctx,
entity: AbstractPort,
sql_object: SQLPort,
override=False) -> SQLPort:
now = datetime.now()
port = sql_object
if entity.oid is not None or override:
port.oid = entity.oid
if entity.port_number is not None or override:
port.numero = entity.port_number
if entity.room is not None:
session: Session = ctx.get(CTX_SQL_SESSION)
room = session.query(SQLChambre).filter(
SQLChambre.id == entity.room).one_or_none()
if not room:
raise RoomNotFoundError(entity.room)
port.chambre_id = room.id
if entity.switch_obj is not None:
session: Session = ctx.get(CTX_SQL_SESSION)
switch = session.query(SQLSwitch).filter(
SQLSwitch.id == entity.switch_obj).one_or_none()
if not switch:
raise SwitchNotFoundError(entity.switch_obj)
port.switch_id = switch.id
port.updated_at = now
return port
def list_members(self, ctx, room_id: int) -> List[int]:
try:
room = self.room_repository.get_by_id(ctx, room_id)
if not room:
raise RoomNotFoundError(room_id)
except Exception as e:
raise e
return self.room_repository.get_members(ctx, room_id=room_id)
def delete(self, ctx, id) -> None:
session: Session = ctx.get(CTX_SQL_SESSION)
room = session.query(Chambre).filter(Chambre.id == id).one_or_none()
if room is None:
raise RoomNotFoundError(id)
with track_modifications(ctx, session, room):
session.delete(room)
def remove_member(self, ctx, room_id: int, member_id: int) -> None:
try:
self.member_manager.get_by_id(ctx, member_id)
room = self.room_repository.get_by_id(ctx, room_id)
if not room:
raise RoomNotFoundError(room_id)
except NotFoundError as e:
raise e
self.room_repository.remove_member(ctx, member_id)
self.member_manager.reset_member(ctx, member_id)
def update(self,
ctx,
abstract_room: AbstractRoom,
override=False) -> object:
session: Session = ctx.get(CTX_SQL_SESSION)
query = session.query(Chambre)
query = query.filter(Chambre.id == abstract_room.id)
query = query.join(Vlan, Vlan.id == Chambre.vlan_id)
room = query.one_or_none()
if room is None:
raise RoomNotFoundError(str(abstract_room.id))
new_chambre = _merge_sql_with_entity(ctx, abstract_room, room,
override)
return _map_room_sql_to_entity(new_chambre)
def add_member(self, ctx, room_id: int, member_id: int) -> None:
try:
room = self.room_repository.get_by_id(ctx, room_id)
if not room:
raise RoomNotFoundError(room_id)
self.member_manager.get_by_id(ctx, member_id)
except NotFoundError as e:
raise e
previous_room = self.room_repository.get_from_member(ctx, member_id)
if previous_room:
self.room_repository.remove_member(ctx, member_id)
self.room_repository.add_member(ctx, room_id, member_id)
if not previous_room:
self.member_manager.update_subnet(ctx, member_id=member_id)
self.member_manager.ethernet_vlan_changed(ctx, member_id,
room.vlan)
elif previous_room.vlan != room.vlan:
self.member_manager.ethernet_vlan_changed(ctx, member_id,
room.vlan)
def room_from_member(self, ctx, member_id: int) -> int:
room = self.room_repository.get_from_member(ctx, member_id)
if not room:
raise RoomNotFoundError()
return room.id