Added auth & improved database

tests/custom/database/src/model/city.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+from typing import Optional
+
+from cpl.core.typing import SerialId
+from cpl.database.abc.db_model_abc import DbModelABC
+
+
+class City(DbModelABC):
+    def __init__(
+        self,
+        id: int,
+        name: str,
+        zip: str,
+        deleted: bool = False,
+        editor_id: Optional[SerialId] = None,
+        created: Optional[datetime] = None,
+        updated: Optional[datetime] = None,
+    ):
+        DbModelABC.__init__(self, id, deleted, editor_id, created, updated)
+        self._name = name
+        self._zip = zip
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def zip(self) -> str:
+        return self._zip

tests/custom/database/src/model/city_dao.py

@@ -0,0 +1,11 @@
+from cpl.database.abc import DbModelDaoABC
+from model.city import City
+
+
+class CityDao(DbModelDaoABC[City]):
+
+    def __init__(self):
+        DbModelDaoABC.__init__(self, __name__, City, "city")
+
+        self.attribute(City.name, str)
+        self.attribute(City.zip, int)

tests/custom/database/src/model/city_model.py

@@ -1,54 +0,0 @@
-from cpl.database.abc.table_abc import TableABC
-
-
-class CityModel(TableABC):
-    def __init__(self, name: str, zip_code: str, id=0):
-        self.CityId = id
-        self.Name = name
-        self.ZIP = zip_code
-
-    @staticmethod
-    def get_create_string() -> str:
-        return str(
-            f"""
-            CREATE TABLE IF NOT EXISTS `City` (
-                `CityId` INT(30) NOT NULL AUTO_INCREMENT,
-                `Name` VARCHAR(64) NOT NULL,
-                `ZIP` VARCHAR(5) NOT NULL,
-                PRIMARY KEY(`CityId`)
-            );
-        """
-        )
-
-    @property
-    def insert_string(self) -> str:
-        return str(
-            f"""
-            INSERT INTO `City` (
-                `Name`, `ZIP`
-            ) VALUES (
-                '{self.Name}',
-                '{self.ZIP}'
-            );
-        """
-        )
-
-    @property
-    def udpate_string(self) -> str:
-        return str(
-            f"""
-            UPDATE `City`
-            SET `Name` = '{self.Name}', 
-            `ZIP` = '{self.ZIP}',
-            WHERE `CityId` = {self.Id};
-        """
-        )
-
-    @property
-    def delete_string(self) -> str:
-        return str(
-            f"""
-            DELETE FROM `City`
-            WHERE `CityId` = {self.Id};
-        """
-        )

tests/custom/database/src/model/user.py

@@ -1,9 +1,23 @@
+from datetime import datetime
+from typing import Optional
+
+from cpl.core.typing import SerialId
 from cpl.database.abc.db_model_abc import DbModelABC
 
 
 class User(DbModelABC):
-    def __init__(self, id: int, name: str, city_id: int = 0):
-        DbModelABC.__init__(self, id)
+
+    def __init__(
+        self,
+        id: int,
+        name: str,
+        city_id: int = 0,
+        deleted: bool = False,
+        editor_id: Optional[SerialId] = None,
+        created: Optional[datetime] = None,
+        updated: Optional[datetime] = None,
+    ):
+        DbModelABC.__init__(self, id, deleted, editor_id, created, updated)
         self._name = name
         self._city_id = city_id
 
@@ -13,4 +27,4 @@ class User(DbModelABC):
 
     @property
     def city_id(self) -> int:
-        return self._city_id
+        return self._city_id

tests/custom/database/src/model/user_dao.py

@@ -1,4 +1,3 @@
-from cpl.database import InternalTables
 from cpl.database.abc import DbModelDaoABC
 from model.user import User
 
@@ -6,7 +5,7 @@ from model.user import User
 class UserDao(DbModelDaoABC[User]):
 
     def __init__(self):
