workers-control 0.1.1__py3-none-any.whl

arbeitszeit/accountant_notifications.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from uuid import UUID
+
+from arbeitszeit.email_notifications import (
+    AccountantNotificationAboutNewPlan,
+    EmailSender,
+)
+from arbeitszeit.repositories import DatabaseGateway
+
+
+@dataclass
+class AccountantNotifier:
+    email_sender: EmailSender
+    database: DatabaseGateway
+
+    def notify_all_accountants_about_new_plan(
+        self, product_name: str, plan_id: UUID
+    ) -> None:
+        for (
+            accountant,
+            email,
+        ) in self.database.get_accountants().joined_with_email_address():
+            self.email_sender.send_email(
+                AccountantNotificationAboutNewPlan(
+                    product_name=product_name,
+                    plan_id=plan_id,
+                    accountant_name=accountant.name,
+                    accountant_email_address=email.address,
+                )
+            )

arbeitszeit/anonymization.py

@@ -0,0 +1,52 @@
+"""
+Sentinels to represent anonymized values.
+"""
+
+from __future__ import annotations
+
+from typing import Final, TypeAlias
+from uuid import UUID
+
+
+class AnonymizedUUID:
+    """Marker class for anonymized UUIDs.
+
+    Prefer using the singleton instance ANONYMIZED_UUID instead of creating
+    new instances. Identity checks ("is") are the recommended way to detect
+    anonymized values.
+    """
+
+    __slots__: tuple[str, ...] = ()
+
+    def __repr__(self) -> str:
+        return "<ANONYMIZED_UUID>"
+
+    def __bool__(self) -> bool:  # pragma: no cover - defensive
+        raise TypeError("AnonymizedUUID cannot be used in a boolean context")
+
+
+class AnonymizedStr:
+    """Marker class for anonymized strings.
+
+    Prefer using the singleton instance ANONYMIZED_STR instead of creating
+    new instances. Identity checks ("is") are the recommended way to detect
+    anonymized values.
+    """
+
+    __slots__: tuple[str, ...] = ()
+
+    def __repr__(self) -> str:
+        return "<ANONYMIZED_STR>"
+
+    def __bool__(self) -> bool:  # pragma: no cover - defensive
+        raise TypeError("AnonymizedStr cannot be used in a boolean context")
+
+
+# Singleton sentinel instances (preferred values to use and compare against)
+ANONYMIZED_UUID: Final[AnonymizedUUID] = AnonymizedUUID()
+ANONYMIZED_STR: Final[AnonymizedStr] = AnonymizedStr()
+
+
+# Helpful type aliases
+MaybeAnonymizedUUID: TypeAlias = UUID | AnonymizedUUID
+MaybeAnonymizedStr: TypeAlias = str | AnonymizedStr

arbeitszeit/control_thresholds.py

@@ -0,0 +1,9 @@
+from typing import Protocol
+
+
+class ControlThresholds(Protocol):
+    def get_allowed_overdraw_of_member_account(self) -> int | None:
+        """Return the allowed overdraw limit in hours. None means unlimited overdraw."""
+        ...
+
+    def get_acceptable_relative_account_deviation(self) -> int: ...

arbeitszeit/datetime_service.py

@@ -0,0 +1,6 @@
+from datetime import datetime
+from typing import Protocol
+
+
+class DatetimeService(Protocol):
+    def now(self) -> datetime: ...

arbeitszeit/decimal.py

@@ -0,0 +1,7 @@
+import functools
+from decimal import Decimal
+from typing import Iterable
+
+
+def decimal_sum(iterable: Iterable[Decimal]) -> Decimal:
+    return functools.reduce(lambda x, y: x + y, iterable, Decimal(0))

arbeitszeit/email.py

@@ -0,0 +1,8 @@
+def is_possibly_an_email_address(text: str) -> bool:
+    return (
+        "@" in text
+        and not text.startswith("@")
+        and not text.endswith("@")
+        and not text.startswith(" ")
+        and not text.endswith(" ")
+    )

arbeitszeit/email_notifications.py

