eetlijst-python 0.0.1__py3-none-any.whl

eetlijst/services/groups/groups.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+
+from eetlijst.generated import GraphQlClient, order_by
+from eetlijst.generated.input_types import (
+    String_comparison_exp,
+    eetschema_group_order_by,
+    eetschema_group_set_input,
+    eetschema_users_in_group_bool_exp,
+    eetschema_users_in_group_order_by,
+)
+
+from eetlijst.services.group_list import GroupList
+from eetlijst.services.groups.transformers import (
+    GroupResult,
+    transform_all_groups,
+    transform_create_group,
+    transform_get_group,
+    transform_update_group,
+)
+
+if TYPE_CHECKING:
+    from eetlijst.services.group_users import GroupUsers
+
+
+@dataclass
+class Groups:
+    _client: GraphQlClient
+    users: GroupUsers
+    list: GroupList
+
+    async def get(
+        self,
+        group_id: str,
+        include_users: bool = False,
+    ) -> GroupResult:
+        result = await self._client.get_group(group_id=group_id)
+        return transform_get_group(result, include_users=include_users)
+
+    async def all(
+        self,
+        user_id: str,
+        include_users: bool = False,
+        include_inactive_users: bool = False,
+        where: Optional[eetschema_users_in_group_bool_exp] = None,
+        order: Optional[List[eetschema_users_in_group_order_by]] = None,
+        limit: Optional[int] = None,
+    ) -> List[GroupResult]:
+        where_data = (
+            where.model_copy(update={"user_id": String_comparison_exp(_eq=user_id)})
+            if where is not None
+            else eetschema_users_in_group_bool_exp(
+                user_id=String_comparison_exp(_eq=user_id)
+            )
+        )
+
+        order_data = order or [
+            eetschema_users_in_group_order_by(
+                group=eetschema_group_order_by(created_at=order_by.desc)
+            )
+        ]
+
+        result = await self._client.all_groups(
+            where=where_data,
+            order=order_data,
+            limit=limit,
+            include_users=include_users,
+            include_inactive_users=include_inactive_users,
+        )
+
+        return transform_all_groups(result, include_users=include_users)
+
+    async def create(self, name: str, user_id: str) -> GroupResult:
+        result = await self._client.create_group(name=name, user_id=user_id)
+        return transform_create_group(result)
+
+    async def update(
+        self, group_id: str, data: eetschema_group_set_input
+    ) -> GroupResult:
+        result = await self._client.update_group(
+            group_id=group_id,
+            set_=data,
+        )
+        return transform_update_group(result)

eetlijst/services/groups/transformers.py

