eetlijst-python 0.0.1__py3-none-any.whl

eetlijst/services/events/transformers.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+from typing import Optional
+
+from eetlijst.generated.automatic_events import (
+    AutomaticEvents,
+    AutomaticEventsQueryTodaysEvents,
+)
+from eetlijst.generated.base_model import BaseModel
+from eetlijst.generated.fragments import (
+    EventFields,
+    EventFieldsLinkedExpenses,
+    EventFieldsUser,
+)
+from eetlijst.generated.update_event import UpdateEvent
+
+from eetlijst.exceptions import EetlijstException
+
+from eetlijst.services.event_attendance.transformers import (
+    Attendance,
+    transform_attendance,
+)
+
+
+class Event(BaseModel):
+    id: str
+    group_id: str
+    open: bool
+    start_date: datetime
+    closed_by: str | None
+    signup_deadline: datetime | None
+    changed_signup_time: bool
+    name: str
+    description: str | None
+    user: EventFieldsUser | None
+    created_at: datetime | None
+    updated_at: datetime | None
+    expenses: list[EventFieldsLinkedExpenses] | None = None
+    attendees: list[Attendance] | None = None
+
+
+def transform_automatic_events(
+    events: AutomaticEvents,
+) -> AutomaticEventsQueryTodaysEvents:
+    if not events or not events.query_todays_events:
+        raise EetlijstException("Failed to populate dinners")
+
+    return events.query_todays_events
+
+
+def transform_event(event: Optional[EventFields]) -> Event:
+    if not event:
+        raise EetlijstException("Event not found")
+
+    data = event.model_dump(exclude={"linked_expenses", "event_attendees"})
+    data["expenses"] = event.linked_expenses  # TODO: add transform_expense
+    data["attendees"] = [
+        transform_attendance(attendee) for attendee in (event.event_attendees or [])
+    ]
+
+    return Event(**data)
+
+
+def transform_update_event(event: UpdateEvent) -> Event:
+    if not event or not event.update_eetschema_event_by_pk:
+        raise EetlijstException("Failed to update event")
+
+    return transform_event(event.update_eetschema_event_by_pk)

eetlijst/services/expenses/__init__.py

@@ -0,0 +1 @@
+from .expenses import Expenses

eetlijst/services/expenses/expenses.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from eetlijst.generated import GraphQlClient, order_by
+from eetlijst.generated.input_types import (
+    Boolean_comparison_exp,
+    eetschema_expense_bool_exp,
+    eetschema_expense_distribution_insert_input,
+    eetschema_expense_insert_input,
+    eetschema_expense_order_by,
+    eetschema_expense_set_input,
+    uuid_comparison_exp,
+)
+
+from eetlijst.services.expenses.transformers import (
+    transform_create_expense,
+    transform_expense,
+    transform_group_total_expense,
+    transform_update_expense,
+)
+from eetlijst.services.settlements import Settlements
+
+
+@dataclass
+class Expenses:
+    _client: GraphQlClient
+    settlements: Settlements
+
+    async def get(self, expense_id: str):
+        result = await self._client.all_expenses(
+            where=eetschema_expense_bool_exp(id=uuid_comparison_exp(_eq=expense_id))
+        )
+
+        return transform_expense(result.eetschema_expense[0])
+
+    async def all(
+        self,
+        group_id: str,
+        where: Optional[eetschema_expense_bool_exp] = None,
+        order: Optional[list[eetschema_expense_order_by]] = None,
+        limit: Optional[int] = None,
+    ):
+        if where is not None:
+            where_data = where.model_copy(
+                update={
+                    "deleted": Boolean_comparison_exp(_eq=False),
+                    "group_id": uuid_comparison_exp(_eq=group_id),
+                }
+            )
+        else:
+            where_data = eetschema_expense_bool_exp(
+                deleted=Boolean_comparison_exp(_eq=False),
+                group_id=uuid_comparison_exp(_eq=group_id),
+            )
+
+        order_data = order
+        if order_data is None:
+            order_data = [eetschema_expense_order_by(created_at=order_by.desc)]
+
+        result = await self._client.all_expenses(
+            where=where_data,
+            order=order_data,
+            limit=limit,
+        )
+
+        return [transform_expense(expense) for expense in result.eetschema_expense]
+
+    async def create(self, data: eetschema_expense_insert_input):
+        result = await self._client.create_expense(*data)
+        return transform_create_expense(result)
+
+    async def update(self, expense_id: str, data: eetschema_expense_set_input):
+        result = await self._client.update_expense(
+            expense_id=expense_id,
+            set_=data,
+        )
+
+        return transform_update_expense(result)
+
+    async def update_distribution(
+        self,
+        expense_id: str,
+        data: list[eetschema_expense_distribution_insert_input],
+    ):
+        await self._client.update_expense_distribution(
+            expense_id=expense_id,
+            objects=data,
+        )
+
+    async def delete(self, expense_id: str):
+        return await self.update(
+            expense_id=expense_id,
+            data=eetschema_expense_set_input(deleted=True),
+        )
+
+    async def group_total(self, group_id: str):
+        result = await self._client.group_total_expense(group_id=group_id)
+        return transform_group_total_expense(result)