@@ -0,0 +1,117 @@
+"""This module contains all possible types of email notifications that
+the workers control app can issue and the interface by which the interactors
+request those notifications to be sent.
+"""
+
+from dataclasses import dataclass
+from typing import Protocol, Type, TypeAlias, Union, get_args
+from uuid import UUID
+
+
+@dataclass
+class MemberRegistration:
+    email_address: str
+
+
+@dataclass
+class CompanyRegistration:
+    email_address: str
+
+
+@dataclass
+class AccountantNotificationAboutNewPlan:
+    product_name: str
+    plan_id: UUID
+    accountant_name: str
+    accountant_email_address: str
+
+
+@dataclass
+class AccountantInvitation:
+    email_address: str
+
+
+@dataclass
+class WorkerInvitation:
+    worker_email: str
+    invite: UUID
+
+
+@dataclass
+class WorkerRemovalNotification:
+    worker_email: str
+    worker_name: str
+    worker_id: UUID
+    company_email: str
+    company_name: str
+
+
+@dataclass
+class EmailChangeWarning:
+    old_email_address: str
+
+
+@dataclass
+class EmailChangeConfirmation:
+    old_email_address: str
+    new_email_address: str
+
+
+@dataclass
+class CooperationRequestEmail:
+    coordinator_email_address: str
+    coordinator_name: str
+
+
+@dataclass
+class CoordinationTransferRequest:
+    candidate_email: str
+    candidate_name: str
+    cooperation_name: str
+    transfer_request: UUID
+
+
+@dataclass
+class ResetPasswordRequest:
+    email_address: str
+    reset_token: str
+
+
+@dataclass
+class ResetPasswordConfirmation:
+    email_address: str
+
+
+@dataclass
+class RejectedPlanNotification:
+    planner_email_address: str
+    planning_company_name: str
+    plan_id: UUID
+    product_name: str
+
+
+# This type definition can be used by implementations of the
+# EmailSender protocol for static type checking purposes. Keep this
+# list alphabetically sorted.
+Message: TypeAlias = Union[
+    AccountantInvitation,
+    AccountantNotificationAboutNewPlan,
+    CompanyRegistration,
+    CooperationRequestEmail,
+    CoordinationTransferRequest,
+    EmailChangeWarning,
+    EmailChangeConfirmation,
+    MemberRegistration,
+    RejectedPlanNotification,
+    ResetPasswordConfirmation,
+    ResetPasswordRequest,
+    WorkerInvitation,
+    WorkerRemovalNotification,
+]
+# Implementations can rely on this set to contain all possible message
+# types.
+all_message_types: set[Type] = set(get_args(Message))
+
+
+class EmailSender(Protocol):
+    def send_email(self, message: Message) -> None: ...

