workers-control 0.2.4__tar.gz → 0.2.6__tar.gz

{workers_control-0.2.4/src/workers_control.egg-info → workers_control-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workers-control
-Version: 0.2.4
+Version: 0.2.6
 Summary: A flask app for labour time accounting.
 License-Expression: AGPL-3.0-or-later
 Project-URL: Source, https://github.com/ida-arbeitszeit/workers-control
@@ -15,12 +15,12 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: alembic==1.18.1
 Requires-Dist: email-validator==2.3.0
-Requires-Dist: flask==3.1.2
+Requires-Dist: flask<=3.1.3,>=3.1.2
 Requires-Dist: flask-babel==4.0.0
 Requires-Dist: flask-talisman==1.1.0
 Requires-Dist: flask-login==0.6.3
 Requires-Dist: flask-wtf==1.2.2
-Requires-Dist: matplotlib<=3.11.0,>=3.10.9
+Requires-Dist: matplotlib<=3.11.1,>=3.10.9
 Provides-Extra: profiling
 Requires-Dist: flask_profiler; extra == "profiling"
 Dynamic: license-file

{workers_control-0.2.4 → workers_control-0.2.6}/build_support/backend.py

@@ -1,9 +1,15 @@
+from typing import Any, Dict, Optional
+
 from setuptools import build_meta as _orig
 from setuptools.build_meta import *  # noqa: F403,F401
 
 from build_support import translations
 
 
-def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):  # type: ignore[no-redef]
+def build_wheel(  # type: ignore[no-redef]
+    wheel_directory: str,
+    config_settings: Optional[Dict[str, Any]] = None,
+    metadata_directory: Optional[str] = None,
+) -> str:
     translations.compile_messages()
     return _orig.build_wheel(wheel_directory, config_settings, metadata_directory)

{workers_control-0.2.4 → workers_control-0.2.6}/pyproject.toml

@@ -5,7 +5,7 @@ backend-path = ["."]
 
 [project]
 name = "workers-control"
-version = "0.2.4"
+version = "0.2.6"
 description = "A flask app for labour time accounting."
 license = "AGPL-3.0-or-later"
 requires-python = ">=3.13"
@@ -21,12 +21,12 @@ dependencies = [
     # Pin to exact versions, if possible.
     "alembic==1.18.1",
     "email-validator==2.3.0",
-    "flask==3.1.2",
+    "flask>=3.1.2, <=3.1.3", # different versions in stable/unstable nixpkgs
     "flask-babel==4.0.0",
     "flask-talisman==1.1.0",
     "flask-login==0.6.3",
     "flask-wtf==1.2.2",
-    "matplotlib>=3.10.9, <=3.11.0" # different versions in stable/unstable nixpkgs
+    "matplotlib>=3.10.9, <=3.11.1" # different versions in stable/unstable nixpkgs
 ]
 
 [project.optional-dependencies]
@@ -68,20 +68,14 @@ exclude = '''
 '''
 disable_error_code = "type-abstract"
 explicit_package_bases = true
+disallow_untyped_defs = true
 
 [[tool.mypy.overrides]]
 module = [
-    "src",
-    "dev",
-    "tests"
-]
-allow_untyped_defs = false
-
-[[tool.mypy.overrides]]
-module = [
-    "flask_babel",
-    "flask_login",
-    "flask_wtf",
+    "flask_babel.*",
+    "flask_login.*",
+    "flask_talisman.*",
+    "flask_wtf.*",
     "parameterized.*",
     "wtforms.*",
 ]

{workers_control-0.2.4 → workers_control-0.2.6}/src/workers_control/core/email_notifications.py

@@ -64,7 +64,7 @@ class NameChangeConfirmation:
 
 
 @dataclass
-class CooperationRequestEmail:
+class CollaborationRequestEmail:
     coordinator_email_address: str
     coordinator_name: str
 
@@ -73,7 +73,7 @@ class CooperationRequestEmail:
 class CoordinationTransferRequest:
     candidate_email: str
     candidate_name: str
-    cooperation_name: str
+    collaboration_name: str
     transfer_request: UUID
 
 