eetlijst/services/expenses/transformers.py

@@ -0,0 +1,73 @@
+from typing import Optional, TypedDict
+
+from eetlijst.generated.create_expense import CreateExpense
+from eetlijst.generated.fragments import ExpenseFields
+from eetlijst.generated.group_total_expense import GroupTotalExpense
+from eetlijst.generated.update_expense import UpdateExpense
+
+from eetlijst.exceptions import EetlijstException
+
+
+class GroupTotalExpenseDict(TypedDict):
+    total: int
+    expenses: int
+    imported: int
+
+
+def transform_expense(expense: Optional[ExpenseFields]) -> ExpenseFields:
+    if not expense:
+        raise EetlijstException("Expense not found")
+
+    return expense
+
+
+def transform_create_expense(expense: CreateExpense) -> ExpenseFields:
+    if not expense or not expense.insert_eetschema_expense_one:
+        raise EetlijstException("Failed to create expense")
+
+    return transform_expense(expense.insert_eetschema_expense_one)
+
+
+def transform_update_expense(expense: UpdateExpense) -> ExpenseFields:
+    if (
+        not expense
+        or not expense.update_eetschema_expense
+        or not expense.update_eetschema_expense.returning
+    ):
+        raise EetlijstException("Failed to update expense")
+
+    return transform_expense(expense.update_eetschema_expense.returning[0])
+
+
+def transform_group_total_expense(
+    result: Optional[GroupTotalExpense],
+) -> GroupTotalExpenseDict:
+    if not result:
+        return {"total": 0, "expenses": 0, "imported": 0}
+
+    expenses_total = 0
+    if (
+        result.eetschema_expense_aggregate
+        and result.eetschema_expense_aggregate.aggregate
+        and result.eetschema_expense_aggregate.aggregate.sum
+        and result.eetschema_expense_aggregate.aggregate.sum.payed_amount is not None
+    ):
+        expenses_total = result.eetschema_expense_aggregate.aggregate.sum.payed_amount
+
+    imports_total = 0
+    if (
+        result.eetschema_expense_eetlijst_import_aggregate
+        and result.eetschema_expense_eetlijst_import_aggregate.aggregate
+        and result.eetschema_expense_eetlijst_import_aggregate.aggregate.sum
+        and result.eetschema_expense_eetlijst_import_aggregate.aggregate.sum.payed_amount
+        is not None
+    ):
+        expenses_total = (
+            result.eetschema_expense_eetlijst_import_aggregate.aggregate.sum.payed_amount
+        )
+
+    return {
+        "total": expenses_total + imports_total,
+        "expenses": expenses_total,
+        "imported": imports_total,
+    }

eetlijst/services/expenses/utils.py