arbeitszeit/injector.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import inspect
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    Iterable,
+    List,
+    Optional,
+    Protocol,
+    Type,
+    TypeVar,
+    get_type_hints,
+)
+
+S = TypeVar("S")
+T = TypeVar("T")
+T_cov = TypeVar("T_cov", covariant=True)
+CallableT = TypeVar("CallableT", bound=Callable)
+TypeT = TypeVar("TypeT", bound=Type)
+ProviderFunction = Callable[[Type[T]], "Provider[T]"]
+
+
+class Injector:
+    def __init__(self, modules: List[Module]) -> None:
+        class _RecursionModule(Module):
+            def configure(module_self, binder: Binder) -> None:
+                super().configure(binder)
+                binder[Injector] = InstanceProvider(self)
+
+        recursion_module = _RecursionModule()
+
+        self.binder: Binder = Binder(Injector.default_provider)
+        recursion_module.configure(self.binder)
+        for module in modules:
+            module.configure(self.binder)
+
+    @staticmethod
+    def default_provider(cls: Type[T]) -> ClassProvider[T]:
+        return ClassProvider(cls)
+
+    def get(self, cls: Type[T]) -> T:
+        provider = self.binder.get(cls)
+        return provider.provide(self.binder)
+
+    def call_with_injection(
+        self,
+        f: Callable[..., T],
+        args: Optional[Iterable[Any]] = None,
+        kwargs: Optional[Dict[str, Any]] = None,
+    ) -> T:
+        if args is None:
+            args = []
+        if kwargs is None:
+            kwargs = {}
+        signature = inspect.signature(f)
+        bound_arguments = signature.bind_partial(*args)
+        dependencies = dict()
+        for key, value in get_type_hints(f).items():
+            if (
+                key != "return"
+                and key not in bound_arguments.arguments
+                and key not in kwargs
+            ):
+                dependencies[key] = self.get(value)
+        dependencies.update(kwargs)
+        return f(*bound_arguments.arguments.values(), **dependencies)
+
+    def create_object(self, cls: Type[T], additional_kwargs: Dict[str, Any]) -> T:
+        return self.call_with_injection(cls, kwargs=additional_kwargs)
+
+
+class Binder:
+    def __init__(self, default: ProviderFunction) -> None:
+        self._default = default
+        self._bindings: Dict[Type, Provider] = dict()
+        self._instances: Dict[Type, Any] = dict()
+
+    def __getitem__(self, key: Type[T]) -> Provider[T]:
+        return self._bindings[key]
+
+    def __setitem__(self, key: Type[T], value: Provider[T]) -> None:
+        self._bindings[key] = value
+
+    def __contains__(self, key: Type[T]) -> bool:
+        return key in self._bindings
+
+    def bind(self, cls: Type[T], to: Provider[T]) -> None:
+        self._bindings[cls] = to
+
+    def get(self, cls: Type[T]) -> Provider[T]:
+        if cls not in self:
+            return self._default(cls)
+        else:
+            return self[cls]
+
+
+class Provider(Protocol, Generic[T_cov]):
+    def provide(self, binder: Binder) -> T_cov: ...
+
+
+class AliasProvider(Generic[T]):
+    """This provider provides instances by simply refering to another
+    class.  This can be useful when specifying the concret
+    implementation of an abstract base class (ABC) or a Protocol.
+    """
+
+    def __init__(self, cls: Type[T]) -> None:
+        self.cls = cls
+
+    def provide(self, binder: Binder) -> T:
+        provider = binder.get(self.cls)
+        return provider.provide(binder)
+
+
+class InstanceProvider(Provider[T]):
+    """Provide an instance of of a class by specifying the concrete
+    instance in the provider.
+    """
+
+    def __init__(self, instance: T) -> None:
+        self.instance = instance
+
+    def provide(self, binder: Binder) -> T:
+        return self.instance
+
+
+class ClassProvider(Provider[T]):
+    """Provide an instance of a type by calling its constructor
+    (__init__ method) and providing its arguments from dependency
+    injection.
+
+    This provider usually doen't need to be specified directly since
+    it is assumed to be the default in case no other provider was
+    specified.
+    """
+
+    def __init__(self, cls: Type[T]) -> None:
+        self.cls = cls
+
+    def provide(self, binder: Binder) -> T:
+        if self.is_singleton:
+            instance = binder._instances.get(self.cls)
+            if instance is not None:
+                return instance
+        args = get_type_hints(self.cls.__init__)
+        kwargs = dict()
+        for name, annotation in args.items():
+            if name == "return":
+                continue
+            kwargs[name] = binder.get(annotation).provide(binder)
+        try:
+            instance = self.cls(**kwargs)
+        except TypeError as e:
+            raise TypeError(f"Could not create instance of class {self.cls}") from e
+        if self.is_singleton:
+            binder._instances[self.cls] = instance
+        return instance
+
+    @property
+    def is_singleton(self) -> bool:
+        return getattr(self.cls, "_injection_singleton", False)
+
+
+class CallableProvider(Provider[T]):
+    """Provide an instance by calling a function.  The arguments to
+    the function will be provide by dependency injection.
+    """
+
+    def __init__(self, f: Callable[..., T], is_singleton: bool = False) -> None:
+        self.f = f
+        self._is_singleton = is_singleton
+
+    def provide(self, binder: Binder) -> T:
+        if self._is_singleton:
+            instance = binder._instances.get(self.return_type)
+            if instance:
+                return instance
+        args = get_type_hints(self.f)
+        kwargs = dict()
+        for name, annotation in args.items():
+            if name == "return":
+                continue
+            kwargs[name] = binder.get(annotation).provide(binder)
+        instance = self.f(**kwargs)
+        if self._is_singleton:
+            binder._instances[self.return_type] = instance
+        return instance
+
+    @property
+    def return_type(self) -> Type:
+        hints = get_type_hints(self.f)
+        return hints["return"]
+
+
+class Module:
+    def configure(self, binder: Binder) -> None:
+        pass
+
+
+def singleton(cls: TypeT) -> TypeT:
+    cls._injection_singleton = True
+    return cls

