Moving requests to resource

api/app/account/resource.py

@@ -1,68 +1,58 @@
+from sqlmodel import select
+
+from account.models import Account
+
 class AccountResource:
     @classmethod
     def get_by_path(cls, session, path):
         if not path:
             return None
 
-        return session.exec(select(cls).where(cls.path == path)).first()
+        return session.exec(select(Account).where(Account.path == path)).first()
 
-    def get_parent(self, session):
-        if self.parent_account_id is None:
+    @classmethod
+    def get_parent(cls, session, model):
+        if model.parent_account_id is None:
             return None
 
-        self.parent_account = self.get(session, self.parent_account_id)
-        return self.parent_account
-
-    def compute_path(self, session):
-        if self.parent_account_id is None:
-            self.path = self.get_root_path()
-        else:
-            self.parent_account = self.get(session, self.parent_account_id)
-            self.path = self.parent_account.get_child_path(self)
-
-        return self.path
-
-    def compute_family(self):
-        if self.type in Asset:
-            self.family = AccountFamily.Asset.value
-        elif self.type in Liability:
-            self.family = AccountFamily.Liability.value
-        else:
-            self.family = self.type
-        return self.family
+        model.parent_account = cls.get(session, model.parent_account_id)
+        return model.parent_account
 
     @classmethod
     def schema_to_model(cls, session, schema, model=None):
         try:
             if model:
-                model = cls.model_validate(model, update=schema)
+                model = Account.model_validate(model, update=schema)
             else:
                 schema.path = ""
                 schema.family = ""
-                model = cls.model_validate(schema)
+                model = Account.model_validate(schema)
         except Exception as e:
             print(e)
+            raise
 
         model.compute_family()
-        model.validate_parent(session)
-        model.compute_path(session)
+        cls.validate_parent(session, model)
+        model.compute_path()
         return model
 
-    def validate_parent(self, session):
-        if self.parent_account_id is None:
+    @classmethod
+    def validate_parent(cls, session, model):
+        if model.parent_account_id is None:
             return True
 
-        parent = self.get_parent(session)
+        parent = cls.get_parent(session, model)
         if not parent:
             raise KeyError("Parent account not found.")
 
-        if parent.family != self.family:
+        if parent.family != model.family:
             raise ValueError("Account family mismatch with parent account..")
 
-        if self.path and parent.path.startswith(self.path):
+        if model.path and parent.path.startswith(model.path):
             raise ValueError("Parent Account is descendant")
 
-        return True
+        model.parent_account = parent
+        return model
 
     @classmethod
     def create(cls, account, session):