@@ -0,0 +1,140 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+from eetlijst.generated.all_groups import AllGroups
+from eetlijst.generated.create_group import CreateGroup
+from eetlijst.generated.fragments import GroupFields, UserInGroupFields
+from eetlijst.generated.get_group import GetGroup
+from eetlijst.generated.update_group import UpdateGroup
+
+from eetlijst.exceptions import EetlijstException
+
+from eetlijst.services.users.transformers import UserResult, transform_user
+
+
+class GroupSummaryResult(BaseModel):
+    payed_total: float
+    user_id: str
+
+
+class UserInGroupResult(BaseModel):
+    order: Optional[int] = None
+    start_holliday: Optional[datetime] = None
+    end_holliday: Optional[datetime] = None
+    monday: Optional[bool] = None
+    tuesday: Optional[bool] = None
+    wednesday: Optional[bool] = None
+    thursday: Optional[bool] = None
+    friday: Optional[bool] = None
+    saturday: Optional[bool] = None
+    sunday: Optional[bool] = None
+    user: Optional[UserResult] = None
+
+
+class GroupResult(BaseModel):
+    id: str
+    name: str
+    default_close_time: Optional[datetime]
+    created_at: datetime
+    created_at_eetlijst: Optional[datetime]
+    statistics_start_date: Optional[datetime]
+    statistics_end_date: Optional[datetime]
+    invite_uuid: str
+    invite_open: bool
+    description: Optional[str]
+    summary: list[GroupSummaryResult]
+    users: list[UserInGroupResult] = []
+
+
+def transform_group(
+    group: Optional[GroupFields],
+    users: Optional[list[UserInGroupResult]] = None,
+) -> GroupResult:
+    if not group:
+        raise EetlijstException("Group not found")
+
+    filtered_summary = [
+        GroupSummaryResult(
+            payed_total=float(entry.payed_total),
+            user_id=entry.user_id,
+        )
+        for entry in (group.summary or [])
+        if entry and entry.payed_total is not None and entry.user_id is not None
+    ]
+
+    group_data = group.model_dump(exclude={"summary"})
+    return GroupResult(
+        **group_data,
+        summary=filtered_summary,
+        users=users or [],
+    )
+
+
+def transform_user_in_group(
+    user_in_group: Optional[UserInGroupFields],
+) -> UserInGroupResult:
+    if not user_in_group:
+        raise EetlijstException("User in group not found")
+
+    user_data = transform_user(user_in_group.user) if user_in_group.user else None
+    data = user_in_group.model_dump(exclude={"user"})
+
+    return UserInGroupResult(
+        **data,
+        user=user_data,
+    )
+
+
+def transform_create_group(result: CreateGroup) -> GroupResult:
+    if not result.group:
+        raise EetlijstException("Failed to create group")
+
+    return transform_group(result.group)
+
+
+def transform_update_group(result: UpdateGroup) -> GroupResult:
+    if not result.group:
+        raise EetlijstException("Failed to update group")
+
+    return transform_group(result.group)
+
+
+def transform_all_groups(
+    result: AllGroups,
+    include_users: bool = False,
+) -> list[GroupResult]:
+    transformed_groups: list[GroupResult] = []
+    for user_in_group in result.eetschema_users_in_group:
+        if not user_in_group.group:
+            continue
+
+        users = (
+            [transform_user_in_group(u) for u in user_in_group.group.users_in_groups]
+            if include_users and user_in_group.group.users_in_groups
+            else []
+        )
+
+        transformed_groups.append(transform_group(user_in_group.group, users=users))
+
+    return transformed_groups
+
+
+def transform_get_group(
+    result: GetGroup,
+    include_users: bool = False,
+) -> GroupResult:
+    if not result.eetschema_group_by_pk:
+        raise EetlijstException("Failed to get group")
+
+    users = (
+        [
+            transform_user_in_group(u)
+            for u in result.eetschema_group_by_pk.users_in_groups
+        ]
+        if include_users and result.eetschema_group_by_pk.users_in_groups
+        else []
+    )
+
+    return transform_group(result.eetschema_group_by_pk, users=users)

eetlijst/services/settlements/__init__.py

@@ -0,0 +1 @@
+from .settlements import Settlements

eetlijst/services/settlements/settlements.py