arbeitszeit/interactors/accept_cooperation.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Optional
+from uuid import UUID
+
+from arbeitszeit.datetime_service import DatetimeService
+from arbeitszeit.repositories import DatabaseGateway
+
+
+@dataclass
+class AcceptCooperationRequest:
+    requester_id: UUID
+    plan_id: UUID
+    cooperation_id: UUID
+
+
+@dataclass
+class AcceptCooperationResponse:
+    class RejectionReason(Exception, Enum):
+        plan_not_found = auto()
+        cooperation_not_found = auto()
+        plan_inactive = auto()
+        plan_has_cooperation = auto()
+        plan_is_public_service = auto()
+        cooperation_was_not_requested = auto()
+        requester_is_not_coordinator = auto()
+
+    rejection_reason: Optional[RejectionReason]
+
+    @property
+    def is_rejected(self) -> bool:
+        return self.rejection_reason is not None
+
+
+@dataclass
+class AcceptCooperationInteractor:
+    database_gateway: DatabaseGateway
+    datetime_service: DatetimeService
+
+    def execute(self, request: AcceptCooperationRequest) -> AcceptCooperationResponse:
+        try:
+            self._validate_request(request)
+        except AcceptCooperationResponse.RejectionReason as reason:
+            return AcceptCooperationResponse(rejection_reason=reason)
+        plan = self.database_gateway.get_plans().with_id(request.plan_id)
+        plan.update().set_cooperation(request.cooperation_id).set_requested_cooperation(
+            None
+        ).perform()
+        return AcceptCooperationResponse(rejection_reason=None)
+
+    def _validate_request(self, request: AcceptCooperationRequest) -> None:
+        plan_and_cooperation = (
+            self.database_gateway.get_plans()
+            .with_id(request.plan_id)
+            .joined_with_cooperation()
+            .first()
+        )
+        cooperation_and_coordinator = (
+            self.database_gateway.get_cooperations()
+            .with_id(request.cooperation_id)
+            .joined_with_current_coordinator()
+            .first()
+        )
+        now = self.datetime_service.now()
+        if cooperation_and_coordinator is None:
+            raise AcceptCooperationResponse.RejectionReason.cooperation_not_found
+        cooperation, coordinator = cooperation_and_coordinator
+        if plan_and_cooperation is None:
+            raise AcceptCooperationResponse.RejectionReason.plan_not_found
+        plan, current_cooperation = plan_and_cooperation
+        if not plan.is_active_as_of(now):
+            raise AcceptCooperationResponse.RejectionReason.plan_inactive
+        if current_cooperation:
+            raise AcceptCooperationResponse.RejectionReason.plan_has_cooperation
+        if plan.is_public_service:
+            raise AcceptCooperationResponse.RejectionReason.plan_is_public_service
+        if plan.requested_cooperation != cooperation.id:
+            raise AcceptCooperationResponse.RejectionReason.cooperation_was_not_requested
+        if request.requester_id != coordinator.id:
+            raise AcceptCooperationResponse.RejectionReason.requester_is_not_coordinator

arbeitszeit/interactors/accept_coordination_transfer.py

