join tested auth service login/select completed

api_services/api_controllers/postgres/mixin.py

@@ -1,12 +1,18 @@
 import arrow
+import datetime
 
-from sqlalchemy import Column, Integer, String, Float, ForeignKey, UUID, TIMESTAMP, Boolean, SmallInteger, Numeric, func, text
+from decimal import Decimal
+from typing import Any, Optional
+
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, UUID, TIMESTAMP, Boolean, SmallInteger, Numeric, func, text, NUMERIC
 from sqlalchemy.orm import relationship
 from sqlalchemy.orm import Mapped, mapped_column
 from sqlalchemy_mixins.serialize import SerializeMixin
 from sqlalchemy_mixins.repr import ReprMixin
 from sqlalchemy_mixins.smartquery import SmartQueryMixin
 from sqlalchemy_mixins.activerecord import ActiveRecordMixin
+from sqlalchemy.orm import InstrumentedAttribute, Mapped
+
 from api_controllers.postgres.engine import get_db, Base
 
 
@@ -26,6 +32,100 @@ class BasicMixin(
         """Get database session."""
         return get_db()
 
+    @classmethod
+    def iterate_over_variables(cls, val: Any, key: str) -> tuple[bool, Optional[Any]]:
+        """
+        Process a field value based on its type and convert it to the appropriate format.
+
+        Args:
+            val: Field value
+            key: Field name
+
+        Returns:
+            Tuple of (should_include, processed_value)
+        """
+        try:
+            key_ = cls.__annotations__.get(key, None)
+            is_primary = key in getattr(cls, "primary_keys", [])
+            row_attr = bool(getattr(getattr(cls, key), "foreign_keys", None))
+
+            # Skip primary keys and foreign keys
+            if is_primary or row_attr:
+                return False, None
+
+            if val is None:  # Handle None values
+                return True, None
+
+            if str(key[-5:]).lower() == "uu_id":  # Special handling for UUID fields
+                return True, str(val)
+
+            if key_:  # Handle typed fields
+                if key_ == Mapped[int]:
+                    return True, int(val)
+                elif key_ == Mapped[bool]:
+                    return True, bool(val)
+                elif key_ == Mapped[float] or key_ == Mapped[NUMERIC]:
+                    return True, round(float(val), 3)
+                elif key_ == Mapped[TIMESTAMP]:
+                    return True, str(arrow.get(str(val)).format("YYYY-MM-DD HH:mm:ss"))
+                elif key_ == Mapped[str]:
+                    return True, str(val)
+            else:  # Handle based on Python types
+                if isinstance(val, datetime.datetime):
+                    return True, str(arrow.get(str(val)).format("YYYY-MM-DD HH:mm:ss"))
+                elif isinstance(val, bool):
+                    return True, bool(val)
+                elif isinstance(val, (float, Decimal)):
+                    return True, round(float(val), 3)
+                elif isinstance(val, int):
+                    return True, int(val)
+                elif isinstance(val, str):
+                    return True, str(val)
+                elif val is None:
+                    return True, None
+            return False, None
+
+        except Exception as e:
+            err = e
+            return False, None
+
+    def get_dict(self, exclude_list: Optional[list[InstrumentedAttribute]] = None) -> dict[str, Any]:
+        """
+        Convert model instance to dictionary with customizable fields.
+
+        Args:
+            exclude_list: List of fields to exclude from the dictionary
+
+        Returns:
+            Dictionary representation of the model
+        """
+        try:
+            return_dict: Dict[str, Any] = {}
+            exclude_list = exclude_list or []
+            exclude_list = [exclude_arg.key for exclude_arg in exclude_list]
+
+            # Get all column names from the model
+            columns = [col.name for col in self.__table__.columns]
+            columns_set = set(columns)
+
+            # Filter columns
+            columns_list = set([col for col in columns_set if str(col)[-2:] != "id"])
+            columns_extend = set(col for col in columns_set if str(col)[-5:].lower() == "uu_id")
+            columns_list = set(columns_list) | set(columns_extend)
+            columns_list = list(set(columns_list) - set(exclude_list))
+
+            for key in columns_list:
+                val = getattr(self, key)
+                correct, value_of_database = self.iterate_over_variables(val, key)
+                if correct:
+                    return_dict[key] = value_of_database
+
+            return return_dict
+
+        except Exception as e:
+            err = e
+            return {}
+
 
 class CrudMixin(BasicMixin):
     """