@@ -0,0 +1,31 @@
+from typing import TypedDict
+
+from eetlijst.generated.fragments import (
+    ExpenseFields,
+    ExpenseFieldsExpenseDistributionsUser,
+)
+
+
+class UserBalance(TypedDict):
+    user: ExpenseFieldsExpenseDistributionsUser
+    balance: int
+
+
+def calculate_balances_from_expenses(
+    expenses: list[ExpenseFields],
+) -> list[UserBalance]:
+    balances: dict[str, UserBalance] = {}
+
+    for expense in expenses:
+        for distribution in expense.expense_distributions:
+            user_id = distribution.user.id
+            payed_amount = distribution.payed_amount
+
+            if user_id in balances:
+                balances[user_id]["balance"] += payed_amount
+            else:
+                balances[user_id] = {"user": distribution.user, "balance": payed_amount}
+
+    result = list(balances.values())
+    result.sort(key=lambda item: item["balance"], reverse=True)
+    return result

eetlijst/services/group_list/__init__.py

@@ -0,0 +1 @@
+from .group_list import GroupList

eetlijst/services/group_list/group_list.py

@@ -0,0 +1,95 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from eetlijst.generated import GraphQlClient
+from eetlijst.generated.input_types import (
+    eetschema_list_bool_exp,
+    eetschema_list_insert_input,
+    eetschema_list_order_by,
+    eetschema_list_set_input,
+    uuid_comparison_exp,
+)
+
+from eetlijst.exceptions import EetlijstException
+
+from eetlijst.services.group_list.transformers import (
+    transform_create_list_item,
+    transform_create_many_list_items,
+    transform_list_item,
+    transform_update_list_item,
+)
+
+
+@dataclass
+class GroupList:
+    _client: GraphQlClient
+
+    async def get(self, item_id: str):
+        result = await self._client.list_items(
+            where=eetschema_list_bool_exp(id=uuid_comparison_exp(_eq=item_id))
+        )
+
+        return transform_list_item(result.eetschema_list[0])
+
+    async def items(
+        self,
+        group_id: str,
+        where: Optional[eetschema_list_bool_exp] = None,
+        order: Optional[list[eetschema_list_order_by]] = None,
+        limit: Optional[int] = None,
+    ):
+        if where is not None:
+            where_data = where.model_copy(
+                update={
+                    "group_id": uuid_comparison_exp(_eq=group_id),
+                }
+            )
+        else:
+            where_data = eetschema_list_bool_exp(
+                group_id=uuid_comparison_exp(_eq=group_id),
+            )
+
+        result = await self._client.list_items(
+            where=where_data,
+            order=order,
+            limit=limit,
+        )
+
+        return [transform_list_item(item) for item in result.eetschema_list]
+
+    async def create_item(self, data: eetschema_list_insert_input):
+        result = await self._client.create_list_item(*data)
+        return transform_create_list_item(result)
+
+    async def create_many_items(self, items: list[eetschema_list_insert_input]):
+        result = await self._client.create_many_list_items(items=items)
+        return transform_create_many_list_items(result)
+
+    async def update_item(self, item_id: str, data: eetschema_list_set_input):
+        result = await self._client.update_list_item(
+            id=item_id,
+            set_=data,
+        )
+        return transform_update_list_item(result)
+
+    async def toggle_item(self, item_id: str):
+        item = await self.get(item_id)
+        if not item:
+            raise EetlijstException("List item not found")
+
+        return await self.update_item(
+            item_id=item_id,
+            data=eetschema_list_set_input(checked=not item.checked),
+        )
+
+    async def check_item(self, item_id: str, state: bool = True):
+        return await self.update_item(
+            item_id=item_id,
+            data=eetschema_list_set_input(checked=state),
+        )
+
+    async def remove_item(self, item_id: str):
+        return await self.update_item(
+            item_id=item_id,
+            data=eetschema_list_set_input(active=False),
+        )