-        DbModelDaoABC.__init__(self, __name__, User, InternalTables.users)
+        DbModelDaoABC.__init__(self, __name__, User, "users")
 
         self.attribute(User.name, str)
         self.attribute(User.city_id, int, db_name="CityId")

tests/custom/database/src/model/user_model.py

@@ -1,56 +0,0 @@
-from cpl.database.abc.table_abc import TableABC
-from .city_model import CityModel
-
-
-class UserModel(TableABC):
-    def __init__(self, name: str, city: CityModel, id=0):
-        self.UserId = id
-        self.Name = name
-        self.CityId = city.CityId if city is not None else 0
-        self.City = city
-
-    @staticmethod
-    def get_create_string() -> str:
-        return str(
-            f"""
-            CREATE TABLE IF NOT EXISTS `User` (
-                `UserId` INT(30) NOT NULL AUTO_INCREMENT,
-                `Name` VARCHAR(64) NOT NULL,
-                `CityId` INT(30),
-                FOREIGN KEY (`UserId`) REFERENCES City(`CityId`),
-                PRIMARY KEY(`UserId`)
-            );
-        """
-        )
-
-    @property
-    def insert_string(self) -> str:
-        return str(
-            f"""
-            INSERT INTO `User` (
-                `Name`
-            ) VALUES (
-                '{self.Name}'
-            );
-        """
-        )
-
-    @property
-    def udpate_string(self) -> str:
-        return str(
-            f"""
-            UPDATE `User`
-            SET `Name` = '{self.Name}', 
-            `CityId` = {self.CityId},
-            WHERE `UserId` = {self.UserId};
-        """
-        )
-
-    @property
-    def delete_string(self) -> str:
-        return str(
-            f"""
-            DELETE FROM `User`
-            WHERE `UserId` = {self.UserId};
-        """
-        )

tests/custom/database/src/model/user_repo.py

@@ -1,38 +0,0 @@
-from cpl.database.abc.db_context_abc import DBContextABC
-from .city_model import CityModel
-from .user_model import UserModel
-from .user_repo_abc import UserRepoABC
-
-
-class UserRepo(UserRepoABC):
-    def __init__(self, db_context: DBContextABC):
-        UserRepoABC.__init__(self)
-
-        self._db_context: DBContextABC = db_context
-
-    def add_test_user(self):
-        city = CityModel("Haren", "49733")
-        city2 = CityModel("Meppen", "49716")
-        self._db_context.execute(city2.insert_string)
-        user = UserModel("TestUser", city)
-        self._db_context.execute(user.insert_string)
-
-    async def get_users(self) -> list[UserModel]:
-        users = []
-        results = await self._db_context.select("SELECT * FROM `User`")
-        for result in results:
-            users.append(UserModel(result[1], await self.get_city_by_id(result[2]), id=result[0]))
-        return users
-
-    async def get_cities(self) -> list[CityModel]:
-        cities = []
-        results = await self._db_context.select("SELECT * FROM `City`")
-        for result in results:
-            cities.append(CityModel(result[1], result[2], id=result[0]))
-        return cities
-
-    async def get_city_by_id(self, id: int) -> CityModel:
-        if id is None:
-            return None
-        result = await self._db_context.select(f"SELECT * FROM `City` WHERE `Id` = {id}")
-        return CityModel(result[1], result[2], id=result[0])

tests/custom/database/src/model/user_repo_abc.py

@@ -1,22 +0,0 @@
-from abc import ABC, abstractmethod
-
-from .city_model import CityModel
-from .user_model import UserModel
-
-
-class UserRepoABC(ABC):
-    @abstractmethod
-    def __init__(self):
-        pass
-
-    @abstractmethod
-    def get_users(self) -> list[UserModel]:
-        pass
-
-    @abstractmethod
-    def get_cities(self) -> list[CityModel]:
-        pass
-
-    @abstractmethod
-    def get_city_by_id(self, id: int) -> CityModel:
-        pass