@@ -0,0 +1,225 @@
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import List, Optional, TypedDict
+
+from eetlijst.generated import GraphQlClient, order_by
+from eetlijst.generated.fragments import ExpenseFields
+from eetlijst.generated.input_types import (
+    Boolean_comparison_exp,
+    eetschema_expense_bool_exp,
+    eetschema_expense_distribution_insert_input,
+    eetschema_expense_order_by,
+    eetschema_expense_set_input,
+    eetschema_settlements_bool_exp,
+    eetschema_settlements_order_by,
+    uuid_comparison_exp,
+)
+
+from eetlijst.services.expenses.transformers import (
+    transform_create_expense,
+    transform_update_expense,
+)
+from eetlijst.services.expenses.utils import calculate_balances_from_expenses
+from eetlijst.services.settlements.transformers import (
+    SettlementResult,
+    transform_create_settlement,
+    transform_settle_unsettled_expenses,
+    transform_settlement,
+    transform_settlement_expenses,
+)
+from eetlijst.services.settlements.utils import (
+    CalculatedAdjustmentExpense,
+    calculate_adjustment_expenses,
+)
+
+
+class SettleResult(TypedDict):
+    id: str
+    expenses: list[ExpenseFields]
+    adjustments: list[ExpenseFields]
+
+
+@dataclass
+class Settlements:
+    _client: GraphQlClient
+
+    async def get(self, settlement_id: str) -> Optional[SettlementResult]:
+        result = await self._client.all_settlements(
+            where=eetschema_settlements_bool_exp(
+                id=uuid_comparison_exp(_eq=settlement_id)
+            )
+        )
+
+        return transform_settlement(result.eetschema_settlements[0])
+
+    async def all(
+        self,
+        group_id: str,
+        where: Optional[eetschema_settlements_bool_exp] = None,
+        order: Optional[list[eetschema_settlements_order_by]] = None,
+        limit: Optional[int] = None,
+    ) -> list[SettlementResult]:
+        group_filter = uuid_comparison_exp(_eq=group_id)
+        where_data = (
+            where.model_copy(update={"group_id": group_filter})
+            if where is not None
+            else eetschema_settlements_bool_exp(group_id=group_filter)
+        )
+
+        order_data = order or [eetschema_settlements_order_by(created_at=order_by.desc)]
+
+        result = await self._client.all_settlements(
+            where=where_data,
+            order=order_data,
+            limit=limit,
+        )
+        return [transform_settlement(s) for s in result.eetschema_settlements]
+
+    async def create(self, group_id: str) -> SettlementResult:
+        result = await self._client.create_settlement(group_id=group_id)
+        return transform_create_settlement(result)
+
+    async def settle(
+        self,
+        group_id: str,
+        settlement_id: Optional[str] = None,
+        do_not_create_adjustment_expenses: bool = False,
+        select: Optional[eetschema_expense_bool_exp] = None,
+    ) -> SettleResult:
+        if settlement_id is None:
+            settlement = await self.create(group_id=group_id)
+            settlement_id = settlement.id
+
+        group_filter = uuid_comparison_exp(_eq=group_id)
+        settled_filter = uuid_comparison_exp(_is_null=True)
+
+        if select is not None:
+            where_data = select.model_copy(
+                update={
+                    "group_id": group_filter,
+                    "settled_id": settled_filter,
+                }
+            )
+        else:
+            where_data = eetschema_expense_bool_exp(
+                group_id=group_filter,
+                settled_id=settled_filter,
+            )
+
+        result = await self._client.settle_unsettled_expenses(
+            settlement_id=settlement_id,
+            where=where_data,
+        )
+        settled = transform_settle_unsettled_expenses(result)
+
+        inserted_adjustments: List[ExpenseFields] = []
+        if not do_not_create_adjustment_expenses:
+            balances = calculate_balances_from_expenses(settled.expenses)
+            adjustments = calculate_adjustment_expenses(balances)
+
+            now = datetime.now(timezone.utc)
+            description = f"Vereffening {now.strftime('%d-%m-%Y')}"
+
+            async def create_and_update_adjustment(
+                adjustment: CalculatedAdjustmentExpense,
+            ) -> ExpenseFields:
+                distribution_data = [
+                    eetschema_expense_distribution_insert_input(
+                        user_id=d["user"].id,
+                        payed_amount=d["payed_amount"],
+                        count=d["count"],
+                    )
+                    for d in adjustment["expense_distributions"]
+                ]
+
+                created_raw = await self._client.create_expense(
+                    group_id=group_id,
+                    payed_by=adjustment["payed_by"].id,
+                    payed_amount=adjustment["payed_amount"],
+                    payed_at=now,
+                    description=description,
+                    settlement_expense_id=settlement_id,
+                    data=distribution_data,
+                )
+                created_expense = transform_create_expense(created_raw)
+
+                updated_raw = await self._client.update_expense(
+                    expense_id=created_expense.id,
+                    set_=eetschema_expense_set_input(settled_id=settlement_id),
+                )
+                return transform_update_expense(updated_raw)
+
+            inserted_adjustments = list(
+                await asyncio.gather(
+                    *(create_and_update_adjustment(adj) for adj in adjustments)
+                )
+            )
+
+        return {
+            "id": settlement_id,
+            "expenses": settled.expenses,
+            "adjustments": inserted_adjustments,
+        }
+
+    async def expenses(
+        self,
+        settlement_id: str,
+        where: Optional[eetschema_expense_bool_exp] = None,
+        order: Optional[list[eetschema_expense_order_by]] = None,
+    ) -> list[ExpenseFields]:
+        return await self._expenses(
+            settlement_id=settlement_id,
+            settlement_expense_id_not_null=False,
+            where=where,
+            order=order,
+        )
+
+    async def adjustments(
+        self,
+        settlement_id: str,
+        where: Optional[eetschema_expense_bool_exp] = None,
+        order: Optional[list[eetschema_expense_order_by]] = None,
+    ) -> list[ExpenseFields]:
+        return await self._expenses(
+            settlement_id=settlement_id,
+            settlement_expense_id_not_null=True,
+            where=where,
+            order=order,
+        )
+
+    async def _expenses(
+        self,
+        settlement_id: str,
+        settlement_expense_id_not_null: bool,
+        where: Optional[eetschema_expense_bool_exp] = None,
+        order: Optional[list[eetschema_expense_order_by]] = None,
+    ) -> list[ExpenseFields]:
+        deleted_filter = Boolean_comparison_exp(_eq=False)
+        settled_filter = uuid_comparison_exp(_eq=settlement_id)
+        settlement_expense_filter = uuid_comparison_exp(
+            _is_null=not settlement_expense_id_not_null
+        )
+
+        if where is not None:
+            where_data = where.model_copy(
+                update={
+                    "deleted": deleted_filter,
+                    "settled_id": settled_filter,
+                    "settlement_expense_id": settlement_expense_filter,
+                }
+            )
+        else:
+            where_data = eetschema_expense_bool_exp(
+                deleted=deleted_filter,
+                settled_id=settled_filter,
+                settlement_expense_id=settlement_expense_filter,
+            )
+
+        order_data = order or [eetschema_expense_order_by(created_at=order_by.desc)]
+
+        result = await self._client.settlement_expenses(
+            where=where_data,
+            order=order_data,
+        )
+        return transform_settlement_expenses(result)