@@ -103,7 +103,7 @@ Message: TypeAlias = Union[
     AccountantInvitation,
     AccountantNotificationAboutNewPlan,
     CompanyRegistration,
-    CooperationRequestEmail,
+    CollaborationRequestEmail,
     CoordinationTransferRequest,
     EmailChangeWarning,
     EmailChangeConfirmation,

workers_control-0.2.6/src/workers_control/core/interactors/accept_collaboration.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Optional
+from uuid import UUID
+
+from workers_control.core.datetime_service import DatetimeService
+from workers_control.core.repositories import DatabaseGateway
+
+
+@dataclass
+class AcceptCollaborationRequest:
+    requester_id: UUID
+    plan_id: UUID
+    collaboration_id: UUID
+
+
+@dataclass
+class AcceptCollaborationResponse:
+    class RejectionReason(Exception, Enum):
+        plan_not_found = auto()
+        collaboration_not_found = auto()
+        plan_inactive = auto()
+        plan_has_collaboration = auto()
+        plan_is_public_service = auto()
+        collaboration_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 AcceptCollaborationInteractor:
+    database_gateway: DatabaseGateway
+    datetime_service: DatetimeService
+
+    def execute(
+        self, request: AcceptCollaborationRequest
+    ) -> AcceptCollaborationResponse:
+        try:
+            self._validate_request(request)
+        except AcceptCollaborationResponse.RejectionReason as reason:
+            return AcceptCollaborationResponse(rejection_reason=reason)
+        plan = self.database_gateway.get_plans().with_id(request.plan_id)
+        plan.update().set_collaboration(
+            request.collaboration_id
+        ).set_requested_collaboration(None).perform()
+        return AcceptCollaborationResponse(rejection_reason=None)
+
+    def _validate_request(self, request: AcceptCollaborationRequest) -> None:
+        plan_and_collaboration = (
+            self.database_gateway.get_plans()
+            .with_id(request.plan_id)
+            .joined_with_collaboration()
+            .first()
+        )
+        collaboration_and_coordinator = (
+            self.database_gateway.get_collaborations()
+            .with_id(request.collaboration_id)
+            .joined_with_current_coordinator()
+            .first()
+        )
+        now = self.datetime_service.now()
+        if collaboration_and_coordinator is None:
+            raise AcceptCollaborationResponse.RejectionReason.collaboration_not_found
+        collaboration, coordinator = collaboration_and_coordinator
+        if plan_and_collaboration is None:
+            raise AcceptCollaborationResponse.RejectionReason.plan_not_found
+        plan, current_collaboration = plan_and_collaboration
+        if not plan.is_active_as_of(now):
+            raise AcceptCollaborationResponse.RejectionReason.plan_inactive
+        if current_collaboration:
+            raise AcceptCollaborationResponse.RejectionReason.plan_has_collaboration
+        if plan.is_public_service:
+            raise AcceptCollaborationResponse.RejectionReason.plan_is_public_service
+        if plan.requested_collaboration != collaboration.id:
+            raise AcceptCollaborationResponse.RejectionReason.collaboration_was_not_requested
+        if request.requester_id != coordinator.id:
+            raise AcceptCollaborationResponse.RejectionReason.requester_is_not_coordinator

{workers_control-0.2.4 → workers_control-0.2.6}/src/workers_control/core/interactors/accept_coordination_transfer.py

@@ -4,7 +4,7 @@ from typing import Optional
 from uuid import UUID
 
 from workers_control.core.datetime_service import DatetimeService
-from workers_control.core.records import Cooperation, CoordinationTransferRequest
+from workers_control.core.records import Collaboration, CoordinationTransferRequest
 from workers_control.core.repositories import DatabaseGateway
 
 
@@ -26,7 +26,7 @@ class AcceptCoordinationTransferInteractor:
             accepting_company_is_not_candidate = auto()
 
         rejection_reason: Optional[RejectionReason]
-        cooperation_id: Optional[UUID]
+        collaboration_id: Optional[UUID]
         transfer_request_id: UUID
 
         @property
@@ -35,63 +35,67 @@ class AcceptCoordinationTransferInteractor:
 
     def accept_coordination_transfer(self, request: Request) -> Response:
         try:
-            transfer_request, cooperation = self._validate_request(request)
+            transfer_request, collaboration = self._validate_request(request)
         except self.Response.RejectionReason as reason:
             return self.Response(
                 rejection_reason=reason,
-                cooperation_id=None,
+                collaboration_id=None,
                 transfer_request_id=request.transfer_request_id,
             )
-        cooperation_id = self._create_new_coordination_tenure(
-            transfer_request, cooperation
+        collaboration_id = self._create_new_coordination_tenure(
+            transfer_request, collaboration
         )
         return self.Response(
             rejection_reason=None,
-            cooperation_id=cooperation_id,
+            collaboration_id=collaboration_id,
             transfer_request_id=request.transfer_request_id,
         )
 
     def _validate_request(
         self, request: Request
-    ) -> tuple[CoordinationTransferRequest, Cooperation]:
+    ) -> tuple[CoordinationTransferRequest, Collaboration]:
         result = (
             self.database_gateway.get_coordination_transfer_requests()
             .with_id(request.transfer_request_id)
-            .joined_with_cooperation()
+            .joined_with_collaboration()
             .first()
         )
         if result is None:
             raise self.Response.RejectionReason.transfer_request_not_found
-        transfer_request, cooperation = result
+        transfer_request, collaboration = 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
+        if self._collaboration_has_a_coordination_tenure_starting_after_transfer_request(
+            collaboration=collaboration, transfer_request=transfer_request
         ):
             raise self.Response.RejectionReason.transfer_request_closed
-        return transfer_request, cooperation
+        return transfer_request, collaboration
 
     def _create_new_coordination_tenure(
-        self, transfer_request: CoordinationTransferRequest, cooperation: Cooperation
+        self,
+        transfer_request: CoordinationTransferRequest,
+        collaboration: Collaboration,
     ) -> UUID:
         new_tenure = self.database_gateway.create_coordination_tenure(
             company=transfer_request.candidate,
-            cooperation=cooperation.id,
+            collaboration=collaboration.id,
             start_date=self.datetime_service.now(),
         )
-        return new_tenure.cooperation
+        return new_tenure.collaboration
 
-    def _cooperation_has_a_coordination_tenure_starting_after_transfer_request(
-        self, transfer_request: CoordinationTransferRequest, cooperation: Cooperation
+    def _collaboration_has_a_coordination_tenure_starting_after_transfer_request(
+        self,
+        transfer_request: CoordinationTransferRequest,
+        collaboration: Collaboration,
     ) -> bool:
-        latest_coordination_tenure_of_cooperation = (
+        latest_coordination_tenure_of_collaboration = (
             self.database_gateway.get_coordination_tenures()
-            .of_cooperation(cooperation.id)
+            .of_collaboration(collaboration.id)
             .ordered_by_start_date(ascending=False)
             .first()
         )
-        assert latest_coordination_tenure_of_cooperation
+        assert latest_coordination_tenure_of_collaboration
         return (
-            latest_coordination_tenure_of_cooperation.start_date
+            latest_coordination_tenure_of_collaboration.start_date
             > transfer_request.request_date
         )

workers_control-0.2.4/src/workers_control/core/interactors/cancel_cooperation_solicitation.py → workers_control-0.2.6/src/workers_control/core/interactors/cancel_collaboration_solicitation.py

@@ -5,23 +5,23 @@ from workers_control.core.repositories import DatabaseGateway
 
 
 @dataclass
-class CancelCooperationSolicitationRequest:
+class CancelCollaborationSolicitationRequest:
     requester_id: UUID
     plan_id: UUID
 
 
 @dataclass
-class CancelCooperationSolicitationInteractor:
+class CancelCollaborationSolicitationInteractor:
     database_gateway: DatabaseGateway
 
-    def execute(self, request: CancelCooperationSolicitationRequest) -> bool:
+    def execute(self, request: CancelCollaborationSolicitationRequest) -> bool:
         plans_changed_count = (
             self.database_gateway.get_plans()
             .with_id(request.plan_id)
             .planned_by(request.requester_id)
-            .that_request_cooperation_with_coordinator()
+            .that_request_collaboration_with_coordinator()
             .update()
-            .set_requested_cooperation(None)
+            .set_requested_collaboration(None)
             .perform()
         )
         return bool(plans_changed_count)

workers_control-0.2.4/src/workers_control/core/interactors/create_cooperation.py → workers_control-0.2.6/src/workers_control/core/interactors/create_collaboration.py

@@ -9,20 +9,20 @@ from workers_control.core.repositories import DatabaseGateway
 
 
 @dataclass
-class CreateCooperationRequest:
+class CreateCollaborationRequest:
     coordinator_id: UUID
     name: str
     definition: str
 
 
 @dataclass
-class CreateCooperationResponse:
+class CreateCollaborationResponse:
     class RejectionReason(Exception, Enum):
         coordinator_not_found = auto()
-        cooperation_with_name_exists = auto()
+        collaboration_with_name_exists = auto()
 
     rejection_reason: Optional[RejectionReason]
-    cooperation_id: Optional[UUID]
+    collaboration_id: Optional[UUID]
 
     @property
     def is_rejected(self) -> bool:
@@ -30,19 +30,21 @@ class CreateCooperationResponse:
 
 
 @dataclass
-class CreateCooperationInteractor:
+class CreateCollaborationInteractor:
     datetime_service: DatetimeService
     database_gateway: DatabaseGateway
 
-    def execute(self, request: CreateCooperationRequest) -> CreateCooperationResponse:
+    def execute(
+        self, request: CreateCollaborationRequest
+    ) -> CreateCollaborationResponse:
         try:
             coordinator = self._validate_request(request)
-        except CreateCooperationResponse.RejectionReason as reason:
-            return CreateCooperationResponse(
-                rejection_reason=reason, cooperation_id=None
+        except CreateCollaborationResponse.RejectionReason as reason:
+            return CreateCollaborationResponse(
+                rejection_reason=reason, collaboration_id=None
             )
         account = self.database_gateway.create_account()
-        cooperation = self.database_gateway.create_cooperation(
+        collaboration = self.database_gateway.create_collaboration(
             self.datetime_service.now(),
             request.name,
             request.definition,
@@ -50,26 +52,26 @@ class CreateCooperationInteractor:
         )
         self.database_gateway.create_coordination_tenure(
             company=coordinator.id,
-            cooperation=cooperation.id,
+            collaboration=collaboration.id,
             start_date=self.datetime_service.now(),
         )
-        return CreateCooperationResponse(
-            rejection_reason=None, cooperation_id=cooperation.id
+        return CreateCollaborationResponse(
+            rejection_reason=None, collaboration_id=collaboration.id
         )
 
-    def _validate_request(self, request: CreateCooperationRequest) -> Company:
+    def _validate_request(self, request: CreateCollaborationRequest) -> Company:
         coordinator = (
             self.database_gateway.get_companies()
             .with_id(request.coordinator_id)
             .first()
         )
-        coops_with_requested_name = (
-            self.database_gateway.get_cooperations().with_name_ignoring_case(
+        collabs_with_requested_name = (
+            self.database_gateway.get_collaborations().with_name_ignoring_case(
                 request.name
             )
         )
         if coordinator is None:
-            raise CreateCooperationResponse.RejectionReason.coordinator_not_found
-        if coops_with_requested_name:
-            raise CreateCooperationResponse.RejectionReason.cooperation_with_name_exists
+            raise CreateCollaborationResponse.RejectionReason.coordinator_not_found
+        if collabs_with_requested_name:
+            raise CreateCollaborationResponse.RejectionReason.collaboration_with_name_exists
         return coordinator

workers_control-0.2.6/src/workers_control/core/interactors/deny_collaboration.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Optional
+from uuid import UUID
+
+from workers_control.core.datetime_service import DatetimeService
+from workers_control.core.repositories import DatabaseGateway
+
+
+@dataclass
+class DenyCollaborationRequest:
+    requester_id: UUID
+    plan_id: UUID
+    collaboration_id: UUID
+
+
+@dataclass
+class DenyCollaborationResponse:
+    class RejectionReason(Exception, Enum):
+        plan_not_found = auto()
+        collaboration_not_found = auto()
+        collaboration_was_not_requested = auto()
+        requester_is_not_coordinator = auto()
+        plan_is_inactive = auto()
+
+    rejection_reason: Optional[RejectionReason]
+
+    @property
+    def is_rejected(self) -> bool:
+        return self.rejection_reason is not None
+
+
+@dataclass
+class DenyCollaborationInteractor:
+    database_gateway: DatabaseGateway
+    datetime_service: DatetimeService
+
+    def execute(self, request: DenyCollaborationRequest) -> DenyCollaborationResponse:
+        try:
+            self._validate_request(request)
+        except DenyCollaborationResponse.RejectionReason as reason:
+            return DenyCollaborationResponse(rejection_reason=reason)
+
+        self.database_gateway.get_plans().with_id(
+            request.plan_id
+        ).update().set_requested_collaboration(None).perform()
+        return DenyCollaborationResponse(rejection_reason=None)
+
+    def _validate_request(self, request: DenyCollaborationRequest) -> None:
+        plan = self.database_gateway.get_plans().with_id(request.plan_id).first()
+        now = self.datetime_service.now()
+        collaboration_and_coordinator = (
+            self.database_gateway.get_collaborations()
+            .with_id(request.collaboration_id)
+            .joined_with_current_coordinator()
+            .first()
+        )
+        if not collaboration_and_coordinator:
+            raise DenyCollaborationResponse.RejectionReason.collaboration_not_found
+        collaboration, coordinator = collaboration_and_coordinator
+        if plan is None:
+            raise DenyCollaborationResponse.RejectionReason.plan_not_found
+        if not plan.is_active_as_of(now):
+            raise DenyCollaborationResponse.RejectionReason.plan_is_inactive
+        if plan.requested_collaboration != collaboration.id:
+            raise DenyCollaborationResponse.RejectionReason.collaboration_was_not_requested
+        if request.requester_id != coordinator.id:
+            raise DenyCollaborationResponse.RejectionReason.requester_is_not_coordinator

workers_control-0.2.6/src/workers_control/core/interactors/end_collaboration.py

@@ -0,0 +1,73 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Optional
+from uuid import UUID
+
+from workers_control.core.repositories import DatabaseGateway
+
+
+@dataclass
+class EndCollaborationRequest:
+    requester_id: UUID
+    plan_id: UUID
+    collaboration_id: UUID
+
+
+@dataclass
+class EndCollaborationResponse:
+    class RejectionReason(Exception, Enum):
+        plan_not_found = auto()
+        collaboration_not_found = auto()
+        plan_has_no_collaboration = auto()
+        requester_is_not_authorized = auto()
+
+    rejection_reason: Optional[RejectionReason]
+
+    @property
+    def is_rejected(self) -> bool:
+        return self.rejection_reason is not None
+
+
+@dataclass
+class EndCollaborationInteractor:
+    database_gateway: DatabaseGateway
+
+    def execute(self, request: EndCollaborationRequest) -> EndCollaborationResponse:
+        try:
+            self._validate_request(request)
+        except EndCollaborationResponse.RejectionReason as reason:
+            return EndCollaborationResponse(rejection_reason=reason)
+        assert (
+            self.database_gateway.get_plans()
+            .with_id(request.plan_id)
+            .update()
+            .set_collaboration(None)
+            .perform()
+        )
+        return EndCollaborationResponse(rejection_reason=None)
+
+    def _validate_request(self, request: EndCollaborationRequest) -> None:
+        plan_and_collaboration = (
+            self.database_gateway.get_plans()
+            .with_id(request.plan_id)
+            .joined_with_collaboration()
+            .first()
+        )
+        collaboration_and_coordinator = (
+            self.database_gateway.get_collaborations()
+            .with_id(request.collaboration_id)
+            .joined_with_current_coordinator()
+            .first()
+        )
+        if not collaboration_and_coordinator:
+            raise EndCollaborationResponse.RejectionReason.collaboration_not_found
+        if plan_and_collaboration is None:
+            raise EndCollaborationResponse.RejectionReason.plan_not_found
+        plan, current_collaboration = plan_and_collaboration
+        if not current_collaboration:
+            raise EndCollaborationResponse.RejectionReason.plan_has_no_collaboration
+        coordinator = collaboration_and_coordinator[1]
+        if (request.requester_id != coordinator.id) and (
+            request.requester_id != plan.planner
+        ):
+            raise EndCollaborationResponse.RejectionReason.requester_is_not_authorized

workers_control-0.2.4/src/workers_control/core/interactors/get_coop_summary.py → workers_control-0.2.6/src/workers_control/core/interactors/get_collab_summary.py

@@ -10,9 +10,9 @@ from workers_control.core.services.price_calculator import PriceCalculator
 
 
 @dataclass
-class GetCoopSummaryRequest:
+class GetCollabSummaryRequest:
     requester_id: UUID
-    coop_id: UUID
+    collab_id: UUID
 
 
 @dataclass
@@ -26,50 +26,50 @@ class AssociatedPlan:
 
 
 @dataclass
-class GetCoopSummaryResponse:
+class GetCollabSummaryResponse:
     requester_is_coordinator: bool
-    coop_id: UUID
-    coop_name: str
-    coop_definition: str
+    collab_id: UUID
+    collab_name: str
+    collab_definition: str
     current_coordinator: UUID
     current_coordinator_name: str
-    coop_price: Optional[Decimal]
+    collab_price: Optional[Decimal]
     plans: List[AssociatedPlan]
 
 
 @dataclass
-class GetCoopSummaryInteractor:
+class GetCollabSummaryInteractor:
     database_gateway: DatabaseGateway
     price_calculator: PriceCalculator
     datetime_service: DatetimeService
 
     def execute(
-        self, request: GetCoopSummaryRequest
-    ) -> Optional[GetCoopSummaryResponse]:
-        coop_and_coordinator = (
-            self.database_gateway.get_cooperations()
-            .with_id(request.coop_id)
+        self, request: GetCollabSummaryRequest
+    ) -> Optional[GetCollabSummaryResponse]:
+        collab_and_coordinator = (
+            self.database_gateway.get_collaborations()
+            .with_id(request.collab_id)
             .joined_with_current_coordinator()
             .first()
         )
-        if coop_and_coordinator is None:
+        if collab_and_coordinator is None:
             return None
-        coop, coordinator = coop_and_coordinator
+        collab, coordinator = collab_and_coordinator
         now = self.datetime_service.now()
         plan_result = (
             self.database_gateway.get_plans()
-            .that_are_part_of_cooperation(request.coop_id)
+            .that_are_part_of_collaboration(request.collab_id)
             .that_will_expire_after(now)
         )
         plans = list(plan_result)
-        return GetCoopSummaryResponse(
+        return GetCollabSummaryResponse(
             requester_is_coordinator=coordinator.id == request.requester_id,
-            coop_id=coop.id,
-            coop_name=coop.name,
-            coop_definition=coop.definition,
+            collab_id=collab.id,
+            collab_name=collab.name,
+            collab_definition=collab.definition,
             current_coordinator=coordinator.id,
             current_coordinator_name=coordinator.name,
-            coop_price=self._get_cooperative_price(plans),
+            collab_price=self._get_collaborative_price(plans),
             plans=self._get_associated_plans(plans, request.requester_id),
         )
 
@@ -78,7 +78,7 @@ class GetCoopSummaryInteractor:
         assert planner
         return planner.name
 
-    def _get_cooperative_price(self, plans: list[Plan]) -> Optional[Decimal]:
+    def _get_collaborative_price(self, plans: list[Plan]) -> Optional[Decimal]:
         if not plans:
             return None
         return self.price_calculator.calculate_price(plans[0].id)