Merge pull request #197 from tuttle-dev/dev-db-refactor

Merge dev-db-refactor into dev

Author: vlad-ed-git

app/app.py

@@ -1,26 +1,21 @@
 from typing import Callable, Optional
 
-import re
-from pathlib import Path
-
 from flet import (
     AlertDialog,
     FilePicker,
     FilePickerUploadFile,
     Page,
     SnackBar,
     TemplateRoute,
-    Text,
     View,
     app,
 )
 
-import demo
-import sqlmodel
 from auth.view import ProfileScreen, SplashScreen
 from contracts.view import ContractEditorScreen, ViewContractScreen
 from core.abstractions import TuttleView, TuttleViewParams
 from core.client_storage_impl import ClientStorageImpl
+from core.database_storage_impl import DatabaseStorageImpl
 from core.models import RouteView
 from core.utils import AlertDialogControls
 from core.views import get_heading
@@ -64,9 +59,11 @@ def __init__(
         self.page.fonts = APP_FONTS
         self.page.theme = APP_THEME
         self.client_storage = ClientStorageImpl(page=self.page)
-        preferences = PreferencesIntent(
-            client_storage=self.client_storage,
+        self.db = DatabaseStorageImpl(
+            store_demo_timetracking_dataframe=self.store_demo_timetracking_dataframe,
+            debug_mode=self.debug_mode,
         )
+        preferences = PreferencesIntent(self.client_storage)
         preferences_result = preferences.get_preference_by_key(
             PreferencesStorageKeys.theme_mode_key
         )
@@ -92,10 +89,6 @@ def __init__(
         self.current_route_view: Optional[RouteView] = None
         self.page.on_resize = self.page_resize
 
-        # database config
-        self.app_dir = self.ensure_app_dir()
-        self.db_path = self.app_dir / "tuttle.db"
-
     def page_resize(self, e):
         if self.current_route_view:
             self.current_route_view.on_window_resized(
@@ -193,7 +186,6 @@ def control_alert_dialog(
     def change_route(self, to_route: str, data: Optional[any] = None):
         """navigates to a new route"""
         newRoute = to_route if data is None else f"{to_route}/{data}"
-
         self.page.go(newRoute)
 
     def on_view_pop(self, view: Optional[View] = None):
@@ -247,89 +239,35 @@ def on_route_change(self, route):
             self.page.window_width, self.page.window_height
         )
 
-    def create_model(self):
-        logger.info("Creating database model")
-        sqlmodel.SQLModel.metadata.create_all(
-            self.db_engine,
-            checkfirst=True,
-        )
-
-    def ensure_database(self):
-        """
-        Ensure that the database exists and is up to date.
-        """
-        if not self.db_path.exists():
-            self.reset_database()
-        else:
-            logger.info("Database exists, skipping creation")
-
-    def reset_database(self):
-        """
-        Delete the database and rebuild database model.
-        """
-        logger.info("Clearing database")
-        try:
-            self.db_path.unlink()
-        except FileNotFoundError:
-            logger.info("Database file not found, skipping delete")
-        self.db_engine = sqlmodel.create_engine(
-            f"sqlite:///{self.db_path}",
-            echo=self.debug_mode,
-        )
-        self.create_model()
-
     def store_demo_timetracking_dataframe(self, time_tracking_data: DataFrame):
         """Caches the time tracking dataframe created from a demo installation"""
         self.timetracking_intent = TimeTrackingIntent(
             client_storage=self.client_storage
         )
         self.timetracking_intent.set_timetracking_data(data=time_tracking_data)
 
-    def install_demo_data(self):
-        """Install demo data into the database."""
-        self.reset_database()
-        try:
-            demo.install_demo_data(
-                n_projects=4,
-                db_path=self.db_path,
-                on_cache_timetracking_dataframe=self.store_demo_timetracking_dataframe,
-            )
-        except Exception as ex:
-            logger.exception(ex)
-            logger.error("Failed to install demo data")
-
-    def ensure_app_dir(self) -> Path:
-        """Ensures that the user directory exists"""
-        app_dir = Path.home() / ".tuttle"
-        if not app_dir.exists():
-            app_dir.mkdir(parents=True)
-        return app_dir
-
-    def ensure_uploads_dir(self) -> Path:
-        uploads_dir = self.app_dir / "uploads"
-        if not uploads_dir.exists():
-            uploads_dir.mkdir(parents=True)
-        return uploads_dir
+    def build(self):
+        self.page.go(self.page.route)
 
     def close(self):
         """Closes the application."""
         self.page.window_close()
 
-    def build(self):
-        self.page.go(self.page.route)
-
     def reset_and_quit(self):
         """Resets the application and quits."""
-        self.reset_database()
+        self.db.reset_database()
         self.close()
 
 
 class TuttleRoutes:
     """Utility class for parsing of routes to destination views"""
 
     def __init__(self, app: TuttleApp):
-        self.app = app
+        # init callbacks for some views
         self.on_theme_changed = app.on_theme_mode_changed
+        self.on_reset_and_quit = app.reset_and_quit
+        self.on_install_demo_data = app.db.install_demo_data
+        # init common params for views
         self.tuttle_view_params = TuttleViewParams(
             navigate_to_route=app.change_route,
             show_snack=app.show_snack,
@@ -370,14 +308,16 @@ def parse_route(self, pageRoute: str):
         if routePath.match(SPLASH_SCREEN_ROUTE):
             screen = SplashScreen(
                 params=self.tuttle_view_params,
-                install_demo_data_callback=self.app.install_demo_data,
+                on_install_demo_data=self.on_install_demo_data,
             )
         elif routePath.match(HOME_SCREEN_ROUTE):
             screen = HomeScreen(
                 params=self.tuttle_view_params,
             )
         elif routePath.match(PROFILE_SCREEN_ROUTE):
-            screen = ProfileScreen(params=self.tuttle_view_params)
+            screen = ProfileScreen(
+                params=self.tuttle_view_params,
+            )
         elif routePath.match(CONTRACT_EDITOR_SCREEN_ROUTE):
             screen = ContractEditorScreen(params=self.tuttle_view_params)
         elif routePath.match(f"{CONTRACT_DETAILS_SCREEN_ROUTE}/:contractId"):
@@ -395,7 +335,7 @@ def parse_route(self, pageRoute: str):
             screen = PreferencesScreen(
                 params=self.tuttle_view_params,
                 on_theme_changed_callback=self.on_theme_changed,
-                on_reset_app_callback=self.app.reset_and_quit,
+                on_reset_app_callback=self.on_reset_and_quit,
             )
         elif routePath.match(PROJECT_EDITOR_SCREEN_ROUTE):
             screen = ProjectEditorScreen(params=self.tuttle_view_params)
@@ -431,7 +371,7 @@ def main(page: Page):
     app = TuttleApp(page)
 
     # if database does not exist, create it
-    app.ensure_database()
+    app.db.ensure_database()
 
     app.build()
 

app/auth/view.py

@@ -32,22 +32,20 @@ class PaymentDataForm(UserControl):
     def __init__(
         self,
         on_form_submit: Callable[[User], None],
-        user: User,
     ):
         super().__init__()
         self.on_form_submit = on_form_submit
-        self.user = user
-        self.set_form_data()
+        self.user: User = None
 
     def set_form_data(self):
         """Sets the form data to the user's current data"""
         if not self.user.bank_account:
             # Create a new bank account if none exists
             self.user.bank_account = BankAccount(name="", BIC="", IBAN="")
-        self.bank_bic = self.user.bank_account.BIC
-        self.bank_name = self.user.bank_account.name
-        self.bank_iban = self.user.bank_account.IBAN
-        self.vat_number = self.user.VAT_number
+        self.bank_ibc_field.value = self.bank_bic = self.user.bank_account.BIC
+        self.bank_name_field.value = self.bank_name = self.user.bank_account.name
+        self.bank_iban_field.value = self.bank_iban = self.user.bank_account.IBAN
+        self.vat_number_field.value = self.vat_number = self.user.VAT_number
 
     def update_form_data(self, user: User):
         """Updates the user's data with the form data"""
@@ -77,32 +75,35 @@ def on_bank_name_changed(self, e):
 
     def build(self):
         """Called when form is built"""
+        self.vat_number_field = views.get_std_txt_field(
+            on_change=self.on_vat_number_changed,
+            label="VAT Number",
+            hint="Value Added Tax number of the user, legally required for invoices.",
+        )
+        self.bank_name_field = views.get_std_txt_field(
+            on_change=self.on_bank_name_changed,
+            label="Name",
+            hint="Name of account",
+        )
+        self.bank_iban_field = views.get_std_txt_field(
+            on_change=self.on_bank_iban_changed,
+            label="IBAN",
+            hint="International Bank Account Number",
+        )
+        self.bank_ibc_field = views.get_std_txt_field(
+            on_change=self.on_bank_bic_changed,
+            label="BIC",
+            hint="Bank Identifier Code",
+        )
         return Column(
             spacing=dimens.SPACE_MD,
             controls=[
-                views.get_std_txt_field(
-                    on_change=self.on_vat_number_changed,
-                    label="VAT Number",
-                    hint="Value Added Tax number of the user, legally required for invoices.",
-                    initial_value=self.vat_number,
-                ),
+                self.vat_number_field,
                 views.xsSpace,
                 views.get_sub_heading_txt("Bank Account"),
-                views.get_std_txt_field(
-                    on_change=self.on_bank_name_changed,
-                    label="Name",
-                    initial_value=self.bank_name,
-                ),
-                views.get_std_txt_field(
-                    on_change=self.on_bank_iban_changed,
-                    label="IBAN",
-                    initial_value=self.bank_iban,
-                ),
-                views.get_std_txt_field(
-                    on_change=self.on_bank_bic_changed,
-                    label="BIC",
-                    initial_value=self.bank_bic,
-                ),
+                self.bank_name_field,
+                self.bank_iban_field,
+                self.bank_ibc_field,
                 views.stdSpace,
                 views.get_primary_btn(
                     label="Save",
@@ -347,13 +348,13 @@ class SplashScreen(TuttleView, UserControl):
     def __init__(
         self,
         params: TuttleViewParams,
-        install_demo_data_callback,
+        on_install_demo_data: Callable,
     ):
         super().__init__(params=params)
         self.keep_back_stack = False  # User cannot go back from this screen
         self.intent = AuthIntent()
-        self.install_demo_data_callback = install_demo_data_callback
         self.client_storage = params.client_storage
+        self.on_install_demo_data = on_install_demo_data
 
     def show_login_if_signed_out_else_redirect(self):
         result = self.intent.get_user_if_exists()
@@ -391,8 +392,9 @@ def set_login_form(self):
         self.update_self()
 
     def on_proceed_with_demo_data_clicked(self, e):
-        self.install_demo_data_callback()
-        self.navigate_to_route(res_utils.HOME_SCREEN_ROUTE)
+        """when the user clicks on the proceed with demo data button"""
+        self.on_install_demo_data()  # install demo data
+        self.navigate_to_route(res_utils.HOME_SCREEN_ROUTE)  # navigate to home screen
 
     def did_mount(self):
         self.mounted = True
@@ -580,6 +582,7 @@ def build(self):
         )
 
     def did_mount(self):
+
         """Called when the view is mounted on page"""
         self.mounted = True
         result: IntentResult = self.intent.get_user_if_exists()
@@ -638,6 +641,7 @@ def build(self):
         return profile_destination_content_wrapper(self.user_info_content)
 
     def did_mount(self):
+
         """Called when the view is mounted on page"""
         self.mounted = True
         result: IntentResult = self.intent.get_user_if_exists()
@@ -673,11 +677,15 @@ def on_update_payment_info(self, user: User):
             self.show_snack(result.error_msg, is_error=True)
 
     def build(self):
+        self.payment_data_form = PaymentDataForm(
+            on_form_submit=self.on_update_payment_info,
+        )
         self.payment_info_content = [
             views.get_heading(
                 "Payment Settings",
                 size=fonts.HEADLINE_4_SIZE,
             ),
+            self.payment_data_form,
         ]
         return profile_destination_content_wrapper(self.payment_info_content)
 
@@ -691,11 +699,7 @@ def did_mount(self):
         else:
             self.user_profile: User = result.data
             # setup payment info form
-            self.payment_data_form = PaymentDataForm(
-                on_form_submit=self.on_update_payment_info,
-                user=self.user_profile,
-            )
-            self.payment_info_content.append(self.payment_data_form)
+            self.payment_data_form.update_form_data(user=self.user_profile)
             self.update_self()
 
     def will_unmount(self):