def view_all(self): # -> Collection[PlacementDto]:
"""
Fetch a full list of DTOs of all stored objects
:return: a collection of DTOs
"""
return [build_dto(i) for i in self._placements.load_all()]
def view_all(self): # -> Collection[UserDto]:
"""
Fetch a full list of DTOs of all stored objects
:return: a collection of DTOs
"""
return [
build_dto(user)
for user in self._user_repo.load_all()
]
def view(self, domain_id: TDomainId) -> SessionDto:
"""
Fetch a DTO of stored object by the ID specified
:param domain_id: id of object to be fetched
:return: a DTO of stored object
:raises ServiceResolutionError: if the entity with
the specified ID can't be found
"""
return build_dto(self._sessions.load(domain_id))
def view(self, domain_id: TDomainId) -> UserDto:
"""
Fetch a DTO of stored object by the ID specified
:param domain_id: id of object to be fetched
:return: a DTO of stored object
:raises ServiceResolutionError: if the entity with
the specified ID can't be found
"""
resolved = self._resolve_entity(self._user_repo, domain_id)
return build_dto(resolved)
def view_by_user(self, user_id: TDomainId): # -> Collection[SessionDto]
"""
Returns a collection of Sessions (Session DTOs to
be exact) that are associated with the specified
User
:param user_id: an identifier of the User in question
:return: a collection of SessionDto objects
"""
resolved = self._sessions.select_by_user(user_id)
return [build_dto(i) for i in resolved]
def view_by_username(self, username: str) -> UserDto:
"""
Allows to fetch a User (UserDto, to be exact) by
User's username
:param username: username of the User to be fetched
:return: an instance of User DTO
:raises ServiceEntityResolutionError: if the User
with the specified username was not found
"""
resolved = self._user_repo.find_by_username(username)
self._check_resolved(resolved)
return build_dto(resolved)
def view_older_than(self, timestamp: float): # -> Collection[SessionDto]
"""
Allows to fetch all Sessions that was created before
the specified point in time (UNIX time)
:param timestamp: UNIX time, maximum value of the
time_created field
:return: a collection of Sessions (their DTOs, to be
exact) that was created before the specified
point in time
"""
resolved = self._sessions.select_older_than(timestamp)
return [build_dto(i) for i in resolved]
def view(self, domain_id: TDomainId) -> ThingDto:
"""
Fetch a DTO of stored object by the ID specified
:param domain_id: id of object to be fetched
:return: a DTO of stored object
:raises ServiceResolutionError: if the entity with
the specified ID can't be found
"""
thing = self._things.load(domain_id)
if thing is None:
raise ServiceEntityResolutionError()
return build_dto(thing)
def select_by_placement(
self, placement_id: Optional[TDomainId]
): # -> Collection[ThingDto]:
"""
Selects all Things that are physically present in the
specified Placement
:param placement_id: an identifier of the Placement
of interest; or None (null) to fetch all Things
that are not assigned to any Placement yet
:return: a collection of Things that are placed in the
specified Placement
"""
return [
build_dto(i) for i in self._things.select_by_placement(placement_id)
]
def view(self, domain_id: TDomainId) -> PlacementDto:
"""
Fetch a DTO of stored object by the ID specified
:param domain_id: id of object to be fetched
:return: a DTO of stored object
:raises ServiceResolutionError: if the entity with
the specified ID can't be found
"""
placement = self._placements.load(domain_id)
if placement is None:
raise ServiceEntityResolutionError(
"A Placement with the specified ID can't "
"be found: %s" % domain_id)
return build_dto(placement)
def view_by_access_token(self, access_token: str) -> SessionDto:
"""
Allows to determine and fetch a Session which contains
the specified access token
:param access_token: an access token associated with Session
:return: Session DTO
:raises ServiceEntityResolutionError: if there is no
session with the specified access token existing
(access token was revoked or not existing at all)
"""
resolved = self._sessions.find_by_access_token(access_token)
if resolved is None:
raise ServiceEntityResolutionError()
return build_dto(resolved)
def authenticate(self, username: str, password: str) -> UserDto:
"""
Authenticate the User by the specified username-password
combination.
:param username: username of the User to be authenticated
:param password: password of the User to be authenticated
:return: an instance of User (User DTO, to be exact)
which has the specified username-password combination
:raises AuthInvalidUserPasswordCombinationError:
if the specified username-password combination is invalid
"""
resolved = self._user_repo.find_by_username(username)
if resolved is None:
raise AuthInvalidUserPasswordCombinationError()
password_ok = resolved.verify_password(password)
if not password_ok:
raise AuthInvalidUserPasswordCombinationError()
return build_dto(resolved)
