Add recurring expense management feature

- Introduced RecurringExpense model to represent regular operating expenses for freelancers.
- Implemented data access layer (SalaryDataSource) for CRUD operations on recurring expenses.
- Added SalaryIntent to handle business logic for computing effective salary, incorporating recurring expenses.
- Created SalaryView for displaying and managing effective salary planning, including a user-friendly interface.
- Updated navigation to include SalaryView and associated icons for better user experience.
- Added migration script to create the recurring expense table in the database.

Author: clstaudt

tuttle/app/core/utils.py

@@ -152,6 +152,8 @@ class TuttleComponentIcons(Enum):
     profile_photo_selected_icon = Icons.PHOTO_ROUNDED
     timeline_icon = Icons.TIMELINE_OUTLINED
     timeline_selected_icon = Icons.TIMELINE_ROUNDED
+    salary_icon = Icons.SAVINGS_OUTLINED
+    salary_selected_icon = Icons.SAVINGS_ROUNDED
 
     def __str__(self) -> str:
         return str(self.value)

tuttle/app/home/view.py

@@ -32,6 +32,7 @@
 from ..core.status_bar import StatusBarManager
 from ..dashboard.view import DashboardView
 from ..invoicing.view import InvoicingListView
+from ..salary.view import SalaryView
 from ..tax.view import TaxView
 from ..timeline.view import TimelineView
 from ..projects.view import ProjectsListView
@@ -126,6 +127,7 @@ def __init__(self, params: TViewParams):
         self.dashboard_view = DashboardView(params)
         self.timeline_view = TimelineView(params)
         self.tax_view = TaxView(params)
+        self.salary_view = SalaryView(params)
         self.items = [
             views.NavigationMenuItem(
                 index=0,
@@ -148,6 +150,13 @@ def __init__(self, params: TViewParams):
                 selected_icon=utils.TuttleComponentIcons.tax_selected_icon,
                 destination=self.tax_view,
             ),
+            views.NavigationMenuItem(
+                index=3,
+                label="Salary",
+                icon=utils.TuttleComponentIcons.salary_icon,
+                selected_icon=utils.TuttleComponentIcons.salary_selected_icon,
+                destination=self.salary_view,
+            ),
         ]
 
 

tuttle/app/salary/__init__.py

@@ -0,0 +1,68 @@
+"""Data-access layer for the Salary feature."""
+
+from typing import List, Optional
+
+from loguru import logger
+import sqlmodel
+
+from ..core.abstractions import SQLModelDataSourceMixin
+from ..core.intent_result import IntentResult
+from ...model import RecurringExpense
+
+
+class SalaryDataSource(SQLModelDataSourceMixin):
+    """CRUD operations for RecurringExpense records."""
+
+    def __init__(self):
+        super().__init__()
+
+    def get_all_expenses(self) -> IntentResult[List[RecurringExpense]]:
+        try:
+            expenses = self.query(RecurringExpense)
+            return IntentResult(was_intent_successful=True, data=expenses)
+        except Exception as ex:
+            return IntentResult(
+                was_intent_successful=False,
+                error_msg="Failed to load recurring expenses.",
+                log_message=f"SalaryDataSource.get_all_expenses: {ex}",
+                exception=ex,
+            )
+
+    def save_expense(self, expense: RecurringExpense) -> IntentResult[RecurringExpense]:
+        try:
+            with self.create_session() as session:
+                session.add(expense)
+                session.commit()
+                session.refresh(expense)
+            return IntentResult(was_intent_successful=True, data=expense)
+        except Exception as ex:
+            return IntentResult(
+                was_intent_successful=False,
+                error_msg="Failed to save recurring expense.",
+                log_message=f"SalaryDataSource.save_expense: {ex}",
+                exception=ex,
+            )
+
+    def delete_expense_by_id(self, expense_id: int) -> IntentResult:
+        try:
+            with self.create_session() as session:
+                expense = session.exec(
+                    sqlmodel.select(RecurringExpense).where(
+                        RecurringExpense.id == expense_id
+                    )
+                ).one_or_none()
+                if expense is None:
+                    return IntentResult(
+                        was_intent_successful=False,
+                        error_msg=f"Expense with id={expense_id} not found.",
+                    )
+                session.delete(expense)
+                session.commit()
+            return IntentResult(was_intent_successful=True)
+        except Exception as ex:
+            return IntentResult(
+                was_intent_successful=False,
+                error_msg="Failed to delete recurring expense.",
+                log_message=f"SalaryDataSource.delete_expense_by_id: {ex}",
+                exception=ex,
+            )

tuttle/app/salary/data_source.py

@@ -0,0 +1,77 @@
+"""Business logic for the Salary feature."""
+
+from decimal import Decimal
+
+from ..core.abstractions import SQLModelDataSourceMixin, Intent
+from ..core.intent_result import IntentResult
+
+from ...model import Invoice, RecurringExpense, User
+from ...tax import get_tax_system
+from ...tax_reserves import compute_effective_salary
+
+from .data_source import SalaryDataSource
+
+
+class SalaryIntent(SQLModelDataSourceMixin, Intent):
+    """Gathers and processes data for the Effective Salary view."""
+
+    def __init__(self):
+        SQLModelDataSourceMixin.__init__(self)
+        self._data_source = SalaryDataSource()
+
+    def _get_country(self) -> str:
+        try:
+            users = self.query(User)
+            if users and users[0].operating_country:
+                return users[0].operating_country
+        except Exception:
+            pass
+        return "Germany"
+
+    def _get_tax_currency(self, country: str) -> str:
+        try:
+            return get_tax_system(country).currency
+        except NotImplementedError:
+            return "EUR"
+
+    def get_effective_salary(self) -> IntentResult:
+        """Compute the effective salary range."""
+        try:
+            invoices = self.query(Invoice)
+            expenses_result = self._data_source.get_all_expenses()
+            expenses = (
+                expenses_result.data if expenses_result.was_intent_successful else []
+            )
+
+            country = self._get_country()
+            currency = self._get_tax_currency(country)
+
+            salary = compute_effective_salary(
+                invoices=invoices,
+                expenses=expenses,
+                country=country,
+                currency=currency,
+            )
+            return IntentResult(
+                was_intent_successful=True,
+                data={"salary": salary, "currency": currency},
+            )
+        except Exception as e:
+            return IntentResult(
+                was_intent_successful=False,
+                error_msg="Failed to compute effective salary.",
+                log_message=f"SalaryIntent.get_effective_salary: {e}",
+                exception=e,
+            )
+
+    def get_expenses(self) -> IntentResult:
+        """Return all recurring expenses."""
+        return self._data_source.get_all_expenses()
+
+    def save_expense(self, expense: RecurringExpense) -> IntentResult:
+        """Persist a new or updated recurring expense."""
+        return self._data_source.save_expense(expense)
+
+    def delete_expense(self, expense_id: int) -> IntentResult:
+        """Remove a recurring expense by id."""
+        return self._data_source.delete_expense_by_id(expense_id)