eetlijst/services/group_list/transformers.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from eetlijst.generated.create_list_item import CreateListItem
+from eetlijst.generated.create_many_list_items import CreateManyListItems
+from eetlijst.generated.fragments import ItemFields
+from eetlijst.generated.update_list_item import UpdateListItem
+
+from eetlijst.exceptions import EetlijstException
+
+
+def transform_list_item(item: Optional[ItemFields]) -> ItemFields:
+    if not item:
+        raise EetlijstException("List item not found")
+
+    return item
+
+
+def transform_create_many_list_items(result: CreateManyListItems):
+    if not result.insert_eetschema_list:
+        raise EetlijstException("Failed to create list items")
+
+    return [
+        transform_list_item(item) for item in result.insert_eetschema_list.returning
+    ]
+
+
+def transform_create_list_item(result: CreateListItem):
+    if not result.insert_eetschema_list_one:
+        raise EetlijstException("Failed to create list item")
+
+    return transform_list_item(result.insert_eetschema_list_one)
+
+
+def transform_update_list_item(result: UpdateListItem):
+    if not result.update_eetschema_list_by_pk:
+        raise EetlijstException("Failed to update list item")
+
+    return transform_list_item(result.update_eetschema_list_by_pk)

eetlijst/services/group_users/__init__.py

@@ -0,0 +1 @@
+from .group_users import GroupUsers

eetlijst/services/group_users/group_users.py

@@ -0,0 +1,130 @@
+from dataclasses import dataclass
+from typing import Optional, TypedDict, Union
+
+from eetlijst.generated import GraphQlClient, order_by
+from eetlijst.generated.input_types import (
+    Boolean_comparison_exp,
+    String_comparison_exp,
+    eetschema_users_in_group_bool_exp,
+    eetschema_users_in_group_order_by,
+    eetschema_users_in_group_set_input,
+    eetschema_users_in_group_updates,
+    uuid_comparison_exp,
+)
+
+from eetlijst.services.group_users.transformers import (
+    transform_all_users_in_group,
+    transform_get_user_in_group,
+    transform_join_group,
+    transform_update_user_in_group,
+    transform_update_users_in_group,
+)
+
+
+class UserOrderItem(TypedDict):
+    user_id: str
+    order: int
+
+
+@dataclass
+class GroupUsers:
+    _client: GraphQlClient
+
+    async def get(self, group_id: str, user_id: str):
+        result = await self._client.get_user_in_group(
+            group_id=group_id, user_id=user_id
+        )
+        return transform_get_user_in_group(result)
+
+    async def all(
+        self,
+        group_id: str,
+        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,
+    ):
+        if where is not None:
+            update_data: dict[
+                str, Union[uuid_comparison_exp, Boolean_comparison_exp]
+            ] = {"group_id": uuid_comparison_exp(_eq=group_id)}
+            if not include_inactive_users:
+                update_data["active"] = Boolean_comparison_exp(_eq=True)
+
+            where_data = where.model_copy(update=update_data)
+        else:
+            where_data = eetschema_users_in_group_bool_exp(
+                group_id=uuid_comparison_exp(_eq=group_id),
+                active=(
+                    None if include_inactive_users else Boolean_comparison_exp(_eq=True)
+                ),
+            )
+
+        order_data = order or [eetschema_users_in_group_order_by(order=order_by.asc)]
+
+        result = await self._client.all_users_in_group(
+            group_id=group_id,
+            where=where_data,
+            order=order_data,
+            limit=limit,
+        )
+
+        return transform_all_users_in_group(result)
+
+    async def add(self, group_id: str, user_id: str, invite_id: str):
+        result = await self._client.join_group(group_id, user_id, invite_id)
+        return transform_join_group(result)
+
+    async def update(
+        self,
+        group_id: str,
+        user_id: str,
+        data: eetschema_users_in_group_set_input,
+    ):
+        result = await self._client.update_user_in_group(
+            group_id=group_id, user_id=user_id, set_=data
+        )
+
+        return transform_update_user_in_group(result)
+
+    async def update_many(
+        self,
+        updates: list[eetschema_users_in_group_updates],
+    ):
+        result = await self._client.update_users_in_group(updates=updates)
+        return transform_update_users_in_group(result)
+
+    async def remove(self, group_id: str, user_id: str):
+        return await self.update(
+            group_id=group_id,
+            user_id=user_id,
+            data=eetschema_users_in_group_set_input(active=False),
+        )
+
+    async def order(
+        self,
+        group_id: str,
+        user_order: list[Union[str, UserOrderItem]],
+        offset: int = 0,
+    ):
+        updates: list[eetschema_users_in_group_updates] = []
+
+        for index, item in enumerate(user_order):
+            if isinstance(item, str):
+                target_user_id = item
+                target_order = index + offset
+            else:
+                target_user_id = item["user_id"]
+                target_order = item["order"] + offset
+
+            updates.append(
+                eetschema_users_in_group_updates(
+                    where=eetschema_users_in_group_bool_exp(
+                        group_id=uuid_comparison_exp(_eq=group_id),
+                        user_id=String_comparison_exp(_eq=target_user_id),
+                    ),
+                    _set=eetschema_users_in_group_set_input(order=target_order),
+                )
+            )
+
+        return await self.update_many(updates)