@@ -0,0 +1,97 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Optional
+from uuid import UUID
+
+from arbeitszeit.datetime_service import DatetimeService
+from arbeitszeit.records import Cooperation, CoordinationTransferRequest
+from arbeitszeit.repositories import DatabaseGateway
+
+
+@dataclass
+class AcceptCoordinationTransferInteractor:
+    database_gateway: DatabaseGateway
+    datetime_service: DatetimeService
+
+    @dataclass
+    class Request:
+        transfer_request_id: UUID
+        accepting_company: UUID
+
+    @dataclass
+    class Response:
+        class RejectionReason(Exception, Enum):
+            transfer_request_not_found = auto()
+            transfer_request_closed = auto()
+            accepting_company_is_not_candidate = auto()
+
+        rejection_reason: Optional[RejectionReason]
+        cooperation_id: Optional[UUID]
+        transfer_request_id: UUID
+
+        @property
+        def is_rejected(self) -> bool:
+            return self.rejection_reason is not None
+
+    def accept_coordination_transfer(self, request: Request) -> Response:
+        try:
+            transfer_request, cooperation = self._validate_request(request)
+        except self.Response.RejectionReason as reason:
+            return self.Response(
+                rejection_reason=reason,
+                cooperation_id=None,
+                transfer_request_id=request.transfer_request_id,
+            )
+        cooperation_id = self._create_new_coordination_tenure(
+            transfer_request, cooperation
+        )
+        return self.Response(
+            rejection_reason=None,
+            cooperation_id=cooperation_id,
+            transfer_request_id=request.transfer_request_id,
+        )
+
+    def _validate_request(
+        self, request: Request
+    ) -> tuple[CoordinationTransferRequest, Cooperation]:
+        result = (
+            self.database_gateway.get_coordination_transfer_requests()
+            .with_id(request.transfer_request_id)
+            .joined_with_cooperation()
+            .first()
+        )
+        if result is None:
+            raise self.Response.RejectionReason.transfer_request_not_found
+        transfer_request, cooperation = result
+        if transfer_request.candidate != request.accepting_company:
+            raise self.Response.RejectionReason.accepting_company_is_not_candidate
+        if self._cooperation_has_a_coordination_tenure_starting_after_transfer_request(
+            cooperation=cooperation, transfer_request=transfer_request
+        ):
+            raise self.Response.RejectionReason.transfer_request_closed
+        return transfer_request, cooperation
+
+    def _create_new_coordination_tenure(
+        self, transfer_request: CoordinationTransferRequest, cooperation: Cooperation
+    ) -> UUID:
+        new_tenure = self.database_gateway.create_coordination_tenure(
+            company=transfer_request.candidate,
+            cooperation=cooperation.id,
+            start_date=self.datetime_service.now(),
+        )
+        return new_tenure.cooperation
+
+    def _cooperation_has_a_coordination_tenure_starting_after_transfer_request(
+        self, transfer_request: CoordinationTransferRequest, cooperation: Cooperation
+    ) -> bool:
+        latest_coordination_tenure_of_cooperation = (
+            self.database_gateway.get_coordination_tenures()
+            .of_cooperation(cooperation.id)
+            .ordered_by_start_date(ascending=False)
+            .first()
+        )
+        assert latest_coordination_tenure_of_cooperation
+        return (
+            latest_coordination_tenure_of_cooperation.start_date
+            > transfer_request.request_date
+        )

arbeitszeit/interactors/answer_company_work_invite.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Optional
+from uuid import UUID
+
+from arbeitszeit.repositories import DatabaseGateway
+
+
+@dataclass
+class AnswerCompanyWorkInviteRequest:
+    is_accepted: bool
+    invite_id: UUID
+    user: UUID
+
+
+@dataclass
+class AnswerCompanyWorkInviteResponse:
+    class Failure(Exception, Enum):
+        invite_not_found = auto()
+        member_was_not_invited = auto()
+
+    is_success: bool
+    is_accepted: bool
+    company_name: Optional[str]
+    failure_reason: Optional[Failure]
+
+
+@dataclass
+class AnswerCompanyWorkInviteInteractor:
+    database_gateway: DatabaseGateway
+
+    def execute(
+        self, request: AnswerCompanyWorkInviteRequest
+    ) -> AnswerCompanyWorkInviteResponse:
+        invite = (
+            self.database_gateway.get_company_work_invites()
+            .with_id(request.invite_id)
+            .first()
+        )
+        if invite is None:
+            return self._create_failure_response(
+                reason=AnswerCompanyWorkInviteResponse.Failure.invite_not_found
+            )
+        if invite.member != request.user:
+            return self._create_failure_response(
+                reason=AnswerCompanyWorkInviteResponse.Failure.member_was_not_invited
+            )
+        elif request.is_accepted:
+            self.database_gateway.get_companies().with_id(invite.company).add_worker(
+                invite.member
+            )
+            self.database_gateway.get_company_work_invites().with_id(
+                request.invite_id
+            ).delete()
+        elif not request.is_accepted:
+            self.database_gateway.get_company_work_invites().with_id(
+                request.invite_id
+            ).delete()
+        company = self.database_gateway.get_companies().with_id(invite.company).first()
+        assert company
+        return AnswerCompanyWorkInviteResponse(
+            is_success=True,
+            is_accepted=request.is_accepted,
+            company_name=company.name,
+            failure_reason=None,
+        )
+
+    def _create_failure_response(
+        self, reason: AnswerCompanyWorkInviteResponse.Failure
+    ) -> AnswerCompanyWorkInviteResponse:
+        return AnswerCompanyWorkInviteResponse(
+            is_success=False,
+            is_accepted=False,
+            company_name=None,
+            failure_reason=reason,
+        )