eetlijst/services/settlements/transformers.py

@@ -0,0 +1,95 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from eetlijst.generated.create_settlement import CreateSettlement
+from eetlijst.generated.fragments import (
+    ExpenseFields,
+    SettlementFields,
+    SettlementFieldsCreatedBy,
+)
+from eetlijst.generated.settle_unsettled_expenses import SettleUnsettledExpenses
+from eetlijst.generated.settlement_expenses import SettlementExpenses
+
+from eetlijst.exceptions import EetlijstException
+
+from eetlijst.services.expenses.transformers import transform_expense
+
+
+class SettlementResult(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    id: str
+    group_id: str
+    created_at: datetime
+    updated_at: datetime
+    created_by: SettlementFieldsCreatedBy
+    expenses_total: Optional[int] = None
+    adjustments_total: Optional[int] = None
+
+
+class SettleUnsettledExpensesResult(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    number_expenses: int
+    expenses: list[ExpenseFields]
+
+
+def transform_settlement(settlement: Optional[SettlementFields]) -> SettlementResult:
+    if not settlement:
+        raise EetlijstException("Settlement not found")
+
+    expenses_total: Optional[int] = None
+    if (
+        settlement.expenses_total
+        and settlement.expenses_total.aggregate
+        and settlement.expenses_total.aggregate.sum
+    ):
+        expenses_total = settlement.expenses_total.aggregate.sum.payed_amount
+
+    adjustments_total: Optional[int] = None
+    if (
+        settlement.adjustments_total
+        and settlement.adjustments_total.aggregate
+        and settlement.adjustments_total.aggregate.sum
+    ):
+        adjustments_total = settlement.adjustments_total.aggregate.sum.payed_amount
+
+    data = {
+        **settlement.model_dump(),
+        "expenses_total": expenses_total,
+        "adjustments_total": adjustments_total,
+    }
+
+    return SettlementResult(**data)
+
+
+def transform_create_settlement(result: CreateSettlement) -> SettlementResult:
+    if not result.settlement:
+        raise EetlijstException("Failed to create settlement")
+
+    return transform_settlement(result.settlement)
+
+
+def transform_settle_unsettled_expenses(
+    result: SettleUnsettledExpenses,
+) -> SettleUnsettledExpensesResult:
+    if not result.update_eetschema_expense:
+        raise EetlijstException("Failed to settle expenses")
+
+    expenses = [
+        transform_expense(expense)
+        for expense in result.update_eetschema_expense.expenses
+    ]
+
+    data = {
+        **result.update_eetschema_expense.model_dump(),
+        "expenses": expenses,
+    }
+
+    return SettleUnsettledExpensesResult(**data)
+
+
+def transform_settlement_expenses(result: SettlementExpenses):
+    return [transform_expense(expense) for expense in result.eetschema_expense]

eetlijst/services/settlements/utils.py

@@ -0,0 +1,84 @@
+from typing import TypedDict
+
+from eetlijst.generated.fragments import ExpenseFieldsExpenseDistributionsUser
+
+from eetlijst.services.expenses.utils import UserBalance
+
+
+class AdjustmentExpenseDistribution(TypedDict):
+    user: ExpenseFieldsExpenseDistributionsUser
+    count: int
+    payed_amount: int
+    user_id: str
+
+
+class CalculatedAdjustmentExpense(TypedDict):
+    payed_by: ExpenseFieldsExpenseDistributionsUser
+    payed_amount: int
+    expense_distributions: list[AdjustmentExpenseDistribution]
+
+
+def calculate_adjustment_expenses(
+    balances: list[UserBalance],
+) -> list[CalculatedAdjustmentExpense]:
+    creditors: list[UserBalance] = sorted(
+        [
+            UserBalance(user=b["user"], balance=b["balance"])
+            for b in balances
+            if b["balance"] > 0
+        ],
+        key=lambda b: b["balance"],
+    )
+
+    debtors: list[UserBalance] = sorted(
+        [
+            UserBalance(user=b["user"], balance=b["balance"])
+            for b in balances
+            if b["balance"] < 0
+        ],
+        key=lambda b: abs(b["balance"]),
+        reverse=True,
+    )
+
+    results: list[CalculatedAdjustmentExpense] = []
+
+    for creditor in creditors:
+        distributions: list[AdjustmentExpenseDistribution] = []
+
+        for debtor in debtors:
+            amount = min(creditor["balance"], abs(debtor["balance"]))
+            if amount <= 0:
+                continue
+
+            distributions.append(
+                {
+                    "user": debtor["user"],
+                    "payed_amount": amount,
+                    "user_id": debtor["user"].id,
+                    "count": 0,
+                }
+            )
+
+            creditor["balance"] -= amount
+            debtor["balance"] += amount
+
+        total = -sum(entry["payed_amount"] for entry in distributions)
+
+        distributions.append(
+            {
+                "user": creditor["user"],
+                "payed_amount": total,
+                "user_id": creditor["user"].id,
+                "count": 0,
+            }
+        )
+
+        results.append(
+            {
+                "payed_by": creditor["user"],
+                "payed_amount": total,
+                "expense_distributions": distributions,
+            }
+        )
+
+    return results

eetlijst/services/users/__init__.py

@@ -0,0 +1 @@
+from .users import Users