eetlijst/services/group_users/transformers.py

@@ -0,0 +1,84 @@
+from typing import Optional, TypedDict
+
+from eetlijst.generated.all_users_in_group import AllUsersInGroup
+from eetlijst.generated.get_user_in_group import GetUserInGroup
+from eetlijst.generated.join_group import JoinGroup
+from eetlijst.generated.update_user_in_group import UpdateUserInGroup
+from eetlijst.generated.update_users_in_group import UpdateUsersInGroup
+
+from eetlijst.exceptions import EetlijstException
+
+from eetlijst.services.groups.transformers import (
+    UserInGroupResult,
+    transform_user_in_group,
+)
+
+
+class JoinGroupResult(TypedDict):
+    accepted: bool
+    error: Optional[str]
+
+
+class UpdateUsersInGroupResult(TypedDict):
+    number_users_in_group: int
+    users_in_group: list[UserInGroupResult]
+
+
+def transform_join_group(result: JoinGroup) -> JoinGroupResult:
+    if not result.join_group:
+        raise EetlijstException("Failed to join group")
+
+    return {
+        "accepted": result.join_group.accepted,
+        "error": result.join_group.error,
+    }
+
+
+def transform_update_users_in_group(
+    result: UpdateUsersInGroup,
+) -> UpdateUsersInGroupResult:
+    if not result.update_eetschema_users_in_group_many:
+        raise EetlijstException("Failed to update users in group")
+
+    valid_results = [
+        item for item in result.update_eetschema_users_in_group_many if item is not None
+    ]
+
+    updated_users_in_group = sum(item.number_users_in_group for item in valid_results)
+    users_in_group = [
+        transform_user_in_group(user)
+        for item in valid_results
+        for user in (item.users_in_group or [])
+    ]
+
+    return {
+        "number_users_in_group": updated_users_in_group,
+        "users_in_group": users_in_group,
+    }
+
+
+def transform_update_user_in_group(result: UpdateUserInGroup) -> UserInGroupResult:
+    if not result.update_eetschema_users_in_group_by_pk:
+        raise EetlijstException("Failed to update user in group")
+
+    return transform_user_in_group(result.update_eetschema_users_in_group_by_pk)
+
+
+def transform_all_users_in_group(result: AllUsersInGroup) -> list[UserInGroupResult]:
+    if not result.eetschema_group_by_pk:
+        raise EetlijstException("Failed to get users")
+
+    return [
+        transform_user_in_group(user)
+        for user in result.eetschema_group_by_pk.users_in_groups
+    ]
+
+
+def transform_get_user_in_group(result: GetUserInGroup) -> UserInGroupResult:
+    if (
+        not result.eetschema_group_by_pk
+        or not result.eetschema_group_by_pk.users_in_groups
+    ):
+        raise EetlijstException("Failed to get user")
+
+    return transform_user_in_group(result.eetschema_group_by_pk.users_in_groups[0])

eetlijst/services/groups/__init__.py

@@ -0,0 +1 @@
+from .groups import Groups